def shrink(ENGINE, newDim): ENGINE.set_groups_as_molecules() [ g.set_move_generator( MoveGeneratorCollector(collection=[ TranslationGenerator(amplitude=0.2), RotationGenerator(amplitude=5) ], randomize=True)) for g in ENGINE.groups ] # get groups order centers = [ np.sum(ENGINE.realCoordinates[g.indexes], axis=0) / len(g) for g in ENGINE.groups ] distances = [np.sqrt(np.add.reduce(c**2)) for c in centers] order = np.argsort(distances) # change boundary conditions bcFrom = str([list(bc) for bc in ENGINE.boundaryConditions.get_vectors()]) ENGINE.set_boundary_conditions(newDim) bcTo = str([list(bc) for bc in ENGINE.boundaryConditions.get_vectors()]) LOGGER.info("boundary conditions changed from %s to %s" % (bcFrom, bcTo)) # set selector recur = 200 gs = RecursiveGroupSelector(DefinedOrderSelector(ENGINE, order=order), recur=recur, refine=True) ENGINE.set_group_selector(gs) # number of steps nsteps = recur * len(ENGINE.groups) for stepIdx in range(10): LOGGER.info("Running 'shrink' mode step %i" % (stepIdx)) ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps) fname = "shrink_" + str(newDim).replace(".", "p")
def run_molecules(ENGINE, rang=5, recur=100, refine=False, explore=True, exportPdb=False, xyzFrequency=500): ENGINE.set_groups_as_molecules() [ g.set_move_generator( MoveGeneratorCollector(collection=[ TranslationGenerator(amplitude=0.2), RotationGenerator(amplitude=2) ], randomize=True)) for g in ENGINE.groups ] # number of steps nsteps = 20 * len(ENGINE.groups) # set selector gs = RecursiveGroupSelector(RandomSelector(ENGINE), recur=recur, refine=refine, explore=explore) ENGINE.set_group_selector(gs) for stepIdx in range(rang): LOGGER.info("Running 'molecules' mode step %i" % (stepIdx)) ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps, xyzFrequency=xyzFrequency, xyzPath="moleculeTraj.xyz", restartPdb=None)
def along1(ENGINE, rang=5, recur=100, refine=False, explore=True): ENGINE.set_groups_as_molecules() [ g.set_move_generator( TranslationAlongSymmetryAxisGenerator(axis=1, amplitude=0.1)) for g in ENGINE.groups ] # set selector centers = [ np.sum(ENGINE.realCoordinates[g.indexes], axis=0) / len(g) for g in ENGINE.groups ] distances = [np.sqrt(np.add.reduce(c**2)) for c in centers] order = np.argsort(distances) recur = 200 gs = RecursiveGroupSelector(DefinedOrderSelector(ENGINE, order=order), recur=recur, refine=refine, explore=explore) ENGINE.set_group_selector(gs) # number of steps nsteps = recur * len(ENGINE.groups) for stepIdx in range(rang): LOGGER.info("Running 'along1' mode step %i" % (stepIdx)) ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)
def angles_HCH(ENGINE, rang=5, recur=10, refine=False, explore=True): groups = [] for idx in range(0, ENGINE.pdb.numberOfAtoms, 13): groups.append(np.array([idx + 1, idx + 2, idx + 3], dtype=np.int32)) # H11-C1-H12 groups.append(np.array([idx + 4, idx + 5, idx + 6], dtype=np.int32)) # H21-C2-H22 groups.append(np.array([idx + 7, idx + 8, idx + 9], dtype=np.int32)) # H31-C3-H32 groups.append(np.array([idx + 10, idx + 11, idx + 12], dtype=np.int32)) # H41-C4-H42 ENGINE.set_groups(groups) [ g.set_move_generator(AngleAgitationGenerator(amplitude=5)) for g in ENGINE.groups ] # set selector if refine or explore: gs = RecursiveGroupSelector(RandomSelector(ENGINE), recur=recur, refine=refine, explore=explore) ENGINE.set_group_selector(gs) # number of steps nsteps = recur * len(ENGINE.groups) for stepIdx in range(rang): LOGGER.info("Running 'angles_HCH' mode step %i" % (stepIdx)) ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)
def run(nsteps, groups=None, pdf=False, vdw=False, bond=False, angle=False, improper=False, message=""): # reset pdb ENGINE.set_pdb(pdbPath) ENGINE.set_groups(groups) # initialize constraints data PDF_CONSTRAINT.set_used(pdf) EMD_CONSTRAINT.set_used(vdw) B_CONSTRAINT.set_used(bond) BA_CONSTRAINT.set_used(angle) IA_CONSTRAINT.set_used(improper) # run ENGINE.initialize_used_constraints() tic = time.time() ENGINE.run(numberOfSteps=nsteps, saveFrequency=2*nsteps, restartPdb=None) spentTime = time.time()-tic # log message += "constraints --> (" if pdf: message += "pdf," if vdw: message += "vdw," if bond: message += "bond," if angle: message += "angle," if improper: message += "improper," message += ") steps (%i) time (%i sec) \n"%(nsteps, spentTime) LOGGER.info("generated:%i - tried:%i - accepted:%i"%(ENGINE.generated, ENGINE.tried, ENGINE.accepted)) LOGGER.info(message) return float(spentTime)/float(nsteps), ENGINE.tried , ENGINE.accepted
def _set_fitted_scale_factor_value(self, scaleFactor): """ This method is a scaleFactor value without any validity checking. Meant to be used internally only. """ if self.__scaleFactor != scaleFactor: LOGGER.info("Experimental constraint '%s' scale factor updated from %.6f to %.6f" %(self.__class__.__name__, self.__scaleFactor, scaleFactor)) self.__scaleFactor = scaleFactor
def atoms(ENGINE, rang=30, recur=20, refine=False, explore=True): ENGINE.set_groups_as_atoms() # set selector if refine or explore: gs = RecursiveGroupSelector(RandomSelector(ENGINE), recur=recur, refine=refine, explore=explore) ENGINE.set_group_selector(gs) # number of steps nsteps = recur * len(ENGINE.groups) for stepIdx in range(rang): LOGGER.info("Running 'atoms' mode step %i" % (stepIdx)) ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)
def run_atoms(ENGINE, rang=None, recur=None, xyzFrequency=500): ENGINE.set_groups(None) # set selector if recur is None: recur = 10 ENGINE.set_group_selector(RandomSelector(ENGINE)) # number of steps nsteps = recur * len(ENGINE.groups) if rang is None: rang = 20 for stepIdx in range(rang): LOGGER.info("Running 'atoms' mode step %i" % (stepIdx)) ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps, xyzFrequency=xyzFrequency, xyzPath="atomsTraj.xyz", restartPdb=None)
def run_recurring_atoms(ENGINE, rang=None, recur=None, explore=True, refine=False, xyzFrequency=500): ENGINE.set_groups(None) # set selector if recur is None: recur = 10 gs = RecursiveGroupSelector(RandomSelector(ENGINE), recur=recur, refine=refine, explore=explore) ENGINE.set_group_selector(gs) # number of steps nsteps = recur * len(ENGINE.groups) if rang is None: rang = 20 for stepIdx in range(rang): LOGGER.info("Running 'explore' mode step %i" % (stepIdx)) if explore: ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps, xyzFrequency=xyzFrequency, xyzPath="exploreTraj.xyz", restartPdb=None) elif refine: ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps, xyzFrequency=xyzFrequency, xyzPath="refineTraj.xyz", restartPdb=None) else: ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps, xyzFrequency=xyzFrequency, xyzPath="recurTraj.xyz", restartPdb=None)
def atoms_type(ENGINE, type='C', rang=30, recur=20, refine=False, explore=True): allElements = ENGINE.allElements groups = [] for idx, el in enumerate(allElements): if el == type: groups.append([idx]) ENGINE.set_groups(groups) # set selector if refine or explore: gs = RecursiveGroupSelector(RandomSelector(ENGINE), recur=recur, refine=refine, explore=explore) ENGINE.set_group_selector(gs) # number of steps nsteps = recur * len(ENGINE.groups) for stepIdx in range(rang): LOGGER.info("Running 'atoms' mode step %i" % (stepIdx)) ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)
# add multiframe if not ENGINE.is_frame(multiframe): ENGINE.add_frame({'name':multiframe, 'frames_name':numberOfFrames}) for sf in ENGINE.frames[multiframe]['frames_name']: ENGINE.set_used_frame(os.path.join(multiframe, sf)) ENGINE.set_pdb(os.path.join(DIR_PATH, 'multiframe_structure_%s.pdb'%sf)) _usedConstraints, _constraints, _rigidConstraints = ENGINE.initialize_used_constraints(sortConstraints=True) if not len(_usedConstraints): LOGGER.warn("@%s No constraints are used. Configuration will be randomized"%ENGINE.usedFrame) # runtime initialize group selector ENGINE._Engine__groupSelector._runtime_initialize() # runtime initialize constraints _=[c._runtime_initialize() for c in _usedConstraints] LOGGER.info("@%s Stochastic engine files are created"%ENGINE.usedFrame) ################################################################################ ###################### CREATE SOFTGRID WORKERS MANAGEMENT ###################### WM = MultiframeUtils.WorkersManagement() WM.start(engine=ENGINE, multiframe='size_distribution', orchestrator=None) ################################################################################ ######################## OPTIMIZE OXYGEN ATOMS POSITION ######################## for sf in ENGINE.frames[multiframe]['frames_name']: fname = os.path.join(multiframe, sf) ENGINE.set_used_frame(fname) # set groups as oxygen atoms only elements = ENGINE.get_original_data('allElements')
def run(self, numberOfSteps=100000, saveFrequency=1000, savePath="restart", xyzFrequency=None, xyzPath="trajectory.xyz"): """ This is an exact copy of engine run method with slight changes marked with #--> to make two trajectories, one of the real system and another the explored space. new code is marked with #<-- all leading variables double scores __ removed. """ # get arguments #-->_numberOfSteps = self.__runtime_get_number_of_steps(numberOfSteps) #-->_saveFrequency, _savePath = self.__runtime_get_save_engine(saveFrequency, savePath) #-->_xyzFrequency, _xyzPath = self.__runtime_get_save_xyz(xyzFrequency, xyzPath) _numberOfSteps = numberOfSteps #<-- _saveFrequency = 2 * numberOfSteps #<-- _savePath = savePath #<-- # create xyz file #-->if _xyzFrequency is not None: #--> _xyzfd = open(_xyzPath, 'a') _xyzfd = open("trajectory.xyz", 'a') #<-- # get and initialize used constraints _usedConstraints, _constraints, _rigidConstraints = self.initialize_used_constraints( ) if not len(_usedConstraints): LOGGER.warn( "No constraints are used. Configuration will be randomize") # compute biasedStdErr self.biasedStdErr = self.compute_total_standard_error(_constraints, current=True) # initialize useful arguments _engineStartTime = time.time() _lastSavedChiSquare = self.biasedStdErr _coordsBeforeMove = None _moveTried = False # initialize group selector self.groupSelector._runtime_initialize() self.__realCoords = self.realCoordinates #<-- self.__boxCoords = self.boxCoordinates #<-- # ##################################################################################### # # #################################### RUN ENGINE ##################################### # LOGGER.info("Engine started %i steps, biasedStdErr is: %.6f" % (_numberOfSteps, self.biasedStdErr)) self.__generated = 0 #<-- self.__tried = 0 #<-- self.__accepted = 0 #<-- for step in xrange(_numberOfSteps): # increment generated self.__generated += 1 # get group self.__lastSelectedGroupIndex = self.groupSelector.select_index() group = self.groups[self.__lastSelectedGroupIndex] # get atoms indexes groupAtomsIndexes = group.indexes # get move generator groupMoveGenerator = group.moveGenerator # get group atoms coordinates before applying move if _coordsBeforeMove is None or not self.groupSelector.isRecurring: _coordsBeforeMove = np.array( self.realCoordinates[groupAtomsIndexes], dtype=self.realCoordinates.dtype) elif self.groupSelector.explore: if _moveTried: _coordsBeforeMove = movedRealCoordinates elif not self.groupSelector.refine: _coordsBeforeMove = np.array( self.realCoordinates[groupAtomsIndexes], dtype=self.realCoordinates.dtype) # compute moved coordinates movedRealCoordinates = groupMoveGenerator.move(_coordsBeforeMove) movedBoxCoordinates = transform_coordinates( transMatrix=self.reciprocalBasisVectors, coords=movedRealCoordinates) ########################### compute enhanceOnlyConstraints ############################ rejectMove = False for c in _rigidConstraints: # compute before move c.compute_before_move(realIndexes=groupAtomsIndexes, relativeIndexes=groupAtomsIndexes) # compute after move c.compute_after_move(realIndexes=groupAtomsIndexes, relativeIndexes=groupAtomsIndexes, movedBoxCoordinates=movedBoxCoordinates) # get rejectMove rejectMove = c.should_step_get_rejected( c.afterMoveStandardError) if rejectMove: break _moveTried = not rejectMove ############################## reject move before trying ############################## if rejectMove: # enhanceOnlyConstraints reject move for c in _rigidConstraints: c.reject_move(realIndexes=groupAtomsIndexes, relativeIndexes=groupAtomsIndexes) # log generated move rejected before getting tried LOGGER.log("move not tried", "Generated move %i is not tried" % self.tried) ###################################### try move ####################################### else: self.__tried += 1 for c in _constraints: # compute before move c.compute_before_move(realIndexes=groupAtomsIndexes, relativeIndexes=groupAtomsIndexes) # compute after move c.compute_after_move( realIndexes=groupAtomsIndexes, relativeIndexes=groupAtomsIndexes, movedBoxCoordinates=movedBoxCoordinates) ################################ compute new biasedStdErr ################################ newStdErr = self.compute_total_standard_error(_constraints, current=False) #if len(_constraints) and (newStdErr >= self.biasedStdErr): if newStdErr > self.biasedStdErr: if generate_random_float() > self.tolerance: rejectMove = True else: self.tolerated += 1 self.biasedStdErr = newStdErr else: self.biasedStdErr = newStdErr ################################## reject tried move ################################## if rejectMove: # set selector move rejected self.groupSelector.move_rejected(self.__lastSelectedGroupIndex) if _moveTried: # constraints reject move for c in _constraints: c.reject_move(realIndexes=groupAtomsIndexes, relativeIndexes=groupAtomsIndexes) # log tried move rejected LOGGER.log("move rejected", "Tried move %i is rejected" % self.__generated) ##################################### accept move ##################################### else: self.__accepted += 1 # set selector move accepted self.groupSelector.move_accepted(self.__lastSelectedGroupIndex) # constraints reject move for c in _usedConstraints: c.accept_move(realIndexes=groupAtomsIndexes, relativeIndexes=groupAtomsIndexes) # set new coordinates self.__realCoords[groupAtomsIndexes] = movedRealCoordinates self.__boxCoords[groupAtomsIndexes] = movedBoxCoordinates # log new successful move triedRatio = 100. * (float(self.__tried) / float(self.__generated)) acceptedRatio = 100. * (float(self.__accepted) / float(self.__generated)) LOGGER.log( "move accepted", "Generated:%i - Tried:%i(%.3f%%) - Accepted:%i(%.3f%%) - biasedStdErr:%.6f" % (self.__generated, self.__tried, triedRatio, self.__accepted, acceptedRatio, self.biasedStdErr)) ##################################### save engine ##################################### if _saveFrequency is not None: if not (step + 1) % _saveFrequency: if _lastSavedChiSquare == self.biasedStdErr: LOGGER.info( "Save engine omitted because no improvement made since last save." ) else: # update state self.state = time.time() for c in _usedConstraints: #c.increment_tried() c.set_state(self.state) # save engine _lastSavedChiSquare = self.biasedStdErr self.save(_savePath) ############################### dump coords to xyz file ############################### #-->if _xyzFrequency is not None: #--> if not(step+1)%_xyzFrequency: #--> _xyzfd.write("%s\n"%self.__pdb.numberOfAtoms) #--> triedRatio = 100.*(float(self.__tried)/float(self.__generated)) #--> acceptedRatio = 100.*(float(self.__accepted)/float(self.__generated)) #--> _xyzfd.write("Generated:%i - Tried:%i(%.3f%%) - Accepted:%i(%.3f%%) - biasedStdErr:%.6f\n" %(self.__generated , self.__tried, triedRatio, self.__accepted, acceptedRatio, self.biasedStdErr)) #--> frame = [self.allNames[idx]+ " " + "%10.5f"%self.__realCoords[idx][0] + " %10.5f"%self.__realCoords[idx][1] + " %10.5f"%self.__realCoords[idx][2] + "\n" for idx in self.__pdb.xindexes] #--> _xyzfd.write("".join(frame)) triedRatio = 100. * (float(self.__tried) / float(self.__generated) ) #<-- acceptedRatio = 100. * ( float(self.__accepted) / float(self.__generated)) #<-- _xyzfd.write("%s\n" % (len(groupAtomsIndexes) * 2)) #<-- _xyzfd.write( "Generated:%i - Tried:%i(%.3f%%) - Accepted:%i(%.3f%%) - biasedStdErr:%.6f\n" % (self.__generated, self.__tried, triedRatio, self.__accepted, acceptedRatio, self.biasedStdErr)) #<-- frame = [ self.allNames[idx] + " " + "%10.5f" % self.realCoordinates[idx][0] + " %10.5f" % self.realCoordinates[idx][1] + " %10.5f" % self.realCoordinates[idx][2] + "\n" for idx in groupAtomsIndexes ] #<-- frame.extend([ self.allNames[idx] + " " + "%10.5f" % _coordsBeforeMove[idx][0] + " %10.5f" % _coordsBeforeMove[idx][1] + " %10.5f" % _coordsBeforeMove[idx][2] + "\n" for idx in range(_coordsBeforeMove.shape[0]) ]) #<-- _xyzfd.write("".join(frame)) #<-- # ##################################################################################### # # ################################# FINISH ENGINE RUN ################################# # #-->LOGGER.info("Engine finishes executing all '%i' steps in %s" % (_numberOfSteps, get_elapsed_time(_engineStartTime, format="%d(days) %d:%d:%d"))) # close .xyz file #-->if _xyzFrequency is not None: #--> _xyzfd.close() _xyzfd.close() #<--