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() #<--