Пример #1
0
def test_optimization_pass_serialization(water, opti_input, opti_success):
    opti_in = OptimizationInput(initial_molecule=water, **opti_input)
    assert isinstance(opti_in.dict(), dict)
    assert isinstance(opti_in.json(), str)

    opti_out = Optimization(initial_molecule=water, **opti_input, **opti_success)
    assert isinstance(opti_out.dict(), dict)
    assert isinstance(opti_out.json(), str)
Пример #2
0
    def _generate_optimization_input(mol, compute_spec, factory):
        import ast
        from qcelemental.models import OptimizationInput

        # TODO: bug report in openff where `atom_map` is a string
        if isinstance(mol.properties.get('atom_map'), str):
            mol.properties['atom_map'] = ast.literal_eval(
                mol.properties['atom_map'])

        # This block will fail for OFF Toolkit 0.8.4, but succeed for 0.8.4rc1
        try:
            attributes = factory.create_cmiles_metadata(mol)
            qcmol = mol.to_qcschema(extras=attributes)
        # In OFFTK 0.8.4, the CMILES field is automatically populated by this method
        except:
            qcmol = mol.to_qcschema()

        method = compute_spec['method']
        basis = compute_spec['basis']
        program = compute_spec['program']

        # generate optimization inputs
        input_data = OptimizationInput(keywords={
            "coordsys": "dlc",
            "enforce": 0,
            "epsilon": 1e-05,
            "reset": True,
            "qccnv": False,
            "molcnv": False,
            "check": 0,
            "trust": 0.1,
            "tmax": 0.3,
            "maxiter": 300,
            "convergence_set": "gau",
            "program": program
        },
                                       extras={},
                                       protocols={},
                                       input_specification={
                                           "driver": "gradient",
                                           "model": {
                                               "method": method,
                                               "basis": basis,
                                           },
                                           "keywords": {
                                               "maxiter":
                                               200,
                                               "scf_properties": [
                                                   "dipole", "quadrupole",
                                                   "wiberg_lowdin_indices",
                                                   "mayer_indices"
                                               ]
                                           },
                                       },
                                       initial_molecule=qcmol)

        return input_data.dict()
Пример #3
0
    def _args_from_optimizationrecord(opt, client):
        from qcelemental.models import OptimizationInput

        # generate optimization inputs
        input_data = OptimizationInput(
            keywords=opt.keywords,
            extras={},
            protocols={},
            input_specification={
                "driver": "gradient",
                "model": {
                    "method": opt.qc_spec.method,
                    "basis": opt.qc_spec.basis,
                },
                "keywords":
                client.query_keywords(opt.qc_spec.keywords)[0].values
            },
            initial_molecule=opt.get_initial_molecule())

        return input_data.dict()