Remove some old RMG-java loading feature

This was deprecated a long time ago.

Author: rwest

rmgpy/rmg/main.py

@@ -52,7 +52,7 @@
 from scipy.optimize import brute
 
 import rmgpy.util as util
-from rmgpy.rmg.model import Species, CoreEdgeReactionModel
+from rmgpy.rmg.model import Species
 from rmgpy.rmg.pdep import PDepNetwork
 from rmgpy import settings
 from rmgpy.chemkin import ChemkinWriter
@@ -2031,191 +2031,6 @@ def log_header(self, level=logging.INFO):
                 logging.log(level, database_conda_package)
                 logging.log(level, '')
 
-    def load_rmg_java_input(self, path):
-        """
-        Load an RMG-Java job from the input file located at `input_file`, or
-        from the `input_file` attribute if not given as a parameter.
-        """
-        warnings.warn("The RMG-Java input is no longer supported and may be"
-                      " removed in version 2.3.", DeprecationWarning)
-        # NOTE: This function is currently incomplete!
-        # It only loads a subset of the available information.
-
-        self.reaction_model = CoreEdgeReactionModel()
-        self.initial_species = []
-        self.reaction_systems = []
-
-        T_list = []
-        P_list = []
-        concentration_list = []
-        species_dict = {}
-        termination = []
-
-        with open(path, 'r') as f:
-            line = self.read_meaningful_line_java(f)
-            while line != '':
-
-                if line.startswith('TemperatureModel:'):
-                    tokens = line.split()
-                    units = tokens[2][1:-1]
-                    assert units in ['C', 'F', 'K']
-                    if units == 'C':
-                        T_list = [float(T) + 273.15 for T in tokens[3:]]
-                    elif units == 'F':
-                        T_list = [(float(T) + 459.67) * 5. / 9. for T in tokens[3:]]
-                    else:
-                        T_list = [float(T) for T in tokens[3:]]
-
-                elif line.startswith('PressureModel:'):
-                    tokens = line.split()
-                    units = tokens[2][1:-1]
-                    assert units in ['atm', 'bar', 'Pa', 'torr']
-                    if units == 'atm':
-                        P_list = [float(P) * 101325. for P in tokens[3:]]
-                    elif units == 'bar':
-                        P_list = [float(P) * 100000. for P in tokens[3:]]
-                    elif units == 'torr':
-                        P_list = [float(P) / 760. * 101325. for P in tokens[3:]]
-                    else:
-                        P_list = [float(P) for P in tokens[3:]]
-
-                elif line.startswith('InitialStatus:'):
-                    label = ''
-                    concentrations = []
-                    adjlist = ''
-
-                    line = self.read_meaningful_line_java(f)
-                    while line != 'END':
-
-                        if line == '' and label != '':
-                            species = Species(label=label, molecule=[Molecule().from_adjacency_list(adjlist)])
-                            self.initial_species.append(species)
-                            species_dict[label] = species
-                            concentration_list.append(concentrations)
-                            label = ''
-                            concentrations = []
-                            adjlist = ''
-
-                        elif line != '' and label == '':
-                            tokens = line.split()
-                            label = tokens[0]
-                            units = tokens[1][1:-1]
-                            if tokens[-1] in ['Unreactive', 'ConstantConcentration']:
-                                tokens.pop(-1)
-                            assert units in ['mol/cm3', 'mol/m3', 'mol/l']
-                            if units == 'mol/cm3':
-                                concentrations = [float(C) * 1.0e6 for C in tokens[2:]]
-                            elif units == 'mol/l':
-                                concentrations = [float(C) * 1.0e3 for C in tokens[2:]]
-                            else:
-                                concentrations = [float(C) for C in tokens[2:]]
-
-                        elif line != '':
-                            adjlist += line + '\n'
-
-                        line = f.readline().strip()
-                        if '//' in line:
-                            line = line[0:line.index('//')]
-
-                elif line.startswith('InertGas:'):
-
-                    line = self.read_meaningful_line_java(f)
-                    while line != 'END':
-
-                        tokens = line.split()
-                        label = tokens[0]
-                        assert label in ['N2', 'Ar', 'He', 'Ne']
-                        if label == 'Ne':
-                            smiles = '[Ne]'
-                        elif label == 'Ar':
-                            smiles = '[Ar]'
-                        elif label == 'He':
-                            smiles = '[He]'
-                        else:
-                            smiles = 'N#N'
-                        units = tokens[1][1:-1]
-                        assert units in ['mol/cm3', 'mol/m3', 'mol/l']
-                        if units == 'mol/cm3':
-                            concentrations = [float(C) * 1.0e6 for C in tokens[2:]]
-                        elif units == 'mol/l':
-                            concentrations = [float(C) * 1.0e3 for C in tokens[2:]]
-                        else:
-                            concentrations = [float(C) for C in tokens[2:]]
-
-                        species = Species(label=label, reactive=False, molecule=[Molecule().from_smiles(smiles)])
-                        self.initial_species.append(species)
-                        species_dict[label] = species
-                        concentration_list.append(concentrations)
-
-                        line = self.read_meaningful_line_java(f)
-
-                elif line.startswith('FinishController:'):
-
-                    # First meaningful line is a termination time or conversion
-                    line = self.read_meaningful_line_java(f)
-                    tokens = line.split()
-                    if tokens[2].lower() == 'conversion:':
-                        label = tokens[3]
-                        conversion = float(tokens[4])
-                        termination.append(TerminationConversion(spec=species_dict[label], conv=conversion))
-                    elif tokens[2].lower() == 'reactiontime:':
-                        time = float(tokens[3])
-                        units = tokens[4][1:-1]
-                        assert units in ['sec', 'min', 'hr', 'day']
-                        if units == 'min':
-                            time *= 60.
-                        elif units == 'hr':
-                            time *= 60. * 60.
-                        elif units == 'day':
-                            time *= 60. * 60. * 24.
-                        termination.append(TerminationTime(time=time))
-
-                    # Second meaningful line is the error tolerance
-                    # We're not doing anything with this information yet!
-                    line = self.read_meaningful_line_java(f)
-
-                line = self.read_meaningful_line_java(f)
-
-        assert len(T_list) > 0
-        assert len(P_list) > 0
-        concentration_list = np.array(concentration_list)
-        # An arbitrary number of concentrations is acceptable, and should be run for each reactor system
-        if not concentration_list.shape[1] > 0:
-            raise AssertionError()
-
-        # Make a reaction system for each (T,P) combination
-        for T in T_list:
-            for P in P_list:
-                for i in range(concentration_list.shape[1]):
-                    concentrations = concentration_list[:, i]
-                    total_conc = np.sum(concentrations)
-                    initial_mole_fractions = dict([(self.initial_species[i], concentrations[i] / total_conc) for i in
-                                                   range(len(self.initial_species))])
-                    reaction_system = SimpleReactor(T, P, initial_mole_fractions=initial_mole_fractions,
-                                                   termination=termination)
-                    self.reaction_systems.append(reaction_system)
-
-    def read_meaningful_line_java(self, f):
-        """
-        Read a meaningful line from an RMG-Java condition file object `f`,
-        returning the line with any comments removed.
-        """
-        warnings.warn("The RMG-Java input is no longer supported and may be"
-                      " removed in version 2.3.", DeprecationWarning)
-        line = f.readline()
-        if line != '':
-            line = line.strip()
-            if '//' in line:
-                line = line[0:line.index('//')]
-            while line == '':
-                line = f.readline()
-                if line == '':
-                    break
-                line = line.strip()
-                if '//' in line:
-                    line = line[0:line.index('//')]
-        return line
-
 
 ################################################################################