Exemplo n.º 1
0
def get_smiles(base_path, molecules, extra=False):
    """
    Returns SMILES strings for a set of molecules

    :param base_path: Directory to begin search in.
    :param molecules: List of strings representing molecule IDs.
    :param extra: If True (default False), give molecule ID with SMILES
    :return: list of SMILES strings
    """

    smiles = []

    if base_path is not None:
        for mol in molecules:
            path = join(base_path, mol)
            molfile = join(path, "{}.mol".format(mol))

            obmol = BabelMolAdaptor.from_file(molfile, file_format="mol")

            smi = obmol.pybel_mol.write("smi").replace("\t\n", "")

            if extra:
                smiles.append((smi, mol))
            else:
                smiles.append(smi)

        return smiles
    else:
        raise ValueError("No path given.")
Exemplo n.º 2
0
    def run(self, site_property=None):
        """
        Write the input file to the scratch directory, run packmol and return
        the packed molecule to the current working directory.

        Args:
            site_property (str): if set then the specified site property
                for the the final packed molecule will be restored.

        Returns:
                Molecule object
        """
        with tempfile.TemporaryDirectory() as scratch_dir:
            self._write_input(input_dir=scratch_dir)
            with open(os.path.join(scratch_dir, self.input_file),
                      "r") as packmol_input:
                with Popen(self.packmol_bin,
                           stdin=packmol_input,
                           stdout=PIPE,
                           stderr=PIPE) as p:
                    (stdout, stderr) = p.communicate()
            output_file = os.path.join(self.control_params["output"])
            if os.path.isfile(output_file):
                packed_mol = BabelMolAdaptor.from_file(
                    output_file, self.control_params["filetype"])
                packed_mol = packed_mol.pymatgen_mol
                print("packed molecule written to {}".format(
                    self.control_params["output"]))
                if site_property:
                    packed_mol = self.restore_site_properties(
                        site_property=site_property, filename=output_file)
                return packed_mol
            raise RuntimeError("Packmol execution failed. %s\n%s" %
                               (stdout, stderr))
Exemplo n.º 3
0
 def test_from_file_return_all_molecules(self):
     adaptors = BabelMolAdaptor.from_file(
         os.path.join(PymatgenTest.TEST_FILES_DIR, "multiple_frame_xyz.xyz"),
         "xyz",
         return_all_molecules=True,
     )
     self.assertEqual(len(adaptors), 302)
Exemplo n.º 4
0
    def restore_site_properties(self, site_property="ff_map", filename=None):
        """
        Restore the site properties for the final packed molecule.

        Args:
            site_property (str):
            filename (str): path to the final packed molecule.

        Returns:
            Molecule
        """

        # only for pdb
        if not self.control_params["filetype"] == "pdb":
            raise

        filename = filename or self.control_params["output"]
        bma = BabelMolAdaptor.from_file(filename, "pdb")
        pbm = pb.Molecule(bma._obmol)

        assert len(pbm.residues) == sum([x["number"] for x in self.param_list])

        packed_mol = self.convert_obatoms_to_molecule(
            pbm.residues[0].atoms, residue_name=pbm.residues[0].name,
            site_property=site_property)

        for resid in pbm.residues[1:]:
            mol = self.convert_obatoms_to_molecule(
                resid.atoms, residue_name=resid.name, site_property=site_property)
            for site in mol:
                packed_mol.append(site.species_and_occu, site.coords,
                                  properties=site.properties)

        return packed_mol
Exemplo n.º 5
0
    def run(self, copy_to_current_on_exit=False, site_property=None):
        """
        Write the input file to the scratch directory, run packmol and return
        the packed molecule.

        Args:
            copy_to_current_on_exit (bool): Whether or not to copy the packmol
                input/output files from the scratch directory to the current
                directory.
            site_property (str): if set then the specified site property
                for the the final packed molecule will be restored.

        Returns:
                Molecule object
        """
        scratch = tempfile.gettempdir()
        with ScratchDir(scratch, copy_to_current_on_exit=copy_to_current_on_exit) as scratch_dir:
            self._write_input(input_dir=scratch_dir)
            packmol_input = open(os.path.join(scratch_dir, self.input_file), 'r')
            p = Popen(self.packmol_bin, stdin=packmol_input, stdout=PIPE, stderr=PIPE)
            (stdout, stderr) = p.communicate()
            output_file = os.path.join(scratch_dir, self.control_params["output"])
            if os.path.isfile(output_file):
                packed_mol = BabelMolAdaptor.from_file(output_file,
                                                       self.control_params["filetype"])
                packed_mol = packed_mol.pymatgen_mol
                print("packed molecule written to {}".format(
                    self.control_params["output"]))
                if site_property:
                    packed_mol = self.restore_site_properties(site_property=site_property, filename=output_file)
                return packed_mol
            else:
                print("Packmol execution failed")
                print(stdout, stderr)
                return None
Exemplo n.º 6
0
    def restore_site_properties(self, site_property="ff_map", filename=None):
        """
        Restore the site properties for the final packed molecule.

        Args:
            site_property (str):
            filename (str): path to the final packed molecule.

        Returns:
            Molecule
        """

        # only for pdb
        if not self.control_params["filetype"] == "pdb":
            raise ValueError()

        filename = filename or self.control_params["output"]
        bma = BabelMolAdaptor.from_file(filename, "pdb")
        pbm = pb.Molecule(bma._obmol)

        assert len(pbm.residues) == sum(x["number"] for x in self.param_list)

        packed_mol = self.convert_obatoms_to_molecule(
            pbm.residues[0].atoms,
            residue_name=pbm.residues[0].name,
            site_property=site_property,
        )

        for resid in pbm.residues[1:]:
            mol = self.convert_obatoms_to_molecule(resid.atoms, residue_name=resid.name, site_property=site_property)
            for site in mol:
                packed_mol.append(site.species, site.coords, properties=site.properties)

        return packed_mol
Exemplo n.º 7
0
    def run(self, copy_to_current_on_exit=False, site_property=None):
        """
        Write the input file to the scratch directory, run packmol and return
        the packed molecule.

        Args:
            copy_to_current_on_exit (bool): Whether or not to copy the packmol
                input/output files from the scratch directory to the current
                directory.
            site_property (str): if set then the specified site property
                for the the final packed molecule will be restored.

        Returns:
                Molecule object
        """
        scratch = tempfile.gettempdir()
        with ScratchDir(scratch, copy_to_current_on_exit=copy_to_current_on_exit) as scratch_dir:
            self._write_input(input_dir=scratch_dir)
            packmol_input = open(os.path.join(scratch_dir, self.input_file), 'r')
            p = Popen(self.packmol_bin, stdin=packmol_input, stdout=PIPE, stderr=PIPE)
            (stdout, stderr) = p.communicate()
            output_file = os.path.join(scratch_dir, self.control_params["output"])
            if os.path.isfile(output_file):
                packed_mol = BabelMolAdaptor.from_file(output_file,
                                                       self.control_params["filetype"])
                packed_mol = packed_mol.pymatgen_mol
                print("packed molecule written to {}".format(
                    self.control_params["output"]))
                if site_property:
                    packed_mol = self.restore_site_properties(site_property=site_property, filename=output_file)
                return packed_mol
            else:
                print("Packmol execution failed")
                print(stdout, stderr)
                return None
Exemplo n.º 8
0
    def run(self, copy_to_current_on_exit=False):
        """
        Write the input file to the scratch directory, run packmol and return
        the packed molecule.

        Args:
            copy_to_current_on_exit (bool): Whether or not to copy the packmol
                input/output files from the scratch directory to the current
                directory.

        Returns:
                Molecule object
        """
        scratch = tempfile.gettempdir()
        with ScratchDir(scratch, copy_to_current_on_exit=copy_to_current_on_exit) as scratch_dir:
            self._write_input(input_dir=scratch_dir)
            packmol_bin = ['packmol']
            packmol_input = open(os.path.join(scratch_dir, self.input_file), 'r')
            p = Popen(packmol_bin, stdin=packmol_input, stdout=PIPE, stderr=PIPE)
            p.wait()
            (stdout, stderr) = p.communicate()
            output_file = os.path.join(scratch_dir, self.control_params["output"])
            if os.path.isfile(output_file):
                packed_mol = BabelMolAdaptor.from_file(output_file)
                print("packed molecule written to {}".format(
                    self.control_params["output"]))
                return packed_mol.pymatgen_mol
            else:
                print("Packmol execution failed")
                print(stdout, stderr)
                return None
Exemplo n.º 9
0
def read_mol(filename):
    """
    Reads a molecule based on file extension. For example, anything ending in
    a "xyz" is assumed to be a XYZ file. Supported formats include xyz,
    gaussian input (gjf|g03|g09|com|inp), Gaussian output (.out|and
    pymatgen's JSON serialized molecules. Using openbabel,
    many more extensions are supported but requires openbabel to be installed.

    Args:
        filename (str): A filename to read from.

    Returns:
        A Molecule object.
    """
    fname = os.path.basename(filename)
    if fnmatch(fname.lower(), "*.xyz*"):
        return XYZ.from_file(filename).molecule
    elif any([fnmatch(fname.lower(), "*.{}*".format(r)) for r in ["gjf", "g03", "g09", "com", "inp"]]):
        return GaussianInput.from_file(filename).molecule
    elif any([fnmatch(fname.lower(), "*.{}*".format(r)) for r in ["out", "lis", "log"]]):
        return GaussianOutput(filename).final_structure
    elif fnmatch(fname, "*.json*") or fnmatch(fname, "*.mson*"):
        with zopen(filename) as f:
            s = json.load(f, cls=MontyDecoder)
            if type(s) != Molecule:
                raise IOError("File does not contain a valid serialized " "molecule")
            return s
    else:
        m = re.search("\.(pdb|mol|mdl|sdf|sd|ml2|sy2|mol2|cml|mrv)", filename.lower())
        if m:
            return BabelMolAdaptor.from_file(filename, m.group(1)).pymatgen_mol

    raise ValueError("Unrecognized file extension!")
Exemplo n.º 10
0
    def run(self):
        """
        Runs packmol

        Returns:
                Molecule object
        """
        scratch = tempfile.gettempdir()
        with ScratchDir(scratch, copy_to_current_on_exit=True) as d:
            with open(os.path.join(d, self.input_file), 'wt',
                      encoding="utf-8") as inp:
                for k, v in six.iteritems(self.control_params):
                    inp.write('{} {}\n'.format(k, self._format_param_val(v)))
                for idx, mol in enumerate(self.mols):
                    a = BabelMolAdaptor(mol)
                    pm = pb.Molecule(a.openbabel_mol)
                    pm.write(self.control_params["filetype"],
                             filename=os.path.join(d, '{}.{}'.format(idx,
                                                                     self.control_params[
                                                                         "filetype"])).encode(
                                 "ascii"),
                             overwrite=True)
                    inp.write("\n")
                    inp.write(
                        "structure {}.{}\n".format(os.path.join(d, str(idx)),
                                                   self.control_params[
                                                       "filetype"]))
                    for k, v in six.iteritems(self.param_list[idx]):
                        inp.write(
                            '  {} {}\n'.format(k, self._format_param_val(v)))
                    inp.write('end structure\n')
            proc = Popen(['packmol'],
                         stdin=open(os.path.join(d, self.input_file), 'r'),
                         stdout=PIPE)
            (stdout, stderr) = proc.communicate()
            output_file = os.path.join(d, self.control_params["output"])
            if os.path.isfile(output_file):
                packed_mol = BabelMolAdaptor.from_file(output_file)
                print("packed molecule written to {}".format(
                    self.control_params["output"]))
                return packed_mol.pymatgen_mol
            else:
                print("Packmol execution failed")
                print(stdout, stderr)
                return None
Exemplo n.º 11
0
def get_molecule(molfile):
    """
    Create pymatgen Molecule object from molecule data file.

    In addition to parsing the input, this function also performs a conformer
    search to get a reasonable starting structure.

    :param molfile: Absolute path to structure file (.mol, .sdf, etc.)
    :return: Molecule.
    """

    obmol = BabelMolAdaptor.from_file(molfile, file_format="mol")
    # OBMolecule does not contain pymatgen Molecule information
    # So, we need to wrap the obmol in a BabelMolAdapter and extract
    obmol.add_hydrogen()
    obmol.make3d()
    obmol.localopt()

    return obmol.pymatgen_mol
Exemplo n.º 12
0
def read_mol(filename):
    """
    Reads a molecule based on file extension. For example, anything ending in
    a "xyz" is assumed to be a XYZ file. Supported formats include xyz,
    gaussian input (gjf|g03|g09|com|inp), Gaussian output (.out|and
    pymatgen's JSON serialized molecules. Using openbabel,
    many more extensions are supported but requires openbabel to be installed.

    Args:
        filename (str): A filename to read from.

    Returns:
        A Molecule object.
    """
    fname = os.path.basename(filename)
    if fnmatch(fname.lower(), "*.xyz*"):
        return XYZ.from_file(filename).molecule
    elif any([
            fnmatch(fname.lower(), "*.{}*".format(r))
            for r in ["gjf", "g03", "g09", "com", "inp"]
    ]):
        return GaussianInput.from_file(filename).molecule
    elif any([
            fnmatch(fname.lower(), "*.{}*".format(r))
            for r in ["out", "lis", "log"]
    ]):
        return GaussianOutput(filename).final_structure
    elif fnmatch(fname, "*.json*") or fnmatch(fname, "*.mson*"):
        with zopen(filename) as f:
            s = json.load(f, cls=MontyDecoder)
            if type(s) != Molecule:
                raise IOError("File does not contain a valid serialized "
                              "molecule")
            return s
    else:
        m = re.search("\.(pdb|mol|mdl|sdf|sd|ml2|sy2|mol2|cml|mrv)",
                      filename.lower())
        if m:
            return BabelMolAdaptor.from_file(filename, m.group(1)).pymatgen_mol

    raise ValueError("Unrecognized file extension!")
Exemplo n.º 13
0
    def write_pdb(self, mol, filename, name=None, num=None):
        """
        dump the molecule into pdb file with custom residue name and number.
        """

        # ugly hack to get around the openbabel issues with inconsistent
        # residue labelling.
        scratch = tempfile.gettempdir()
        with ScratchDir(scratch, copy_to_current_on_exit=False) as _:
            mol.to(fmt="pdb", filename="tmp.pdb")
            bma = BabelMolAdaptor.from_file("tmp.pdb", "pdb")

        num = num or 1
        name = name or "ml{}".format(num)

        # bma = BabelMolAdaptor(mol)
        pbm = pb.Molecule(bma._obmol)
        for i, x in enumerate(pbm.residues):
            x.OBResidue.SetName(name)
            x.OBResidue.SetNum(num)

        pbm.write(format="pdb", filename=filename, overwrite=True)
Exemplo n.º 14
0
    def write_pdb(self, mol, filename, name=None, num=None):
        """
        dump the molecule into pdb file with custom residue name and number.
        """

        # ugly hack to get around the openbabel issues with inconsistent
        # residue labelling.
        scratch = tempfile.gettempdir()
        with ScratchDir(scratch, copy_to_current_on_exit=False) as _:
            mol.to(fmt="pdb", filename="tmp.pdb")
            bma = BabelMolAdaptor.from_file("tmp.pdb", "pdb")

        num = num or 1
        name = name or "ml{}".format(num)

        # bma = BabelMolAdaptor(mol)
        pbm = pb.Molecule(bma._obmol)
        for i, x in enumerate(pbm.residues):
            x.OBResidue.SetName(name)
            x.OBResidue.SetNum(num)

        pbm.write(format="pdb", filename=filename, overwrite=True)
Exemplo n.º 15
0
 def test_from_file(self):
     adaptor = BabelMolAdaptor.from_file(
         os.path.join(PymatgenTest.TEST_FILES_DIR, "molecules/Ethane_e.pdb"), "pdb"
     )
     mol = adaptor.pymatgen_mol
     self.assertEqual(mol.formula, "H6 C2")
Exemplo n.º 16
0
def main():
    def gcd(a, b):
        if b == 0:
            return a
        else:
            return gcd(b, a % b)

    def lcm(a, b):
        return a * b / gcd(a, b)

    import argparse
    parser = argparse.ArgumentParser(
        description="Place salt around a molecule")
    parser.add_argument("-m", "--molecule", dest="molecule", type=str,
                        required=True,
                        help="the file name of molecule")
    parser.add_argument("-l", "--ligand", dest="fragments", type=str,
                        nargs='+',
                        required=True,
                        help="the list of fragment file names to to be placed around the molecule")
    parser.add_argument("-n", "--nums_fragments", dest="nums_fragments",
                        type=int, nargs='+',
                        required=True,
                        help="the number of each fragment, the order must be the same with FRAGMENTS")
    parser.add_argument("-c", "--charge", dest="charge", type=int,
                        required=True,
                        help="total charge of the system")
    parser.add_argument("-t", "--taboo_tolerance", dest="taboo_tolerance",
                        type=float,
                        default=1.0,
                        help="The radius to taboo a solution (in Angstrom)")
    parser.add_argument("-r", "--ratio_taboo_particles",
                        dest="ratio_taboo_particles", type=float,
                        default=0.5,
                        help="ratio of particle within the tolerance to consider taboo current solution")
    parser.add_argument("-o", "--outputfile", dest="outputfile", type=str,
                        required=True,
                        help="the file name of the aligned conformer")
    parser.add_argument("-i", "--iterations", dest="iterations", type=int,
                        default=600,
                        help="maximum number of evaluations")
    parser.add_argument("-s", "--size", dest="size", type=int, default=15,
                        help="population size")
    parser.add_argument("-k", "--num_neighbours", dest="num_neighbours",
                        type=int, default=2,
                        help="number of neighbours")
    parser.add_argument("--force_ordered_fragment",
                        dest="force_ordered_fragment", action="store_true",
                        help="set this option to keep the fragment of the same in the order of input along the X-axis")
    parser.add_argument("--topology", dest="topology",
                        choices=["ring", "star"], type=str, default="ring",
                        help="the topology of the PSO information network")
    parser.add_argument("--initial_guess", dest="initial_guess",
                        choices=["breadth", "center", "volume"],
                        default="breadth",
                        help="where should particles should be initially put")
    parser.add_argument("--bound_setter", dest="bound_setter",
                        choices=["chain", "volume"], default="chain",
                        help="method to set the bound conditions of PSO")
    parser.add_argument("--always_write_best", dest="always_write_best",
                        action="store_true",
                        help="enable this option to output the best structure at every iteration")
    parser.add_argument("--random_seed", dest="random_seed", default=None,
                        type=int,
                        help="random seed for PSO, an integer is expected")
    parser.add_argument("--max_generations_each_conformer",
                        dest="max_generations_each_conformer", default=100,
                        type=int,
                        help="maximum generations for each conformer")
    parser.add_argument("-e", "--evaluator", dest="evaluator", type=str,
                        default="hardsphere",
                        choices=["hardsphere", "sqm"], help="Energy Evaluator")
    options = parser.parse_args()
    if options.evaluator == 'hardsphere':
        qcout_molecule = QcOutput(options.molecule)
        qcout_cation = QcOutput(options.cation)
        qcout_anion = QcOutput(options.anion)
        total_charge_cation = qcout_cation.data[0]["molecules"][-1].charge
        total_charge_anion = qcout_anion.data[0]["molecules"][-1].charge
        total_charge_mol = qcout_molecule.data[0]["molecules"][-1].charge
        num_lcm = lcm(total_charge_cation, -total_charge_anion)
        num_cation = num_lcm / total_charge_cation
        num_anion = num_lcm / -total_charge_anion
        pymatgen_mol_molecule = qcout_molecule.data[0]["molecules"][-1]
        pymatgen_mol_cation = qcout_cation.data[0]["molecules"][-1]
        pymatgen_mol_anion = qcout_anion.data[0]["molecules"][-1]
        # noinspection PyProtectedMember
        molecule = BabelMolAdaptor(pymatgen_mol_molecule)._obmol
        # noinspection PyProtectedMember
        obmol_cation = BabelMolAdaptor(pymatgen_mol_cation)._obmol
        # noinspection PyProtectedMember
        obmol_anion = BabelMolAdaptor(pymatgen_mol_anion)._obmol
        energy_evaluator = HardSphereElectrostaticEnergyEvaluator.from_qchem_output(
            qcout_molecule, qcout_cation, qcout_anion)
        fragments = [obmol_cation, obmol_anion]
    else:
        # noinspection PyProtectedMember
        molecule = BabelMolAdaptor.from_file(options.molecule,
                                             os.path.splitext(
                                                 options.molecule)[1][
                                             1:])._obmol
        fragments = []
        for frag_file in options.fragments:
            file_format = os.path.splitext(frag_file)[1][1:]
            # noinspection PyProtectedMember
            fragments.append(
                BabelMolAdaptor.from_file(frag_file, file_format)._obmol)
        energy_evaluator = SemiEmpricalQuatumMechanicalEnergyEvaluator(
            molecule, fragments, options.nums_fragments,
            total_charge=options.charge,
            taboo_tolerance_ang=options.taboo_tolerance,
            force_order_fragment=options.force_ordered_fragment,
            bound_setter=options.bound_setter)
    if len(fragments) != len(options.nums_fragments):
        raise ValueError(
            "you must specify the duplicated count for every fragment")
    placer = IonPlacer(molecule=molecule, fragments=fragments,
                       nums_fragments=options.nums_fragments,
                       energy_evaluator=energy_evaluator,
                       taboo_tolerance_ang=options.taboo_tolerance,
                       taboo_tolerance_particle_ratio=options.ratio_taboo_particles,
                       topology=options.topology,
                       initial_guess=options.initial_guess,
                       bound_setter=options.bound_setter,
                       always_write_best=options.always_write_best,
                       random_seed=options.random_seed,
                       max_generations_each_conformer=options.max_generations_each_conformer)
    energy_evaluator.arranger = placer
    placer.place(max_evaluations=options.iterations,
                 pop_size=options.size,
                 neighborhood_size=options.num_neighbours)
    print('It took {:.1f} seconds to place the salt'.format(placer
                                                            .playing_time))
Exemplo n.º 17
0
 def test_from_file(self):
     adaptor = BabelMolAdaptor.from_file(
         os.path.join(test_dir, "Ethane_e.pdb"), "pdb")
     mol = adaptor.pymatgen_mol
     self.assertEqual(mol.formula, "H6 C2")
Exemplo n.º 18
0
 def test_from_file_return_all_molecules(self):
     adaptors = BabelMolAdaptor.from_file(os.path.join(
         test_dir, "multiple_frame_xyz.xyz"),
                                          "xyz",
                                          return_all_molecules=True)
     self.assertEqual(len(adaptors), 302)
Exemplo n.º 19
0
    def __init__(self, molecule, optimize=False):
        """
        Instantiation method for FunctionalGroupExtractor.

        :param molecule: Either a filename, a pymatgen.core.structure.Molecule
            object, or a pymatgen.analysis.graphs.MoleculeGraph object.
        :param optimize: Default False. If True, then the input molecule will be
            modified, adding Hydrogens, performing a simple conformer search,
            etc.
        """

        self.molgraph = None

        if isinstance(molecule, str):
            try:
                if optimize:
                    obmol = BabelMolAdaptor.from_file(molecule,
                                                      file_format="mol")
                    # OBMolecule does not contain pymatgen Molecule information
                    # So, we need to wrap the obmol in a BabelMolAdapter
                    obmol.add_hydrogen()
                    obmol.make3d()
                    obmol.localopt()
                    self.molecule = obmol.pymatgen_mol
                else:
                    self.molecule = Molecule.from_file(molecule)
            except OSError:
                raise ValueError("Input must be a valid molecule file, a "
                                 "Molecule object, or a MoleculeGraph object.")

        elif isinstance(molecule, Molecule):
            if optimize:
                obmol = BabelMolAdaptor(molecule)
                obmol.add_hydrogen()
                obmol.make3d()
                obmol.localopt()

                self.molecule = obmol.pymatgen_mol
            else:
                self.molecule = molecule

        elif isinstance(molecule, MoleculeGraph):
            if optimize:
                obmol = BabelMolAdaptor(molecule.molecule)
                obmol.add_hydrogen()
                obmol.make3d()
                obmol.localopt()

                self.molecule = obmol.pymatgen_mol

            else:
                self.molecule = molecule.molecule
                self.molgraph = molecule

        else:
            raise ValueError("Input to FunctionalGroupExtractor must be"
                             "str, Molecule, or MoleculeGraph.")

        if self.molgraph is None:
            self.molgraph = MoleculeGraph.with_local_env_strategy(self.molecule,
                                                                  OpenBabelNN(),
                                                                  reorder=False,
                                                                  extend_structure=False)

        # Assign a specie and coordinates to each node in the graph,
        # corresponding to the Site in the Molecule object
        self.molgraph.set_node_attributes()

        self.species = nx.get_node_attributes(self.molgraph.graph, "specie")
Exemplo n.º 20
0
    def __init__(self, molecule, optimize=False):
        """
        Instantiation method for FunctionalGroupExtractor.

        :param molecule: Either a filename, a pymatgen.core.structure.Molecule
            object, or a pymatgen.analysis.graphs.MoleculeGraph object.
        :param optimize: Default False. If True, then the input molecule will be
            modified, adding Hydrogens, performing a simple conformer search,
            etc.
        """

        self.molgraph = None

        if isinstance(molecule, str):
            try:
                if optimize:
                    obmol = BabelMolAdaptor.from_file(molecule,
                                                      file_format="mol")
                    # OBMolecule does not contain pymatgen Molecule information
                    # So, we need to wrap the obmol in a BabelMolAdapter
                    obmol.add_hydrogen()
                    obmol.make3d()
                    obmol.localopt()
                    self.molecule = obmol.pymatgen_mol
                else:
                    self.molecule = Molecule.from_file(molecule)
            except OSError:
                raise ValueError("Input must be a valid molecule file, a "
                                 "Molecule object, or a MoleculeGraph object.")

        elif isinstance(molecule, Molecule):
            if optimize:
                obmol = BabelMolAdaptor(molecule)
                obmol.add_hydrogen()
                obmol.make3d()
                obmol.localopt()

                self.molecule = obmol.pymatgen_mol
            else:
                self.molecule = molecule

        elif isinstance(molecule, MoleculeGraph):
            if optimize:
                obmol = BabelMolAdaptor(molecule.molecule)
                obmol.add_hydrogen()
                obmol.make3d()
                obmol.localopt()

                self.molecule = obmol.pymatgen_mol

            else:
                self.molecule = molecule.molecule
                self.molgraph = molecule

        else:
            raise ValueError("Input to FunctionalGroupExtractor must be"
                             "str, Molecule, or MoleculeGraph.")

        if self.molgraph is None:
            self.molgraph = MoleculeGraph.with_local_env_strategy(
                self.molecule,
                OpenBabelNN(),
                reorder=False,
                extend_structure=False)

        # Assign a specie and coordinates to each node in the graph,
        # corresponding to the Site in the Molecule object
        self.molgraph.set_node_attributes()

        self.species = nx.get_node_attributes(self.molgraph.graph, "specie")
Exemplo n.º 21
0
 def test_from_file(self):
     adaptor = BabelMolAdaptor.from_file(
         os.path.join(test_dir, "Ethane_e.pdb"), "pdb")
     mol = adaptor.pymatgen_mol
     self.assertEqual(mol.formula, "H6 C2")