def check_isomorphic(conformer):
"""
Compares whatever is in the log file 'f'
to the SMILES of the passed in 'conformer'
"""
starting_molecule = RMGMolecule(smiles=conformer.smiles)
starting_molecule = starting_molecule.to_single_bonds()
atoms = self.read_log(
os.path.join(scratch_dir, f)
)
test_molecule = RMGMolecule()
test_molecule.from_xyz(
atoms.arrays["numbers"],
atoms.arrays["positions"]
)
if not starting_molecule.is_isomorphic(test_molecule):
logging.info(
"Output geometry of {} is not isomorphic with input geometry".format(calc.label))
return False
else:
logging.info(
"{} was successful and was validated!".format(calc.label))
return True
def validate_irc(self):
"""
A method to verify an IRC calc
"""
logging.info("Validating IRC file...")
irc_path = os.path.join(
self.directory, "ts", self.conformer.reaction_label, "irc",
self.conformer.reaction_label + "_irc_" +
self.conformer.direction + "_" + str(self.conformer.index) +
".log")
complete, converged = self.verify_output_file(irc_path)
if not complete:
logging.info("It seems that the IRC claculation did not complete")
return False
if not converged:
logging.info("The IRC calculation did not converge...")
return False
pth1 = list()
steps = list()
with open(irc_path) as output_file:
for line in output_file:
line = line.strip()
if line.startswith('Point Number:'):
if int(line.split()[2]) > 0:
if int(line.split()[-1]) == 1:
pt_num = int(line.split()[2])
pth1.append(pt_num)
else:
pass
elif line.startswith('# OF STEPS ='):
num_step = int(line.split()[-1])
steps.append(num_step)
# This indexes the coordinate to be used from the parsing
if steps == []:
logging.error('No steps taken in the IRC calculation!')
return False
else:
pth1End = sum(steps[:pth1[-1]])
# Compare the reactants and products
irc_parse = ccread(irc_path)
atomcoords = irc_parse.atomcoords
atomnos = irc_parse.atomnos
mol1 = RMGMolecule()
mol1.from_xyz(atomnos, atomcoords[pth1End])
mol2 = RMGMolecule()
mol2.from_xyz(atomnos, atomcoords[-1])
test_reaction = RMGReaction(
reactants=mol1.split(),
products=mol2.split(),
)
r, p = self.conformer.reaction_label.split("_")
reactants = []
products = []
for react in r.split("+"):
react = RMGMolecule(smiles=react)
reactants.append(react)
for prod in p.split("+"):
prod = RMGMolecule(smiles=prod)
products.append(prod)
possible_reactants = []
possible_products = []
for reactant in reactants:
possible_reactants.append(
reactant.generate_resonance_structures())
for product in products:
possible_products.append(
product.generate_resonance_structures())
possible_reactants = list(itertools.product(*possible_reactants))
possible_products = list(itertools.product(*possible_products))
for possible_reactant in possible_reactants:
reactant_list = []
for react in possible_reactant:
reactant_list.append(react.to_single_bonds())
for possible_product in possible_products:
product_list = []
for prod in possible_product:
product_list.append(prod.to_single_bonds())
target_reaction = RMGReaction(
reactants=list(reactant_list),
products=list(product_list))
if target_reaction.is_isomorphic(test_reaction):
logging.info("IRC calculation was successful!")
return True
logging.info("IRC calculation failed for {} :(".format(irc_path))
return False