def parse_grad( self, state, tempfileout=None, ): if tempfileout is None: tempfileout = 'scratch/{:03}/{}/output.dat'.format( self.ID, self.node_id) # GET GRADIENT FOR QMMMM -- REGULAR GRADIENT IS PARSED THROUGH grad.xyz # QMMM is done differently :( if "prmtop" in self.file_options.ActiveOptions: tmpgrad = [] with open(tempfileout, "r") as f: for line in f: if line.startswith("dE/dX", 8): for i in range(self.QM_atoms): findline = next(f, '').strip() mobj = re.match(r'(\S+)\s+(\S+)\s+(\S+)\s*$', findline) tmpgrad.append([ float(mobj.group(1)), float(mobj.group(2)), float(mobj.group(3)), ]) for i in range(self.link_atoms): next(f) # read two lines seperating the QM and MM regions next(f) next(f) for i in range(self.MM_atoms): findline = next(f, '').strip() mobj = re.match(r'(\S+)\s+(\S+)\s+(\S+)\s*$', findline) tmpgrad.append([ float(mobj.group(1)), float(mobj.group(2)), float(mobj.group(3)), ]) tmpgrad = np.asarray(tmpgrad) grad = np.zeros_like(tmpgrad) grad[self.qmindices] = tmpgrad[:len(self.qmindices)] grad[self.mm_indices] = tmpgrad[len(self.qmindices):] else: # getting gradient of non-prmtop job gradfile = 'scratch/{:03}/{}/grad_{}_{}.xyz'.format( self.ID, self.node_id, state[0], state[1]) grad = manage_xyz.read_xyz(gradfile, scale=1.0) grad = manage_xyz.xyz_to_np(grad) self._Gradients[state] = self.Gradient(grad, "Hartree/Bohr")
def parse_coup(self): tempfileout = 'scratch/{:03}/{}/output.dat'.format( self.ID, self.node_id) if "prmtop" in self.file_options.ActiveOptions: tmpcoup = [] with open(tempfileout, "r") as f: for line in f: if line.startswith("dE/dX", 8): # will work for SA-MC and RSPT2 HF for i in range(self.QM_atoms): findline = next(f, '').strip() mobj = re.match(r'(\S+)\s+(\S+)\s+(\S+)\s*$', findline) tmpcoup.append([ float(mobj.group(1)), float(mobj.group(2)), float(mobj.group(3)), ]) # read link atoms for i in range(self.link_atoms): next(f) next(f) next( f ) # read two lines seperating the QM and MM regions for i in range(self.MM_atoms): findline = next(f, '').strip() mobj = re.match(r'(\S+)\s+(\S+)\s+(\S+)\s*$', findline) tmpcoup.append([ float(mobj.group(1)), float(mobj.group(2)), float(mobj.group(3)), ]) tmpcoup = np.asarray(tmpcoup) coup = np.zeros_like(tmpcoup) coup[self.qmindices] = tmpcoup[:len(self.qmindices)] coup[self.mm_indices] = tmpcoup[len(self.qmindices):] else: coupfile = 'scratch/{:03}/{}/coup_{}_{}.xyz'.format( self.ID, self.node_id, self.coupling_states[0], self.coupling_states[1]) coup = manage_xyz.read_xyz(coupfile, scale=1.0) coup = manage_xyz.xyz_to_np(coup) self.Couplings[self.coupling_states] = self.Coupling( coup, 'Hartree/Bohr')
def copy_from_options(MoleculeA, xyz=None, fnm=None, new_node_id=1, copy_wavefunction=True): """Create a copy of MoleculeA""" print(" Copying from MoleculA {}".format(MoleculeA.node_id)) PES = type(MoleculeA.PES).create_pes_from( PES=MoleculeA.PES, options={'node_id': new_node_id}) if xyz is not None: new_geom = manage_xyz.np_to_xyz(MoleculeA.geometry, xyz) coord_obj = type(MoleculeA.coord_obj)( MoleculeA.coord_obj.options.copy().set_values({"xyz": xyz})) elif fnm is not None: new_geom = manage_xyz.read_xyz(fnm, scale=1.) xyz = manage_xyz.xyz_to_np(new_geom) coord_obj = type(MoleculeA.coord_obj)( MoleculeA.coord_obj.options.copy().set_values({"xyz": xyz})) else: new_geom = MoleculeA.geometry coord_obj = type(MoleculeA.coord_obj)( MoleculeA.coord_obj.options.copy()) return Molecule(MoleculeA.Data.copy().set_values({ 'PES': PES, 'coord_obj': coord_obj, 'geom': new_geom, 'node_id': new_node_id, 'copy_wavefunction': copy_wavefunction, }))
for tup in self.states: self._Gradients[tup] = self.Gradients(None, None) elif self.gradient_states and self.coupling_states or runtype == 'gh': self.run(geom, 'gh') elif self.gradient_states and not self.coupling_states or runtype == 'gradient': self.run(geom, 'gradient') else: raise RuntimeError self.hasRanForCurrentCoords = True return if __name__ == "__main__": # ,units.ANGSTROM_TO_AU) geom = manage_xyz.read_xyz('../../data/ethylene.xyz') B = BAGEL.from_options(states=[(1, 0), (1, 1)], gradient_states=[(1, 0), (1, 1)], coupling_states=(0, 1), geom=geom, lot_inp_file='bagel.txt', node_id=0) coords = manage_xyz.xyz_to_np(geom) E0 = B.get_energy(coords, 1, 0) E1 = B.get_energy(coords, 1, 1) g0 = B.get_gradient(coords, 1, 0) g1 = B.get_gradient(coords, 1, 1) c = B.get_coupling(coords, 1, 0, 1) print(E0, E1) print(g0.T) print(g1.T)
self.PES2.ad_idx, runtype='energy') cc += 1 rc += 1 return E1, E2 if __name__ == '__main__': from level_of_theories.pytc import PyTC import psiw import lightspeed as ls filepath = '../../data/ethylene.xyz' geom = manage_xyz.read_xyz(filepath, scale=1) # => Job Data <= ##### states = [(1, 0), (1, 1)] charge = 0 nocc = 7 nactive = 2 basis = '6-31gs' # => PSIW Obj <= ###### nifty.printcool("Build resources") resources = ls.ResourceList.build() nifty.printcool('{}'.format(resources)) molecule = ls.Molecule.from_xyz_file(filepath) geom = psiw.geometry.Geometry.build( resources=resources,
def __init__( self, options, ): """ Constructor """ self.options = options # properties self.Energy = namedtuple('Energy', 'value unit') self.Gradient = namedtuple('Gradient', 'value unit') self.Coupling = namedtuple('Coupling', 'value unit') self._Energies = {} self._Gradients = {} self._Couplings = {} # count number of states singlets = self.search_tuple(self.states, 1) doublets = self.search_tuple(self.states, 2) triplets = self.search_tuple(self.states, 3) quartets = self.search_tuple(self.states, 4) quintets = self.search_tuple(self.states, 5) #TODO do this for all states, since it catches if states are put in lazy e.g [(1,1)] if singlets: len_singlets = max(singlets, key=lambda x: x[1])[1] + 1 else: len_singlets = 0 len_doublets = len(doublets) len_triplets = len(triplets) len_quartets = len(quartets) len_quintets = len(quintets) # DO this before fixing states if put in lazy if self.options['gradient_states'] == None and self.calc_grad: print(" Assuming gradient states are ", self.states) self.options['gradient_states'] = self.options['states'] if len( self.states ) < len_singlets + len_doublets + len_triplets + len_quartets + len_quintets: print('fixing states to be proper length') tmp = [] # TODO put in rest of fixed states for i in range(len_singlets): tmp.append((1, i)) for i in range(len_triplets): tmp.append((3, i)) self.states = tmp print(' New states ', self.states) self.geom = self.options['geom'] if self.geom is not None: print(" initializing LOT from geom") elif self.options['fnm'] is not None: print(" initializing LOT from file") if not os.path.exists(self.options['fnm']): logger.error( 'Tried to create LOT object from a file that does not exist: %s\n' % self.options['fnm']) raise IOError self.geom = manage_xyz.read_xyz(self.options['fnm'], scale=1.) else: raise RuntimeError("Need to initialize LOT object") # Cache some useful atributes - other useful attributes are properties self.currentCoords = manage_xyz.xyz_to_np(self.geom) self.atoms = manage_xyz.get_atoms(self.geom) self.ID = self.options['ID'] self.nproc = self.options['nproc'] self.charge = self.options['charge'] self.node_id = self.options['node_id'] self.lot_inp_file = self.options['lot_inp_file'] # Bools for running self.hasRanForCurrentCoords = False self.has_nelectrons = False # Read file options if they exist and not already set if self.file_options is None: self.file_options = File_Options(self.lot_inp_file) #package specific implementation #TODO MOVE to specific package !!! # tc cloud self.options['job_data']['orbfile'] = self.options['job_data'].get( 'orbfile', '') # pytc? TODO self.options['job_data']['lot'] = self.options['job_data'].get( 'lot', None) print(" making folder scratch/{:03}/{}".format(self.ID, self.node_id)) os.system('mkdir -p scratch/{:03}/{}'.format(self.ID, self.node_id))
self.grada.append((multiplicity, gradient)) # print(gradient) @property def system(self): return self.options['job_data']['system'] @system.setter def system(self, value): self.options['job_data']['system'] = value if __name__ == "__main__": # QMMM #filepath='/export/zimmerman/craldaz/kevin2/tropcwatersphere.xyz' #geom = manage_xyz.read_xyz(filepath) #filepath='tropcwatersphere.xyz' #lot = pDynamo.from_options(states=[(5,0)],charge=-1,nproc=16,fnm=filepath,lot_inp_file='pdynamo_options_qmmm.txt') #lot.run(geom) # DFTB filepath = '../../data/ethylene.xyz' geom = manage_xyz.read_xyz(filepath) lot = pDynamo.from_options(states=[(1, 0)], charge=0, nproc=16, fnm=filepath, lot_inp_file='pdynamo_options_dftb.txt') lot.run(geom)
def __init__(self, options, **kwargs): self.Data = options # => Read in the coordinates <= # # important first try to read in geom t0 = time() if self.Data['geom'] is not None: print(" getting cartesian coordinates from geom") atoms = manage_xyz.get_atoms(self.Data['geom']) xyz = manage_xyz.xyz_to_np(self.Data['geom']) elif self.Data['fnm'] is not None: print(" reading cartesian coordinates from file") if self.Data['ftype'] is None: self.Data['ftype'] = os.path.splitext(self.Data['fnm'])[1][1:] if not os.path.exists(self.Data['fnm']): #logger.error('Tried to create Molecule object from a file that does not exist: %s\n' % self.Data['fnm']) raise IOError geom = manage_xyz.read_xyz(self.Data['fnm'], scale=1.) xyz = manage_xyz.xyz_to_np(geom) atoms = manage_xyz.get_atoms(geom) else: raise RuntimeError t1 = time() print(" Time to get coords= %.3f" % (t1 - t0)) #resid=[] #for a in ob.OBMolAtomIter(mol.OBMol): # res = a.GetResidue() # resid.append(res.GetName()) #self.resid = resid # Perform all the sanity checks and cache some useful attributes # TODO make PES property self.PES = type(self.Data['PES']).create_pes_from( PES=self.Data['PES'], options={'node_id': self.Data['node_id']}, copy_wavefunction=self.Data['copy_wavefunction']) if not hasattr(atoms, "__getitem__"): raise TypeError("atoms must be a sequence of atomic symbols") for a in atoms: if not isinstance(a, str): raise TypeError("atom symbols must be strings") if type(xyz) is not np.ndarray: raise TypeError("xyz must be a numpy ndarray") if xyz.shape != (len(atoms), 3): raise ValueError("xyz must have shape natoms x 3") self.Data['xyz'] = xyz.copy() # create a dictionary from atoms # atoms contain info you need to know about the atoms self.atoms = [ELEMENT_TABLE.from_symbol(atom) for atom in atoms] tx = time() print(" Time to create PES,elements %.3f" % (tx - t1)) t1 = tx if not isinstance(self.Data['comment'], str): raise TypeError("comment for a Molecule must be a string") # Create the coordinate system if self.Data['coord_obj'] is not None: print(" getting coord_object from options") self.coord_obj = self.Data['coord_obj'] else: print( " Disabling this feature, Molecule cannot create coordinate system" ) raise NotImplementedError #elif self.Data['coordinate_type'] == "Cartesian": # self.coord_obj = CartesianCoordinates.from_options(xyz=self.xyz,atoms=self.atoms) #elif self.Data['coordinate_type'] == "DLC": # print(" building coordinate object") # self.coord_obj = DelocalizedInternalCoordinates.from_options(xyz=self.xyz,atoms=self.atoms,connect=True,extra_kwargs =self.Data['top_settings']) #elif self.Data['coordinate_type'] == "HDLC": # self.coord_obj = DelocalizedInternalCoordinates.from_options(xyz=self.xyz,atoms=self.atoms,addcart=True,extra_kwargs =self.Data['top_settings']) #elif self.Data['coordinate_type'] == "TRIC": # self.coord_obj = DelocalizedInternalCoordinates.from_options(xyz=self.xyz,atoms=self.atoms,addtr=True,extra_kwargs =self.Data['top_settings']) self.Data['coord_obj'] = self.coord_obj t2 = time() print(" Time to build coordinate system= %.3f" % (t2 - t1)) #TODO self.gradrms = 0. self.isTSnode = False self.bdist = 0. self.newHess = 5 if self.Data['Hessian'] is None and self.Data['Form_Hessian']: if self.Data['Primitive_Hessian'] is None and type( self.coord_obj) is not CartesianCoordinates: self.form_Primitive_Hessian() t3 = time() print(" Time to build Prim Hessian %.3f" % (t3 - t2)) if self.Data['Primitive_Hessian'] is not None: print(" forming Hessian in basis") self.form_Hessian_in_basis() else: self.form_Hessian() #logger.info("Molecule %s constructed.", repr(self)) #logger.debug("Molecule %s constructed.", repr(self)) print(" molecule constructed")
# drij.append(AtomContact(xyz,AtomIterator,box=np.array([self.boxes[sn].a, self.boxes[sn].b, self.boxes[sn].c]))) # else: drij.append(AtomContact(xyz, AtomIterator)) return AtomIterator, drij if __name__ == '__main__' and __package__ is None: from os import sys, path sys.path.append(path.dirname(path.dirname(path.abspath(__file__)))) #filepath='../../data/butadiene_ethene.xyz' #filepath='crystal.xyz' filepath1 = 'multi1.xyz' filepath2 = 'multi2.xyz' geom1 = manage_xyz.read_xyz(filepath1) geom2 = manage_xyz.read_xyz(filepath2) atom_symbols = manage_xyz.get_atoms(geom1) xyz1 = manage_xyz.xyz_to_np(geom1) xyz2 = manage_xyz.xyz_to_np(geom2) ELEMENT_TABLE = elements.ElementData() atoms = [ELEMENT_TABLE.from_symbol(atom) for atom in atom_symbols] #print(atoms) #hybrid_indices = list(range(0,10)) + list(range(21,26)) hybrid_indices = list(range(16, 26)) G1 = Topology.build_topology(xyz1, atoms, hybrid_indices=hybrid_indices) G2 = Topology.build_topology(xyz2, atoms, hybrid_indices=hybrid_indices)