def test_forcefield_com_exceptions():
with pytest.raises(stk.MacroModelInputError):
stk.MacroModelForceField(macromodel_path='dummy_path',
maximum_iterations=1000000)
with pytest.raises(stk.MacroModelInputError):
stk.MacroModelForceField(macromodel_path='dummy_path',
minimum_gradient=0.00001)
def FF_optimize_cage(name, cage, settings, output_dir, macromodel_path):
"""
Optimize cage with stk.
"""
ff = stk.MacroModelForceField(macromodel_path=macromodel_path,
output_dir=join(output_dir, f'{name}_FFout'),
restricted=True)
# MD process - run MD, collect N conformers, optimize each,
# return lowest energy conformer.
md = stk.MacroModelMD(macromodel_path=macromodel_path,
output_dir=join(output_dir, f'{name}_MDout'),
timeout=settings['timeout'],
force_field=settings['force_field'],
temperature=settings['temperature'],
conformers=settings['conformers'],
time_step=settings['time_step'],
eq_time=settings['eq_time'],
simulation_time=settings['simulation_time'],
maximum_iterations=settings['maximum_iterations'],
minimum_gradient=settings['minimum_gradient'],
use_cache=settings['use_cache'])
seq = stk.Sequence(ff, md)
seq.optimize(mol=cage)
return cage
def FF_optimize_open_cage(name, complex, output_dir, macromodel_path):
"""
Crudely optimize cage complex with stk.
"""
ff_res = stk.MacroModelForceField(macromodel_path=macromodel_path,
output_dir=join(output_dir,
f'{name}_FFResout'),
restricted=True)
ff_unres = stk.MacroModelForceField(macromodel_path=macromodel_path,
output_dir=join(
output_dir, f'{name}_FFUnresout'),
restricted=False)
seq = stk.Sequence(ff_res, ff_unres)
seq.optimize(mol=complex)
return complex
def test_unrestricted_force_field(tmp_cc3, macromodel_path):
tmp_cc3.write(join(outdir, 'umm_ff_before.mol'), conformer=0)
mm = stk.MacroModelForceField(macromodel_path=macromodel_path,
output_dir='umm_ff',
restricted=False,
minimum_gradient=1)
mm.optimize(tmp_cc3, conformer=0)
tmp_cc3.write(join(outdir, 'umm_ff_after.mol'), conformer=0)
def test_unrestricted_force_field(tmp_four_plus_six, macromodel_path):
mm_energy = stk.MacroModelEnergy(macromodel_path, force_field=16)
init_energy = mm_energy.get_energy(tmp_four_plus_six)
tmp_four_plus_six.write(join(test_dir, 'umm_ff_before.mol'))
mm = stk.MacroModelForceField(macromodel_path=macromodel_path,
output_dir='umm_ff',
restricted=False,
minimum_gradient=1,
force_field=16)
mm.optimize(tmp_four_plus_six)
tmp_four_plus_six.write(join(test_dir, 'umm_ff_after.mol'))
assert mm_energy.get_energy(tmp_four_plus_six) < init_energy
random_seed=random_seed,
),
)
# #####################################################################
# Optimizer.
# #####################################################################
# Optimizer for full-run.
failed_optimizer = stk.NullOptimizer(use_cache=True)
optimizer = stk.TryCatch(
stk.Sequence(
stk.MacroModelForceField(
macromodel_path=macromodel_path,
restricted=True,
use_cache=True,
timeout=10800,
),
stk.MacroModelForceField(
macromodel_path=macromodel_path,
restricted=False,
use_cache=True,
timeout=10800,
),
stk.TryCatch(
stk.MacroModelMD(
macromodel_path=macromodel_path,
temperature=700,
eq_time=100,
use_cache=True,
timeout=10800,
key=lambda mol: mol.func_groups[0].fg_type.name == 'aldehyde',
duplicate_building_blocks=False,
random_seed=random_seed,
use_cache=True,
),
random_seed=random_seed,
)
# #####################################################################
# Optimizer.
# #####################################################################
optimizer = stk.Sequence(
stk.MacroModelForceField(
macromodel_path='/home/lt912/schrodinger2017-4',
restricted=True,
use_cache=True,
),
stk.MacroModelForceField(
macromodel_path='/home/lt912/schrodinger2017-4',
restricted=False,
use_cache=True,
),
use_cache=True,
)
# #####################################################################
# Fitness Calculator.
# #####################################################################
def poly(file_1, func_1, file_2, func_2, units):
# turn off cache
stk.OPTIONS['cache'] = False
# make polymer
name_base = '_diol_difluorene_poly'
name_1 = file_1.replace('.mol', '')
name_2 = file_2.replace('.mol', '')
global NAME
NAME = name_1+'_'+name_2+name_base
unit_1 = stk.StructUnit2(file_1, func_1)
unit_2 = stk.StructUnit2(file_2, func_2)
polymer = stk.Polymer([unit_1, unit_2], stk.Linear('AB', [0, 0], n=units, ends='h'))
print(f'Creating polymer: {NAME}')
polymer.write(NAME+'.mol')
mol_polymer = Chem.MolFromMolFile(NAME + '.mol')
# optimization
print(f'Optimizing {NAME}')
macromodel_dir = 'pathMacroModel/'
rff = stk.MacroModelForceField(
macromodel_path=macromodel_dir,
restricted=True
)
uff = stk.MacroModelForceField(
macromodel_path=macromodel_dir,
restricted=False
)
md = stk.MacroModelMD(
macromodel_path=macromodel_dir,
temperature=700,
simulation_time=2000,
time_step=1,
eq_time=100
)
macromodel = stk.OptimizerSequence(rff, uff, md)
macromodel.optimize(polymer)
print (f'Optimization completed: {NAME}')
# save files
# make different directories
if name_base == '_anhydride_poly':
new_dir_1 = file_dir+'Dianhydride/'
if not os.path.exists(new_dir_1):
os.makedirs(new_dir_1)
else:
pass
polymer.write(new_dir_1+NAME+'.mol')
print (f'{NAME} has been saved as dianhydride.')
return (new_dir_1+NAME+'.mol')
else:
new_dir_2 = file_dir+'Polybenzodioxane/'
if not os.path.exists(new_dir_2):
os.makedirs(new_dir_2)
else:
pass
polymer.write(new_dir_2+NAME+'.mol')
print (f'{NAME} has been saved as polybenzodioxane.')
return (new_dir_2+NAME+'.mol')
