Skip to content

single_point

Single point energy calculations for molecular structures.

ASESinglePoint dataclass

Bases: PymatGenMaker[InputType, OutputType], SinglePointCalculation


              flowchart TD
              jfchemistry.single_point.ASESinglePoint[ASESinglePoint]
              jfchemistry.core.makers.pymatgen_maker.PymatGenMaker[PymatGenMaker]
              jfchemistry.core.makers.jfchem_maker.JFChemMaker[JFChemMaker]
              jfchemistry.core.makers.core_maker.CoreMaker[CoreMaker]
              jfchemistry.single_point.base.SinglePointCalculation[SinglePointCalculation]

                              jfchemistry.core.makers.pymatgen_maker.PymatGenMaker --> jfchemistry.single_point.ASESinglePoint
                                jfchemistry.core.makers.jfchem_maker.JFChemMaker --> jfchemistry.core.makers.pymatgen_maker.PymatGenMaker
                                jfchemistry.core.makers.core_maker.CoreMaker --> jfchemistry.core.makers.jfchem_maker.JFChemMaker
                


                jfchemistry.single_point.base.SinglePointCalculation --> jfchemistry.single_point.ASESinglePoint
                


              click jfchemistry.single_point.ASESinglePoint href "" "jfchemistry.single_point.ASESinglePoint"
              click jfchemistry.core.makers.pymatgen_maker.PymatGenMaker href "" "jfchemistry.core.makers.pymatgen_maker.PymatGenMaker"
              click jfchemistry.core.makers.jfchem_maker.JFChemMaker href "" "jfchemistry.core.makers.jfchem_maker.JFChemMaker"
              click jfchemistry.core.makers.core_maker.CoreMaker href "" "jfchemistry.core.makers.core_maker.CoreMaker"
              click jfchemistry.single_point.base.SinglePointCalculation href "" "jfchemistry.single_point.base.SinglePointCalculation"

Base class for single point energy calculations using ASE calculators.

Combines single point energy calculations with ASE calculator interfaces. This class provides the framework for calculating the single point energy of a structure using various ASE calculators (neural networks, machine learning , semi-empirical, etc.).

ATTRIBUTE DESCRIPTION
name

Name of the calculator (default: "ASE Single Point Calculator").

TYPE: str

calculator

The calculator to use for the calculation.

TYPE: ASECalculator

Source code in jfchemistry/single_point/ase.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
@dataclass
class ASESinglePoint[InputType: Molecule | Structure, OutputType: Molecule | Structure](
    PymatGenMaker[InputType, OutputType],
    SinglePointCalculation,
):
    """Base class for single point energy calculations using ASE calculators.

    Combines single point energy calculations with ASE calculator interfaces.
    This class provides the framework for calculating the single point energy
    of a structure using various ASE calculators (neural networks, machine learning
    , semi-empirical, etc.).

    Attributes:
        name: Name of the calculator (default: "ASE Single Point Calculator").
        calculator: The calculator to use for the calculation.
    """

    name: str = "ASE Single Point Calculator"
    calculator: ASECalculator = field(
        default_factory=lambda: ASECalculator,
        metadata={"description": "the calculator to use for the calculation"},
    )

    def __post_init__(self):
        """Post initialization setup."""
        self.name = f"{self.name} with {self.calculator.name}"
        super().__post_init__()

    def _operation(
        self, input: InputType, **kwargs
    ) -> tuple[OutputType | list[OutputType], Properties | list[Properties] | None]:
        """Optimize molecular structure using ASE.

        Performs geometry optimization by:
        1. Converting structure to ASE Atoms
        2. Setting up the calculator with charge and spin
        3. Running the calculator
        4. Converting back to Pymatgen Molecule
        5. Extracting properties from the calculation

        Args:
            input: Input molecular structure with 3D coordinates.
            **kwargs: Additional kwargs to pass to the operation.

        Returns:
            Tuple containing:
                - Optimized Pymatgen Molecule
                - Dictionary of computed properties from calculator
        """
        atoms = input.to_ase_atoms()
        charge = int(input.charge)
        if isinstance(input, Molecule):
            spin_multiplicity = int(input.spin_multiplicity)
        else:
            spin_multiplicity = 1
        self.calculator._set_calculator(atoms, charge=charge, spin_multiplicity=spin_multiplicity)
        print(atoms.get_potential_energy())
        properties = self.calculator._get_properties(atoms)
        return cast("OutputType", input), properties

make 

make(input: InputType | list[InputType], **kwargs) -> Response[_output_model]

Create a workflow job for processing structure(s).

Automatically handles job distribution for lists of structures. Each structure in a list is processed as a separate job for parallel execution.

PARAMETER DESCRIPTION
input

Single Pymatgen SiteCollection or list of SiteCollections.

TYPE: InputType | list[InputType]

**kwargs

Additional kwargs to pass to the operation.

DEFAULT: {}

RETURNS DESCRIPTION
Response[_output_model]

Response containing: - structure: Processed structure(s) - files: XYZ format file(s) of the structure(s) - properties: Computed properties from the operation

Examples:

>>> from jfchemistry.conformers import CRESTConformers
>>> from pymatgen.core import Molecule
>>> molecule = Molecule.from_ase_atoms(molecule("C2H6"))
>>> # Generate conformers
>>> conformer_gen = CRESTConformers(ewin=6.0)
>>> job = conformer_gen.make(input)
Source code in jfchemistry/core/makers/jfchem_maker.py 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
@jfchem_job()
def make(
    self,
    input: InputType | list[InputType],
    **kwargs,
) -> Response[_output_model]:
    """Create a workflow job for processing structure(s).

    Automatically handles job distribution for lists of structures. Each
    structure in a list is processed as a separate job for parallel execution.

    Args:
        input: Single Pymatgen SiteCollection or list of SiteCollections.
        **kwargs: Additional kwargs to pass to the operation.

    Returns:
        Response containing:
            - structure: Processed structure(s)
            - files: XYZ format file(s) of the structure(s)
            - properties: Computed properties from the operation

    Examples:
        >>> from jfchemistry.conformers import CRESTConformers # doctest: +SKIP
        >>> from pymatgen.core import Molecule # doctest: +SKIP
        >>> molecule = Molecule.from_ase_atoms(molecule("C2H6")) # doctest: +SKIP
        >>> # Generate conformers
        >>> conformer_gen = CRESTConformers(ewin=6.0) # doctest: +SKIP
        >>> job = conformer_gen.make(input) # doctest: +SKIP
    """
    return self._run_job(input, **kwargs)

ORCASinglePointCalculator dataclass

Bases: SinglePointCalculation, PymatGenMaker[InputType, OutputType], ORCACalculator


              flowchart TD
              jfchemistry.single_point.ORCASinglePointCalculator[ORCASinglePointCalculator]
              jfchemistry.single_point.base.SinglePointCalculation[SinglePointCalculation]
              jfchemistry.core.makers.pymatgen_maker.PymatGenMaker[PymatGenMaker]
              jfchemistry.core.makers.jfchem_maker.JFChemMaker[JFChemMaker]
              jfchemistry.core.makers.core_maker.CoreMaker[CoreMaker]
              jfchemistry.calculators.orca.orca_calculator.ORCACalculator[ORCACalculator]
              jfchemistry.calculators.base.WavefunctionCalculator[WavefunctionCalculator]
              jfchemistry.calculators.base.Calculator[Calculator]

                              jfchemistry.single_point.base.SinglePointCalculation --> jfchemistry.single_point.ORCASinglePointCalculator
                
                jfchemistry.core.makers.pymatgen_maker.PymatGenMaker --> jfchemistry.single_point.ORCASinglePointCalculator
                                jfchemistry.core.makers.jfchem_maker.JFChemMaker --> jfchemistry.core.makers.pymatgen_maker.PymatGenMaker
                                jfchemistry.core.makers.core_maker.CoreMaker --> jfchemistry.core.makers.jfchem_maker.JFChemMaker
                


                jfchemistry.calculators.orca.orca_calculator.ORCACalculator --> jfchemistry.single_point.ORCASinglePointCalculator
                                jfchemistry.calculators.base.WavefunctionCalculator --> jfchemistry.calculators.orca.orca_calculator.ORCACalculator
                                jfchemistry.calculators.base.Calculator --> jfchemistry.calculators.base.WavefunctionCalculator
                




              click jfchemistry.single_point.ORCASinglePointCalculator href "" "jfchemistry.single_point.ORCASinglePointCalculator"
              click jfchemistry.single_point.base.SinglePointCalculation href "" "jfchemistry.single_point.base.SinglePointCalculation"
              click jfchemistry.core.makers.pymatgen_maker.PymatGenMaker href "" "jfchemistry.core.makers.pymatgen_maker.PymatGenMaker"
              click jfchemistry.core.makers.jfchem_maker.JFChemMaker href "" "jfchemistry.core.makers.jfchem_maker.JFChemMaker"
              click jfchemistry.core.makers.core_maker.CoreMaker href "" "jfchemistry.core.makers.core_maker.CoreMaker"
              click jfchemistry.calculators.orca.orca_calculator.ORCACalculator href "" "jfchemistry.calculators.orca.orca_calculator.ORCACalculator"
              click jfchemistry.calculators.base.WavefunctionCalculator href "" "jfchemistry.calculators.base.WavefunctionCalculator"
              click jfchemistry.calculators.base.Calculator href "" "jfchemistry.calculators.base.Calculator"

Calculate the single point energy of a structure using ORCA DFT calculator.

Inherits all attributes from ORCACalculator.

ATTRIBUTE DESCRIPTION
name

Name of the calculator (default: "ORCA Single Point Calculator").

TYPE: str

basename

Basename of the calculator (default: "orca_single_point").

TYPE: str

Source code in jfchemistry/single_point/orca.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
@dataclass
class ORCASinglePointCalculator[InputType: Molecule, OutputType: Molecule](
    SinglePointCalculation, PymatGenMaker[InputType, OutputType], ORCACalculator
):
    """Calculate the single point energy of a structure using ORCA DFT calculator.

    Inherits all attributes from ORCACalculator.

    Attributes:
        name: Name of the calculator (default: "ORCA Single Point Calculator").
        basename: Basename of the calculator (default: "orca_single_point").
    """

    name: str = "ORCA Single Point Calculator"
    basename: str = "orca_single_point"
    _properties_model: type[ORCAProperties] = ORCAProperties

    def _operation(
        self, input: InputType, **kwargs
    ) -> tuple[OutputType | list[OutputType], Properties | list[Properties] | None]:
        """Calculate the single point energy of a molecule using ORCA."""
        input.to("input.xyz", fmt="xyz")
        sk_list = super()._set_keywords()
        calc = super()._build_calculator(self.basename)
        calc.structure = Structure.from_xyz("input.xyz")
        super()._set_structure_charge_and_spin(calc, input.charge, input.spin_multiplicity)
        super()._configure_calculator_input(calc, sk_list)
        calc.write_input()
        calc.run()
        output = calc.get_output()
        properties = super()._parse_output(output)
        return cast("OutputType", input), properties

make 

make(input: InputType | list[InputType], **kwargs) -> Response[_output_model]

Create a workflow job for processing structure(s).

Automatically handles job distribution for lists of structures. Each structure in a list is processed as a separate job for parallel execution.

PARAMETER DESCRIPTION
input

Single Pymatgen SiteCollection or list of SiteCollections.

TYPE: InputType | list[InputType]

**kwargs

Additional kwargs to pass to the operation.

DEFAULT: {}

RETURNS DESCRIPTION
Response[_output_model]

Response containing: - structure: Processed structure(s) - files: XYZ format file(s) of the structure(s) - properties: Computed properties from the operation

Examples:

>>> from jfchemistry.conformers import CRESTConformers
>>> from pymatgen.core import Molecule
>>> molecule = Molecule.from_ase_atoms(molecule("C2H6"))
>>> # Generate conformers
>>> conformer_gen = CRESTConformers(ewin=6.0)
>>> job = conformer_gen.make(input)
Source code in jfchemistry/core/makers/jfchem_maker.py 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
@jfchem_job()
def make(
    self,
    input: InputType | list[InputType],
    **kwargs,
) -> Response[_output_model]:
    """Create a workflow job for processing structure(s).

    Automatically handles job distribution for lists of structures. Each
    structure in a list is processed as a separate job for parallel execution.

    Args:
        input: Single Pymatgen SiteCollection or list of SiteCollections.
        **kwargs: Additional kwargs to pass to the operation.

    Returns:
        Response containing:
            - structure: Processed structure(s)
            - files: XYZ format file(s) of the structure(s)
            - properties: Computed properties from the operation

    Examples:
        >>> from jfchemistry.conformers import CRESTConformers # doctest: +SKIP
        >>> from pymatgen.core import Molecule # doctest: +SKIP
        >>> molecule = Molecule.from_ase_atoms(molecule("C2H6")) # doctest: +SKIP
        >>> # Generate conformers
        >>> conformer_gen = CRESTConformers(ewin=6.0) # doctest: +SKIP
        >>> job = conformer_gen.make(input) # doctest: +SKIP
    """
    return self._run_job(input, **kwargs)

PySCFGPUSinglePoint dataclass

Bases: PySCFCalculator, PymatGenMaker[InputType, OutputType], SinglePointCalculation


              flowchart TD
              jfchemistry.single_point.PySCFGPUSinglePoint[PySCFGPUSinglePoint]
              jfchemistry.core.makers.pymatgen_maker.PymatGenMaker[PymatGenMaker]
              jfchemistry.core.makers.jfchem_maker.JFChemMaker[JFChemMaker]
              jfchemistry.core.makers.core_maker.CoreMaker[CoreMaker]
              jfchemistry.single_point.base.SinglePointCalculation[SinglePointCalculation]

                              jfchemistry.core.makers.pymatgen_maker.PymatGenMaker --> jfchemistry.single_point.PySCFGPUSinglePoint
                                jfchemistry.core.makers.jfchem_maker.JFChemMaker --> jfchemistry.core.makers.pymatgen_maker.PymatGenMaker
                                jfchemistry.core.makers.core_maker.CoreMaker --> jfchemistry.core.makers.jfchem_maker.JFChemMaker
                


                jfchemistry.single_point.base.SinglePointCalculation --> jfchemistry.single_point.PySCFGPUSinglePoint
                


              click jfchemistry.single_point.PySCFGPUSinglePoint href "" "jfchemistry.single_point.PySCFGPUSinglePoint"
              click jfchemistry.core.makers.pymatgen_maker.PymatGenMaker href "" "jfchemistry.core.makers.pymatgen_maker.PymatGenMaker"
              click jfchemistry.core.makers.jfchem_maker.JFChemMaker href "" "jfchemistry.core.makers.jfchem_maker.JFChemMaker"
              click jfchemistry.core.makers.core_maker.CoreMaker href "" "jfchemistry.core.makers.core_maker.CoreMaker"
              click jfchemistry.single_point.base.SinglePointCalculation href "" "jfchemistry.single_point.base.SinglePointCalculation"

PySCF GPU Calculator with full type support.

This calculator wraps the PySCF GPU package to provide DFT calculation capabilities.

ATTRIBUTE DESCRIPTION
name

Name of the calculator (default: "PySCF GPU").

TYPE: str

cores

Number of CPU cores to use for parallel calculations (default: 1).

TYPE: str

basis_set

Basis set to use for the calculation (488 options available).

TYPE: str

xc_functional

Exchange-correlation functional to use (195 options available).

TYPE: str

Source code in jfchemistry/single_point/pyscfgpu.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
@dataclass
class PySCFGPUSinglePoint[InputType: Molecule, OutputType: Molecule](
    PySCFCalculator, PymatGenMaker[InputType, OutputType], SinglePointCalculation
):
    """PySCF GPU Calculator with full type support.

    This calculator wraps the PySCF GPU package to provide
    DFT calculation capabilities.

    Attributes:
        name: Name of the calculator (default: "PySCF GPU").
        cores: Number of CPU cores to use for parallel calculations (default: 1).
        basis_set: Basis set to use for the calculation (488 options available).
        xc_functional: Exchange-correlation functional to use (195 options available).
    """

    name: str = "PySCF GPU Single Point Calculator"
    _properties_model: type[PySCFProperties] = PySCFProperties
    _filename = "input.xyz"

    def _operation(
        self, input: InputType, **kwargs
    ) -> tuple[OutputType | list[OutputType], Properties | list[Properties] | None]:
        """Calculate the single point energy of a molecule using PySCF GPU."""
        # Write to XYZ file
        input.to(self._filename, fmt="xyz")
        # Make the calculator
        mol = gto.Mole()
        mol.atom = self._filename
        mol.basis = self.basis_set
        mol.build()
        mf = self._setup_mf(mol)
        # mf = dft.RKS(mol)
        mf = mf.newton()
        mf.kernel()
        properties = self._get_properties(mf)
        return cast("OutputType", input), properties

make 

make(input: InputType | list[InputType], **kwargs) -> Response[_output_model]

Create a workflow job for processing structure(s).

Automatically handles job distribution for lists of structures. Each structure in a list is processed as a separate job for parallel execution.

PARAMETER DESCRIPTION
input

Single Pymatgen SiteCollection or list of SiteCollections.

TYPE: InputType | list[InputType]

**kwargs

Additional kwargs to pass to the operation.

DEFAULT: {}

RETURNS DESCRIPTION
Response[_output_model]

Response containing: - structure: Processed structure(s) - files: XYZ format file(s) of the structure(s) - properties: Computed properties from the operation

Examples:

>>> from jfchemistry.conformers import CRESTConformers
>>> from pymatgen.core import Molecule
>>> molecule = Molecule.from_ase_atoms(molecule("C2H6"))
>>> # Generate conformers
>>> conformer_gen = CRESTConformers(ewin=6.0)
>>> job = conformer_gen.make(input)
Source code in jfchemistry/core/makers/jfchem_maker.py 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
@jfchem_job()
def make(
    self,
    input: InputType | list[InputType],
    **kwargs,
) -> Response[_output_model]:
    """Create a workflow job for processing structure(s).

    Automatically handles job distribution for lists of structures. Each
    structure in a list is processed as a separate job for parallel execution.

    Args:
        input: Single Pymatgen SiteCollection or list of SiteCollections.
        **kwargs: Additional kwargs to pass to the operation.

    Returns:
        Response containing:
            - structure: Processed structure(s)
            - files: XYZ format file(s) of the structure(s)
            - properties: Computed properties from the operation

    Examples:
        >>> from jfchemistry.conformers import CRESTConformers # doctest: +SKIP
        >>> from pymatgen.core import Molecule # doctest: +SKIP
        >>> molecule = Molecule.from_ase_atoms(molecule("C2H6")) # doctest: +SKIP
        >>> # Generate conformers
        >>> conformer_gen = CRESTConformers(ewin=6.0) # doctest: +SKIP
        >>> job = conformer_gen.make(input) # doctest: +SKIP
    """
    return self._run_job(input, **kwargs)

TorchSimSinglePoint dataclass

Bases: SinglePointCalculation, PymatGenMaker[InputType, OutputType], TorchSimCalculator


              flowchart TD
              jfchemistry.single_point.TorchSimSinglePoint[TorchSimSinglePoint]
              jfchemistry.single_point.base.SinglePointCalculation[SinglePointCalculation]
              jfchemistry.core.makers.pymatgen_maker.PymatGenMaker[PymatGenMaker]
              jfchemistry.core.makers.jfchem_maker.JFChemMaker[JFChemMaker]
              jfchemistry.core.makers.core_maker.CoreMaker[CoreMaker]
              jfchemistry.calculators.torchsim.torchsim_calculator.TorchSimCalculator[TorchSimCalculator]
              jfchemistry.calculators.base.Calculator[Calculator]

                              jfchemistry.single_point.base.SinglePointCalculation --> jfchemistry.single_point.TorchSimSinglePoint
                
                jfchemistry.core.makers.pymatgen_maker.PymatGenMaker --> jfchemistry.single_point.TorchSimSinglePoint
                                jfchemistry.core.makers.jfchem_maker.JFChemMaker --> jfchemistry.core.makers.pymatgen_maker.PymatGenMaker
                                jfchemistry.core.makers.core_maker.CoreMaker --> jfchemistry.core.makers.jfchem_maker.JFChemMaker
                


                jfchemistry.calculators.torchsim.torchsim_calculator.TorchSimCalculator --> jfchemistry.single_point.TorchSimSinglePoint
                                jfchemistry.calculators.base.Calculator --> jfchemistry.calculators.torchsim.torchsim_calculator.TorchSimCalculator
                



              click jfchemistry.single_point.TorchSimSinglePoint href "" "jfchemistry.single_point.TorchSimSinglePoint"
              click jfchemistry.single_point.base.SinglePointCalculation href "" "jfchemistry.single_point.base.SinglePointCalculation"
              click jfchemistry.core.makers.pymatgen_maker.PymatGenMaker href "" "jfchemistry.core.makers.pymatgen_maker.PymatGenMaker"
              click jfchemistry.core.makers.jfchem_maker.JFChemMaker href "" "jfchemistry.core.makers.jfchem_maker.JFChemMaker"
              click jfchemistry.core.makers.core_maker.CoreMaker href "" "jfchemistry.core.makers.core_maker.CoreMaker"
              click jfchemistry.calculators.torchsim.torchsim_calculator.TorchSimCalculator href "" "jfchemistry.calculators.torchsim.torchsim_calculator.TorchSimCalculator"
              click jfchemistry.calculators.base.Calculator href "" "jfchemistry.calculators.base.Calculator"

Base class for single point energy calculations using TorchSim calculators.

Combines single point energy calculations with TorchSim calculator interfaces. This class provides the framework for calculating the single point energy of a structure using various TorchSim calculators (neural networks, machine learning , semi-empirical, etc.).

ATTRIBUTE DESCRIPTION
name

Name of the calculator (default: "ASE Single Point Calculator").

TYPE: str

Source code in jfchemistry/single_point/torchsim.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
@dataclass
class TorchSimSinglePoint[InputType: Molecule | Structure, OutputType: Molecule | Structure](
    SinglePointCalculation, PymatGenMaker[InputType, OutputType], TorchSimCalculator
):
    """Base class for single point energy calculations using TorchSim calculators.

    Combines single point energy calculations with TorchSim calculator interfaces.
    This class provides the framework for calculating the single point energy
    of a structure using various TorchSim calculators (neural networks, machine learning
    , semi-empirical, etc.).

    Attributes:
        name: Name of the calculator (default: "ASE Single Point Calculator").
    """

    name: str = "TorchSim Single Point Calculator"
    calculator: TorchSimCalculator = field(
        default_factory=lambda: TorchSimCalculator,
        metadata={"description": "the calculator to use for the calculation"},
    )

    def _operation(
        self, input: InputType, **kwargs
    ) -> tuple[OutputType | list[OutputType], Properties | list[Properties] | None]:
        """Calculate the single point energy of a structure using TorchSim.

        Performs geometry optimization by:
        1. Converting structure to ASE Atoms
        2. Setting up the calculator with charge and spin
        3. Running the calculator
        4. Converting back to Pymatgen Molecule
        5. Extracting properties from the calculation

        Args:
            input: Input molecular structure with 3D coordinates.
            **kwargs: Additional kwargs to pass to the operation.

        Returns:
            Tuple containing:
                - Optimized Pymatgen Molecule
                - Dictionary of computed properties from calculator

        """
        properties = self.calculator._get_properties(input)
        return cast("OutputType", input), properties

make 

make(input: InputType | list[InputType], **kwargs) -> Response[_output_model]

Create a workflow job for processing structure(s).

Automatically handles job distribution for lists of structures. Each structure in a list is processed as a separate job for parallel execution.

PARAMETER DESCRIPTION
input

Single Pymatgen SiteCollection or list of SiteCollections.

TYPE: InputType | list[InputType]

**kwargs

Additional kwargs to pass to the operation.

DEFAULT: {}

RETURNS DESCRIPTION
Response[_output_model]

Response containing: - structure: Processed structure(s) - files: XYZ format file(s) of the structure(s) - properties: Computed properties from the operation

Examples:

>>> from jfchemistry.conformers import CRESTConformers
>>> from pymatgen.core import Molecule
>>> molecule = Molecule.from_ase_atoms(molecule("C2H6"))
>>> # Generate conformers
>>> conformer_gen = CRESTConformers(ewin=6.0)
>>> job = conformer_gen.make(input)
Source code in jfchemistry/core/makers/jfchem_maker.py 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
@jfchem_job()
def make(
    self,
    input: InputType | list[InputType],
    **kwargs,
) -> Response[_output_model]:
    """Create a workflow job for processing structure(s).

    Automatically handles job distribution for lists of structures. Each
    structure in a list is processed as a separate job for parallel execution.

    Args:
        input: Single Pymatgen SiteCollection or list of SiteCollections.
        **kwargs: Additional kwargs to pass to the operation.

    Returns:
        Response containing:
            - structure: Processed structure(s)
            - files: XYZ format file(s) of the structure(s)
            - properties: Computed properties from the operation

    Examples:
        >>> from jfchemistry.conformers import CRESTConformers # doctest: +SKIP
        >>> from pymatgen.core import Molecule # doctest: +SKIP
        >>> molecule = Molecule.from_ase_atoms(molecule("C2H6")) # doctest: +SKIP
        >>> # Generate conformers
        >>> conformer_gen = CRESTConformers(ewin=6.0) # doctest: +SKIP
        >>> job = conformer_gen.make(input) # doctest: +SKIP
    """
    return self._run_job(input, **kwargs)