def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R * self.getOption('T') ntrials = self.getOption('ntrials') acc = 0 xo = np.copy(self.universe.configuration().array) eo = self.universe.energy() com = self.universe.centerOfMass().array for c in range(ntrials): step = np.random.randn(3) * self.step_size if c % 2 == 0: # Random translation and full rotation xn = np.dot((xo - com), random_rotate()) + com + step else: # Random translation xn = xo + step self.universe.setConfiguration(Configuration(self.universe, xn)) en = self.universe.energy() if ((en < eo) or (np.random.random() < np.exp(-(en - eo) / RT))): acc += 1 xo = xn eo = en com += step else: self.universe.setConfiguration(Configuration( self.universe, xo)) return ([np.copy(xo)], [en], acc, ntrials, 0.0)
def __init__(self, universe=None, temperature=300. * Units.K, subspace=None, delta=None, sparse=False): if universe == None: return Features.checkFeatures(self, universe) Core.NormalModes.__init__( self, universe, subspace, delta, sparse, ['array', 'imaginary', 'frequencies', 'omega_sq']) self.temperature = temperature self.weights = N.sqrt(self.universe.masses().array) self.weights = self.weights[:, N.NewAxis] self._forceConstantMatrix() ev = self._diagonalize() self.imaginary = N.less(ev, 0.) self.omega_sq = ev self.frequencies = N.sqrt(N.fabs(ev)) / (2. * N.pi) self.sort_index = N.argsort(self.frequencies) self.array.shape = (self.nmodes, self.natoms, 3) self.cleanup()
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R*self.getOption('T') delta_t = self.getOption('delta_t') if 'steps_per_trial' in self.call_options.keys(): steps_per_trial = self.getOption('steps_per_trial') ntrials = self.getOption('steps')/steps_per_trial else: steps_per_trial = self.getOption('steps') ntrials = 1 if 'normalize' in self.call_options.keys(): normalize = self.getOption('normalize') else: normalize = False # Get the universe variables needed by the integrator masses = self.universe.masses() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') comm = self.getOption('mpi_communicator') evaluator = self.universe.energyEvaluator(threads=nt, mpi_communicator=comm) evaluator = evaluator.CEvaluator() late_args = ( masses.array, fixed.array, evaluator, N.zeros((0, 2), N.Int), N.zeros((0, ), N.Float), N.zeros((1,), N.Int), N.zeros((0,), N.Float), N.zeros((2,), N.Float), N.zeros((0,), N.Float), N.zeros((1,), N.Float), delta_t, self.getOption('first_step'), steps_per_trial, self.getActions(), 'Velocity Verlet step') xs = [] energies = [] acc = 0 for t in range(ntrials): # Initialize the velocity self.universe.initializeVelocitiesToTemperature(self.getOption('T')) # Store previous configuration and initial energy xo = self.universe.copyConfiguration() pe_o = self.universe.energy() eo = pe_o + self.universe.kineticEnergy() # Run the velocity verlet integrator self.run(MMTK_dynamics.integrateVV, (self.universe, self.universe.configuration().array, self.universe.velocities().array) + late_args) return (xs, energies, float(acc)/float(ntrials), delta_t)
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R * self.getOption("T") ntrials = self.getOption("ntrials") acc = 0 xo = np.copy(self.universe.configuration().array) eo = self.universe.energy() com = self.universe.centerOfMass().array for c in range(ntrials): step = np.random.randn(3) * self.step_size if c % 2 == 0: # Random translation and full rotation xn = np.dot((xo - com), random_rotate()) + com + step else: # Random translation xn = xo + step self.universe.setConfiguration(Configuration(self.universe, xn)) en = self.universe.energy() if (en < eo) or (np.random.random() < np.exp(-(en - eo) / RT)): acc += 1 xo = xn eo = en com += step else: self.universe.setConfiguration(Configuration(self.universe, xo)) return ([np.copy(xo)], [en], acc, ntrials, 0.0)
def __init__(self, universe=None, friction=None, temperature=300. * Units.K, subspace=None, delta=None, sparse=False): if universe == None: return Features.checkFeatures(self, universe) Core.NormalModes.__init__(self, universe, subspace, delta, sparse, ['array', 'inv_relaxation_times']) self.friction = friction self.temperature = temperature self.weights = N.sqrt(friction.array) self.weights = self.weights[:, N.NewAxis] self._forceConstantMatrix() ev = self._diagonalize() self.inv_relaxation_times = ev self.sort_index = N.argsort(self.inv_relaxation_times) self.array.shape = (self.nmodes, self.natoms, 3) self.cleanup()
def __call__(self, **options): """ Run the minimizer. The keyword options are the same as described under __init__. """ self.setCallOptions(options) Features.checkFeatures(self, self.universe) configuration = self.universe.configuration() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') evaluator = self.universe.energyEvaluator(threads=nt).CEvaluator() args = (self.universe, configuration.array, fixed.array, evaluator, self.getOption('steps'), self.getOption('step_size'), self.getOption('convergence'), self.getActions(), 'Conjugate gradient minimization with ' + self.optionString(['convergence', 'step_size', 'steps'])) return self.run(conjugateGradient, args)
def __call__(self, **options): """ Run the minimizer. The keyword options are the same as described under __init__. """ self.setCallOptions(options) Features.checkFeatures(self, self.universe) configuration = self.universe.configuration() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') evaluator = self.universe.energyEvaluator(threads=nt).CEvaluator() args =(self.universe, configuration.array, fixed.array, evaluator, self.getOption('steps'), self.getOption('step_size'), self.getOption('convergence'), self.getActions(), 'Conjugate gradient minimization with ' + self.optionString(['convergence', 'step_size', 'steps'])) return self.run(conjugateGradient, args)
def __call__(self, **options): """ Run the integrator. The keyword options are the same as described under __init__. """ self.setCallOptions(options) used_features = Features.checkFeatures(self, self.universe) configuration = self.universe.configuration() velocities = self.universe.velocities() if velocities is None: raise ValueError("no velocities") masses = self.universe.masses() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') comm = self.getOption('mpi_communicator') evaluator = self.universe.energyEvaluator(threads=nt, mpi_communicator=comm) evaluator = evaluator.CEvaluator() constraints, const_distances_sq, c_blocks = \ _constraintArrays(self.universe) type = 'NVE' if Features.NoseThermostatFeature in used_features: type = 'NVT' thermostat = self.universe.environmentObjectList( Environment.NoseThermostat)[0] t_parameters = thermostat.parameters t_coordinates = thermostat.coordinates else: t_parameters = N.zeros((0,), N.Float) t_coordinates = N.zeros((2,), N.Float) if Features.AndersenBarostatFeature in used_features: if self.universe.cellVolume() is None: raise ValueError("Barostat requires finite volume universe") if type == 'NVE': type = 'NPH' else: type = 'NPT' barostat = self.universe.environmentObjectList( Environment.AndersenBarostat)[0] b_parameters = barostat.parameters b_coordinates = barostat.coordinates else: b_parameters = N.zeros((0,), N.Float) b_coordinates = N.zeros((1,), N.Float) args = (self.universe, configuration.array, velocities.array, masses.array, fixed.array, evaluator, constraints, const_distances_sq, c_blocks, t_parameters, t_coordinates, b_parameters, b_coordinates, self.getOption('delta_t'), self.getOption('first_step'), self.getOption('steps'), self.getActions(), type + ' dynamics trajectory with ' + self.optionString(['delta_t', 'steps'])) return self.run(MMTK_dynamics.integrateVV, args)
def __init__(self, universe=None, temperature = 300, subspace = None, delta = None, sparse = False): if universe == None: return Features.checkFeatures(self, universe) Core.NormalModes.__init__(self, universe, subspace, delta, sparse, ['array', 'force_constants']) self.temperature = temperature self.weights = N.ones((1, 1), N.Float) self._forceConstantMatrix() ev = self._diagonalize() self.force_constants = ev self.sort_index = N.argsort(self.force_constants) self.array.shape = (self.nmodes, self.natoms, 3) self.cleanup()
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R*self.getOption('T') ntrials = self.getOption('ntrials') natoms = self.universe.numberOfAtoms() acc = 0 xo = np.copy(self.universe.configuration().array) com = self.universe.centerOfMass().array if self.sampling_universe is None: eo = self.universe.energy() else: self.sampling_universe.configuration().array[-natoms:,:] = xo eo = self.sampling_universe.energy() # <- Using sampling Hamiltonian for c in range(ntrials): step = np.random.randn(3)*self.step_size if c%2==0: # Random translation and full rotation xn = np.dot((xo - com), random_rotate()) + com + step else: # Random translation xn = xo + step if self.sampling_universe is None: self.universe.setConfiguration(Configuration(self.universe,xn)) en = self.universe.energy() else: self.sampling_universe.configuration().array[-natoms:,:] = xn en = self.sampling_universe.energy() # <- Using sampling Hamiltonian if ((en<eo) or (np.random.random()<np.exp(-(en-eo)/RT))): acc += 1 xo = xn eo = en com += step else: self.universe.setConfiguration(Configuration(self.universe,xo)) return ([np.copy(xo)], [en], acc, ntrials, 0.0)
def __call__(self, **options): """ Run the integrator. The keyword options are the same as described under __init__. """ self.setCallOptions(options) used_features = Features.checkFeatures(self, self.universe) configuration = self.universe.configuration() velocities = self.universe.velocities() if velocities is None: raise ValueError("no velocities") masses = self.universe.masses() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') comm = self.getOption('mpi_communicator') evaluator = self.universe.energyEvaluator(threads=nt, mpi_communicator=comm) evaluator = evaluator.CEvaluator() constraints, const_distances_sq, c_blocks = \ _constraintArrays(self.universe) type = 'NVE' if Features.NoseThermostatFeature in used_features: type = 'NVT' thermostat = self.universe.environmentObjectList( Environment.NoseThermostat)[0] t_parameters = thermostat.parameters t_coordinates = thermostat.coordinates else: t_parameters = N.zeros((0, ), N.Float) t_coordinates = N.zeros((2, ), N.Float) if Features.AndersenBarostatFeature in used_features: if self.universe.cellVolume() is None: raise ValueError("Barostat requires finite volume universe") if type == 'NVE': type = 'NPH' else: type = 'NPT' barostat = self.universe.environmentObjectList( Environment.AndersenBarostat)[0] b_parameters = barostat.parameters b_coordinates = barostat.coordinates else: b_parameters = N.zeros((0, ), N.Float) b_coordinates = N.zeros((1, ), N.Float) args = (self.universe, configuration.array, velocities.array, masses.array, fixed.array, evaluator, constraints, const_distances_sq, c_blocks, t_parameters, t_coordinates, b_parameters, b_coordinates, self.getOption('delta_t'), self.getOption('first_step'), self.getOption('steps'), self.getActions(), type + ' dynamics trajectory with ' + self.optionString(['delta_t', 'steps'])) return self.run(MMTK_dynamics.integrateVV, args)
def __init__(self, universe = None, friction = None, temperature = 300.*Units.K, subspace = None, delta = None, sparse = False): if universe == None: return Features.checkFeatures(self, universe) Core.NormalModes.__init__(self, universe, subspace, delta, sparse, ['array', 'inv_relaxation_times']) self.friction = friction self.temperature = temperature self.weights = N.sqrt(friction.array) self.weights = self.weights[:, N.NewAxis] self._forceConstantMatrix() ev = self._diagonalize() self.inv_relaxation_times = ev self.sort_index = N.argsort(self.inv_relaxation_times) self.array.shape = (self.nmodes, self.natoms, 3) self.cleanup()
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) # Get the universe variables needed by the integrator configuration = self.universe.configuration() masses = self.universe.masses() velocities = self.universe.velocities() if velocities is None: raise ValueError("no velocities") # Get the friction coefficients. First check if a keyword argument # 'friction' was given to the integrator. Its value can be a # ParticleScalar or a plain number (used for all atoms). If no # such argument is given, collect the values of the attribute # 'friction' from all atoms (default is zero). try: friction = self.getOption('friction') except KeyError: friction = self.universe.getParticleScalar('friction') if not ParticleProperties.isParticleProperty(friction): var = ParticleProperties.ParticleScalar(self.universe) var.array[:] = friction friction = var # Construct a C evaluator object for the force field, using # the specified number of threads or the default value nt = self.getOption('threads') evaluator = self.universe.energyEvaluator(threads=nt).CEvaluator() # Run the C integrator MMTK_langevin.integrateLD(self.universe, configuration.array, velocities.array, masses.array, friction.array, evaluator, self.getOption('temperature'), self.getOption('delta_t'), self.getOption('steps'), self.getActions())
def __init__(self, universe=None, temperature=300, subspace=None, delta=None, sparse=False): if universe == None: return Features.checkFeatures(self, universe) Core.NormalModes.__init__(self, universe, subspace, delta, sparse, ['array', 'force_constants']) self.temperature = temperature self.weights = N.ones((1, 1), N.Float) self._forceConstantMatrix() ev = self._diagonalize() self.force_constants = ev self.sort_index = N.argsort(self.force_constants) self.array.shape = (self.nmodes, self.natoms, 3) self.cleanup()
def __init__(self, universe=None, temperature = 300.*Units.K, subspace = None, delta = None, sparse = False): if universe == None: return Features.checkFeatures(self, universe) Core.NormalModes.__init__(self, universe, subspace, delta, sparse, ['array', 'imaginary', 'frequencies', 'omega_sq']) self.temperature = temperature self.weights = N.sqrt(self.universe.masses().array) self.weights = self.weights[:, N.NewAxis] self._forceConstantMatrix() ev = self._diagonalize() self.imaginary = N.less(ev, 0.) self.omega_sq = ev self.frequencies = N.sqrt(N.fabs(ev)) / (2.*N.pi) self.sort_index = N.argsort(self.frequencies) self.array.shape = (self.nmodes, self.natoms, 3) self.cleanup()
def __call__(self, **options): if (self.confs is None) or len(self.confs)<3: return ([self.universe.copyConfiguration()], [self.universe.energy()], 0.0, 0.0) # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R*self.getOption('T') ntrials = self.getOption('ntrials') acc = 0. energies = [] closest_poses = [] xo_Cartesian = self.universe.copyConfiguration() xo_BAT = np.array(self._BAT_util.BAT(extended=self.extended)) eo = self.universe.energy() if self.extended: closest_pose_o = self._closest_pose_Cartesian(\ xo_Cartesian.array[self.molecule.heavy_atoms,:]) else: closest_pose_o = self._closest_pose_BAT(xo_BAT[self._BAT_to_perturb]) for t in range(ntrials): # Choose a pose to dart towards dart_towards = closest_pose_o while dart_towards==closest_pose_o: dart_towards = np.random.choice(len(self.weights), p=self.weights) # Generate a trial move xn_BAT = np.copy(xo_BAT) xn_BAT[self._BAT_to_perturb] = xo_BAT[self._BAT_to_perturb] + self.darts[closest_pose_o][dart_towards] xn_Cartesian = Configuration(self.universe,self._BAT_util.Cartesian(xn_BAT)) # Sets the universe en = self.universe.energy() if self.extended: closest_pose_n = self._closest_pose_Cartesian(\ xn_Cartesian.array[self.molecule.heavy_atoms,:]) else: closest_pose_n = self._closest_pose_BAT(xn_BAT[self._BAT_to_perturb]) # Accept or reject the trial move if (en<eo) or (np.random.random()<np.exp(-(en-eo)/RT)*\ self._p_attempt(closest_pose_n,closest_pose_o)/\ self._p_attempt(closest_pose_o,dart_towards)): if en>(1000): print 'eo: %f, en: %f'%(eo,en) print 'closest_pose_o %d, closest_pose_n %d'%(\ closest_pose_o,closest_pose_n) print '_p_attempt, forward %f, backwards %f'%(\ self._p_attempt(closest_pose_o,dart_towards), \ self._p_attempt(closest_pose_n,closest_pose_o)) raise Exception('High energy pose!') xo_Cartesian = xn_Cartesian xo_BAT = xn_BAT eo = en closest_pose_o = closest_pose_n acc += 1 else: self.universe.setConfiguration(xo_Cartesian) return ([np.copy(xo_Cartesian)], [en], float(acc)/float(ntrials), 0.0)
def __init__(self, universe=None, temperature=300. * Units.K, subspace=None, delta=None, sparse=False): """ :param universe: the system for which the normal modes are calculated; it must have a force field which provides the second derivatives of the potential energy :type universe: :class:~MMTK.Universe.Universe :param temperature: the temperature for which the amplitudes of the atomic displacement vectors are calculated. A value of None can be specified to have no scaling at all. In that case the mass-weighted norm of each normal mode is one. :type temperature: float :param subspace: the basis for the subspace in which the normal modes are calculated (or, more precisely, a set of vectors spanning the subspace; it does not have to be orthogonal). This can either be a sequence of :class:~MMTK.ParticleProperties.ParticleVector objects or a tuple of two such sequences. In the second case, the subspace is defined by the space spanned by the second set of vectors projected on the complement of the space spanned by the first set of vectors. The first set thus defines directions that are excluded from the subspace. The default value of None indicates a standard normal mode calculation in the 3N-dimensional configuration space. :param delta: the rms step length for numerical differentiation. The default value of None indicates analytical differentiation. Numerical differentiation is available only when a subspace basis is used as well. Instead of calculating the full force constant matrix and then multiplying with the subspace basis, the subspace force constant matrix is obtained by numerical differentiation of the energy gradients along the basis vectors of the subspace. If the basis is much smaller than the full configuration space, this approach needs much less memory. :type delta: float :param sparse: a flag that indicates if a sparse representation of the force constant matrix is to be used. This is of interest when there are no long-range interactions and a subspace of smaller size then 3N is specified. In that case, the calculation will use much less memory with a sparse representation. :type sparse: bool """ if universe == None: return Features.checkFeatures(self, universe) Core.NormalModes.__init__( self, universe, subspace, delta, sparse, ['array', 'imaginary', 'frequencies', 'omega_sq']) self.temperature = temperature self.weights = N.sqrt(self.universe.masses().array) self.weights = self.weights[:, N.NewAxis] self._forceConstantMatrix() ev = self._diagonalize() self.imaginary = N.less(ev, 0.) self.omega_sq = ev self.frequencies = N.sqrt(N.fabs(ev)) / (2. * N.pi) self.sort_index = N.argsort(self.frequencies) self.array.shape = (self.nmodes, self.natoms, 3) self.cleanup()
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) random.seed(self.getOption('seed')) np.random.seed(self.getOption('seed')) memid = np.random.randint(2000,9999) np.random.seed(int(time.time() + os.getpid())) Random.initializeRandomNumbersFromTime() # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R*self.getOption('T') delta_t = self.getOption('delta_t') server = self.getOption('server') ligand_dir = self.getOption('ligand_dir') dyn_type = self.getOption('dyn_type') server_cmd = '' server_cmd = server + ' -mol2 ' + ligand_dir + 'ligand.mol2' + ' -rb ' + ligand_dir + 'ligand.rb' + ' -gaff gaff.dat -frcmod ' + ligand_dir + 'ligand.frcmod -ictd ' + dyn_type + ' -memid ' + str(memid) + ' > tdout' #print server_cmd tdserver = subprocess.Popen(server_cmd, shell=True, preexec_fn=os.setsid) sleep(0.1) if 'steps_per_trial' in self.call_options.keys(): steps_per_trial = self.getOption('steps_per_trial') ntrials = self.getOption('steps')/steps_per_trial else: steps_per_trial = self.getOption('steps') ntrials = 1 if 'normalize' in self.call_options.keys(): normalize = self.getOption('normalize') else: normalize = False # Get the universe variables needed by the integrator masses = self.universe.masses() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') comm = self.getOption('mpi_communicator') evaluator = self.universe.energyEvaluator(threads=nt, mpi_communicator=comm) evaluator = evaluator.CEvaluator() # Deal with reordering #print "objectList = ", self.universe.objectList() #print "objectList prmtop_order = ", self.universe.objectList()[0].prmtop_order #print "atomList = ", self.universe.objectList()[0].atomList() names = [] order = [] for a in self.universe.objectList()[0].atomList(): names.append(a.name) for i in self.universe.objectList()[0].prmtop_order: order.append(i.number) #print "names = ", names #print "order = ", order descorder = list('') for o in order: descorder = descorder + list(str(o)) descorder = descorder + list('|') descorder = descorder + list('1') descorder = descorder + list('|') descorder = descorder + list(str(memid)) descorder = descorder + list('|') #print descorder #print 'Py T ', self.getOption('T'), ' dt ', delta_t, ' trls ', ntrials, 'stps/trl ', steps_per_trial xs = [] energies = [] k = 0 acc = 0 for t in range(ntrials): # Initialize the velocity self.universe.initializeVelocitiesToTemperature(self.getOption('T')) #print "Python vels= ", #for t in self.universe.velocities(): print t, #print # Store previous configuration and initial energy xo = self.universe.copyConfiguration() pe_o = self.universe.energy() eo = pe_o + self.universe.kineticEnergy() ke_o = self.universe.kineticEnergy() # Run the velocity verlet integrator late_args = ( masses.array, fixed.array, evaluator, N.zeros((0, 2), N.Int), N.zeros((0, ), N.Float), N.zeros((1,), N.Int), N.zeros((0,), N.Float), N.zeros((2,), N.Float), N.zeros((0,), N.Float), N.zeros((1,), N.Float), delta_t, self.getOption('first_step'), steps_per_trial, self.getActions(), ''.join(descorder)) #self.run(bTD_dynamics.integrateRKM_SPLIT, #tdserver = subprocess.Popen(server_cmd, shell=True, preexec_fn=os.setsid) #sleep(0.1) self.run(bTD_dynamics.integrateRKM_INTER3, (self.universe, self.universe.configuration().array, self.universe.velocities().array) + late_args) # Decide whether to accept the move pe_n = self.universe.energy() ke_n = self.universe.kineticEnergy() en = pe_n + ke_n random_number = np.random.random() expression = np.exp(-(en-eo)/RT) #expression = np.exp(-(pe_n-pe_o)/RT) #print ' stps Py PEo ', pe_o, ' KEo ', ke_o, ' Eo ', eo, ' PEn ', pe_n, ' KEn ', ke_n, ' En ', en, ' rand ', random_number, ' exp ', expression if (((en<eo) or (random_number<expression)) and (not np.isnan(en))): #if ((pe_n<pe_o) or (random_number<expression)): #or (t==0): # Always acc 1st step for now acc += 1 #print 'Py MC acc' if normalize: self.universe.normalizeConfiguration() descorder[-7] = '1' else: #print 'Py MC nacc' self.universe.setConfiguration(xo) pe_n = pe_o descorder[-7] = '0' xs.append(self.universe.copyConfiguration().array) energies.append(pe_n) # Kill the server tdserver.terminate() os.killpg(tdserver.pid, signal.SIGTERM) # Send the signal to all the process groups os.system('ipcrm -M ' + str(memid)) # Free shared memory #Return return (xs, energies, float(acc)/float(ntrials), delta_t)
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R*self.getOption('T') delta_t = self.getOption('delta_t') if 'steps_per_trial' in self.call_options.keys(): steps_per_trial = self.getOption('steps_per_trial') ntrials = self.getOption('steps')/steps_per_trial else: steps_per_trial = self.getOption('steps') ntrials = 1 if 'normalize' in self.call_options.keys(): normalize = self.getOption('normalize') else: normalize = False # Seed the random number generator if 'random_seed' in self.call_options.keys(): np.random.seed(self.getOption('random_seed')) # Get the universe variables needed by the integrator masses = self.universe.masses() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') comm = self.getOption('mpi_communicator') evaluator = self.universe.energyEvaluator(threads=nt, mpi_communicator=comm) evaluator = evaluator.CEvaluator() late_args = ( masses.array, fixed.array, evaluator, N.zeros((0, 2), N.Int), N.zeros((0, ), N.Float), N.zeros((1,), N.Int), N.zeros((0,), N.Float), N.zeros((2,), N.Float), N.zeros((0,), N.Float), N.zeros((1,), N.Float), delta_t, self.getOption('first_step'), steps_per_trial, self.getActions(), 'Velocity Verlet step') xs = [] energies = [] # Store initial configuration and potential energy xo = np.copy(self.universe.configuration().array) pe_o = self.universe.energy() acc = 0 for t in range(ntrials): # Initialize the velocity self.universe.initializeVelocitiesToTemperature(self.getOption('T')) # Store total energy eo = pe_o + self.universe.kineticEnergy() # Run the velocity verlet integrator self.run(MMTK_dynamics.integrateVV, (self.universe, self.universe.configuration().array, self.universe.velocities().array) + late_args) # Decide whether to accept the move pe_n = self.universe.energy() en = pe_n + self.universe.kineticEnergy() if not np.isnan(en): xo = np.copy(self.universe.configuration().array) pe_o = pe_n acc += 1 if normalize: self.universe.normalizePosition() else: self.universe.setConfiguration(Configuration(self.universe,xo)) xs.append(np.copy(self.universe.configuration().array)) energies.append(pe_o) return (xs, energies, acc, ntrials, delta_t)
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R*self.getOption('T') delta_t = self.getOption('delta_t') if 'steps_per_trial' in self.call_options.keys(): steps_per_trial = self.getOption('steps_per_trial') ntrials = self.getOption('steps')/steps_per_trial else: steps_per_trial = self.getOption('steps') ntrials = 1 if 'normalize' in self.call_options.keys(): normalize = self.getOption('normalize') else: normalize = False # Seed the random number generator if 'random_seed' in self.call_options.keys(): np.random.seed(self.getOption('random_seed')) self.universe.initializeVelocitiesToTemperature(self.getOption('T')) # Get the universe variables needed by the integrator masses = self.universe.masses() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') comm = self.getOption('mpi_communicator') evaluator = self.universe.energyEvaluator(threads=nt, mpi_communicator=comm) evaluator = evaluator.CEvaluator() late_args = ( masses.array, fixed.array, evaluator, N.zeros((0, 2), N.Int), N.zeros((0, ), N.Float), N.zeros((1,), N.Int), N.zeros((0,), N.Float), N.zeros((2,), N.Float), N.zeros((0,), N.Float), N.zeros((1,), N.Float), delta_t, self.getOption('first_step'), steps_per_trial, self.getActions(), 'Hamiltonian Monte Carlo step') # Variables for velocity assignment m3 = np.repeat(np.expand_dims(masses.array,1),3,axis=1) sigma_MB = np.sqrt((self.getOption('T')*Units.k_B)/m3) natoms = self.universe.numberOfAtoms() xs = [] energies = [] # Store initial configuration and potential energy xo = np.copy(self.universe.configuration().array) pe_o = self.universe.energy() acc = 0 for t in range(ntrials): # Initialize the velocity v = self.universe.velocities() v.array = np.multiply(sigma_MB,np.random.randn(natoms,3)) # Store total energy eo = pe_o + 0.5*np.sum(np.multiply(m3,np.square(v.array))) # Run the velocity verlet integrator self.run(MMTK_dynamics.integrateVV, (self.universe, self.universe.configuration().array, self.universe.velocities().array) + late_args) # Decide whether to accept the move pe_n = self.universe.energy() en = pe_n + 0.5*np.sum(np.multiply(m3,np.square(v.array))) if ((en<eo) or (np.random.random()<N.exp(-(en-eo)/RT))) and \ ((abs(pe_o-pe_n)/RT<250.) or (abs(eo-en)/RT<250.)): xo = np.copy(self.universe.configuration().array) pe_o = pe_n acc += 1 if normalize: self.universe.normalizePosition() else: self.universe.setConfiguration(Configuration(self.universe,xo)) xs.append(np.copy(self.universe.configuration().array)) energies.append(pe_o) return (xs, energies, acc, ntrials, delta_t)
def __call__(self, **options): """ options include: steps, steps_per_trial, T, delta_t, random_seed, normalize=False, adapt=False """ # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) # Required arguments steps = self.getOption('steps') delta_t = self.getOption('delta_t') T = self.getOption('T') RT = R*T # Arguments with default values try: steps_per_cycle = self.getOption('steps_per_trial') ncycles = steps/steps_per_cycle except ValueError: steps_per_cycle = steps ncycles = 1 try: fraction_CD = self.getOption('fraction_CD') except ValueError: fraction_CD = 0.5 try: CD_steps_per_trial = self.getOption('CD_steps_per_trial') except ValueError: CD_steps_per_trial = 5 try: delta_t_TD = self.getOption('delta_t_TD') except ValueError: delta_t_TD = 4.0 # Allocate steps per cycle to TD and MD CD_steps_per_cycle = int(fraction_CD*steps_per_cycle) MD_steps_per_cycle = steps_per_cycle - CD_steps_per_cycle*CD_steps_per_trial if 'random_seed' in self.call_options.keys(): random_seed = self.getOption('random_seed') np.random.seed(random_seed) else: import time random_seed = np.int(time.time()*1E3 + rand.rand()*1E3) if 'normalize' in self.call_options.keys(): normalize = self.getOption('normalize') else: normalize = False if self.universe.velocities() is None: self.universe.initializeVelocitiesToTemperature(T) # Get the universe variables needed by the integrator masses = self.universe.masses() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') comm = self.getOption('mpi_communicator') evaluator = self.universe.energyEvaluator(threads=nt, mpi_communicator=comm) evaluator = evaluator.CEvaluator() late_args = ( masses.array, fixed.array, evaluator, N.zeros((0, 2), N.Int), N.zeros((0, ), N.Float), N.zeros((1,), N.Int), N.zeros((0,), N.Float), N.zeros((2,), N.Float), N.zeros((0,), N.Float), N.zeros((1,), N.Float), delta_t, self.getOption('first_step'), MD_steps_per_cycle, self.getActions(), 'Mixed Hamiltonian Monte Carlo step') # Variables for velocity assignment m3 = np.repeat(np.expand_dims(masses.array,1),3,axis=1) sigma_MB = np.sqrt((self.getOption('T')*Units.k_B)/m3) natoms = self.universe.numberOfAtoms() xs = [] energies = [] CD_acc = 0 CD_ntrials = 0 MD_acc = 0 for t in range(ncycles): # Do the constrained dynamics steps (CD_xs_c, CD_energies_c, CD_acc_c, CD_ntrials_c, CD_dts) = \ self.TDintegrator.Call(CD_steps_per_cycle, CD_steps_per_trial, \ T, delta_t_TD/1000., (random_seed+t)%32767, 1, 1, 0.5) xs.extend(CD_xs_c) energies.extend(CD_energies_c) CD_acc += CD_acc_c CD_ntrials += CD_ntrials_c # Store initial configuration and potential energy xo = np.copy(self.universe.configuration().array) pe_o = self.universe.energy() # Initialize the velocity v = self.universe.velocities() v.array = np.multiply(sigma_MB,np.random.randn(natoms,3)) # Store total energy eo = pe_o + 0.5*np.sum(np.multiply(m3,np.square(v.array))) # Run the velocity verlet integrator self.run(MMTK_dynamics.integrateVV, (self.universe, self.universe.configuration().array, self.universe.velocities().array) + late_args) # Decide whether to accept the move pe_n = self.universe.energy() en = pe_n + 0.5*np.sum(np.multiply(m3,np.square(v.array))) if ((en<eo) or (np.random.random()<N.exp(-(en-eo)/RT))) and \ ((abs(pe_o-pe_n)/RT<250.) or (abs(eo-en)/RT<250.)): xo = np.copy(self.universe.configuration().array) pe_o = pe_n MD_acc += 1 if normalize: self.universe.normalizePosition() else: self.universe.setConfiguration(Configuration(self.universe,xo)) xs.append(np.copy(self.universe.configuration().array)) energies.append(pe_o) # print 'TD: %d/%d, MD: %d/%d'%(CD_acc,CD_ntrials,MD_acc,ncycles) return (xs, energies, CD_acc + MD_acc, CD_ntrials + ncycles, delta_t)
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) #the following two lines are required due to MMTK mixing up atom indices. This sorts them. #atoms = self.universe.atomList() #atoms.sort(key=operator.attrgetter('index')) # Get the universe variables needed by the integrator configuration = self.universe.configuration() velocities = self.universe.velocities() if velocities is None: raise ValueError("no velocities") # Get the friction coefficients. First check if a keyword argument # 'friction' was given to the integrator. Its value can be a # ParticleScalar or a plain number (used for all atoms). If no # such argument is given, collect the values of the attribute # 'friction' from all atoms (default is zero). friction = self.getOption('friction') #call this method to create the OpenMM System. Without this, creating #the forces will fail!! self.initOmmSystem() #call this method to ensure that the forcefield parameters get #passed to OpenMM. Without this, there will be no forces to integrate! self.createOmmForces() #The restraint option must be included in the creation of the integrator for this part to be executed try: restraint = self.getOption('restraint') except ValueError: restraint = None print 'No restraints (Value Error)' except: print sys.exc_info()[0] if restraint != None: self.addRestraint(restraint) #ugly hack to get timestep skip information skip = -1 if ('actions' in self.call_options): actions = self.call_options['actions'] for action in actions: if isinstance(action, Dynamics.TranslationRemover): self.addOmmCMRemover(action.skip) if isinstance(action, Trajectory.LogOutput): break # to avoid Logoutput skip setting problem PNR NFF SJC if isinstance(action, Trajectory.TrajectoryOutput): skip = action.skip action.skip = 1 if skip < 0: for action in actions: if issubclass(action.__class__, Trajectory.TrajectoryOutput): skip = action.skip action.skip = 1 break #we are not logging anything, so we don't have to report any intermediate values if skip < 0: skip = 100 steps = 1 # Run the C integrator atoms = self.universe.atomList() masses = [atom.mass() for atom in atoms] natoms = len(atoms) nmolecules = len(self.universe.objectList(Molecule)) molecule_lengths = N.zeros(nmolecules, dtype=N.int32, order='C') for i in range(0, len(self.universe.objectList(Molecule))): molecule_lengths[i] = len( self.universe.objectList(Molecule)[i].atomList()) MMTK_langevin.integrateLD(self.universe, configuration.array, velocities.array, N.array(masses, dtype=N.float64), friction, self.getOption('temperature'), self.getOption('delta_t'), self.getOption('steps'), skip, natoms, self.nbeads, nmolecules, molecule_lengths, self.getActions()) #call this to clean up after ourselves self.destroyOmmSystem()
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) #the following two lines are required due to MMTK mixing up atom indices. This sorts them. #atoms = self.universe.atomList() #atoms.sort(key=operator.attrgetter('index')) # Get the universe variables needed by the integrator configuration = self.universe.configuration() velocities = self.universe.velocities() if velocities is None: raise ValueError("no velocities") # Get the friction coefficients. First check if a keyword argument # 'friction' was given to the integrator. Its value can be a # ParticleScalar or a plain number (used for all atoms). If no # such argument is given, collect the values of the attribute # 'friction' from all atoms (default is zero). friction = self.getOption('friction') #call this method to create the OpenMM System. Without this, creating #the forces will fail!! self.initOmmSystem() #call this method to ensure that the forcefield parameters get #passed to OpenMM. Without this, there will be no forces to integrate! self.createOmmForces() #The restraint option must be included in the creation of the integrator for this part to be executed try: restraint = self.getOption('restraint') except ValueError: restraint = None print 'No restraints (Value Error)' except: print sys.exc_info()[0] if restraint != None: self.addRestraint(restraint) #ugly hack to get timestep skip information skip = -1 if ('actions' in self.call_options): actions = self.call_options['actions'] for action in actions: if isinstance(action, Dynamics.TranslationRemover): self.addOmmCMRemover(action.skip) if isinstance(action, Trajectory.LogOutput): break # to avoid Logoutput skip setting problem PNR NFF SJC if isinstance(action, Trajectory.TrajectoryOutput): skip = action.skip action.skip = 1 if skip < 0 : for action in actions: if issubclass(action.__class__, Trajectory.TrajectoryOutput): skip = action.skip action.skip = 1 break #we are not logging anything, so we don't have to report any intermediate values if skip < 0: skip = 100 steps = 1 # Run the C integrator atoms = self.universe.atomList() masses = [atom.mass() for atom in atoms] natoms = len(atoms) nmolecules = len(self.universe.objectList(Molecule)) molecule_lengths = N.zeros(nmolecules, dtype=N.int32, order='C') for i in range(0,len(self.universe.objectList(Molecule))): molecule_lengths[i] = len(self.universe.objectList(Molecule)[i].atomList()) MMTK_langevin.integrateLD(self.universe, configuration.array, velocities.array, N.array(masses, dtype=N.float64), friction, self.getOption('temperature'), self.getOption('delta_t'), self.getOption('steps'), skip, natoms, self.nbeads, nmolecules, molecule_lengths, self.getActions()) #call this to clean up after ourselves self.destroyOmmSystem()
def __call__(self, **options): if (self.confs is None) or len(self.confs) < 2: return ([self.universe.configuration().array], [self.universe.energy()], \ 0, 0, 0.0) # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R * self.getOption('T') ntrials = min(self.getOption('ntrials'), len(self.confs)) # Seed the random number generator if 'random_seed' in self.call_options.keys(): np.random.seed(self.getOption('random_seed')) acc = 0. energies = [] closest_poses = [] xo_Cartesian = np.copy(self.universe.configuration().array) if self.extended: (closest_pose_o, distance_o) = self._closest_pose_Cartesian(\ xo_Cartesian[self.molecule.heavy_atoms,:]) else: xo_BAT = self._BAT_util.BAT(xo_Cartesian, extended=self.extended) (closest_pose_o, distance_o) = self._closest_pose_BAT(xo_BAT[self._BAT_to_perturb]) # Only attempt smart darting within # a sphere of radius epsilon of the minimum if distance_o > self.epsilon: return ([self.universe.configuration().array], [self.universe.energy()], \ 0, 0, 0.0) if self.extended: xo_BAT = self._BAT_util.BAT(xo_Cartesian, extended=self.extended) eo = self.universe.energy() # report = '' for t in range(ntrials): # Choose a pose to dart towards dart_towards = closest_pose_o while dart_towards == closest_pose_o: dart_towards = np.random.choice(len(self.weights), p=self.weights) # Generate a trial move xn_BAT = np.copy(xo_BAT) xn_BAT[self._BAT_to_perturb] = xo_BAT[ self. _BAT_to_perturb] + self.darts[closest_pose_o][dart_towards] # Check that the trial move is closest to dart_towards if self.extended: xn_Cartesian = self._BAT_util.Cartesian(xn_BAT) (closest_pose_n, distance_n) = self._closest_pose_Cartesian(\ xn_Cartesian[self.molecule.heavy_atoms,:]) if (closest_pose_n != dart_towards): print ' attempted dart from pose %d (%f) to pose %d'%(\ closest_pose_o,distance_o,dart_towards) + \ ' landed near pose %d (%f)!'%(closest_pose_n, distance_n) continue else: (closest_pose_n, distance_n) = self._closest_pose_BAT(\ xn_BAT[self._BAT_to_perturb]) if (closest_pose_n != dart_towards): print ' attempted dart from pose %d (%f) to pose %d'%(\ closest_pose_o,distance_o,dart_towards) + \ ' landed near pose %d (%f)!'%(closest_pose_n, distance_n) continue xn_Cartesian = self._BAT_util.Cartesian(xn_BAT) # Determine energy of new state self.universe.setConfiguration( Configuration(self.universe, xn_Cartesian)) en = self.universe.energy() # report += 'Attempting move from near pose %d with energy %f to pose %d with energy %f. '%(closest_pose_o,eo,closest_pose_n,en) # Accept or reject the trial move if (abs(en-eo)<1000) and \ ((en<eo) or (np.random.random()<np.exp(-(en-eo)/RT)*\ self._p_attempt(closest_pose_n,closest_pose_o)/\ self._p_attempt(closest_pose_o,closest_pose_n))): xo_Cartesian = xn_Cartesian xo_BAT = xn_BAT eo = 1. * en closest_pose_o = closest_pose_n distance_o = distance_n acc += 1 # report += 'Accepted.\n' # else: # report += 'Rejected.\n' # # print report self.universe.setConfiguration( Configuration(self.universe, xo_Cartesian)) return ([np.copy(xo_Cartesian)], [eo], acc, ntrials, 0.0)
def __init__(self, universe = None, friction = None, temperature = 300.*Units.K, subspace = None, delta = None, sparse = False): """ :param universe: the system for which the normal modes are calculated; it must have a force field which provides the second derivatives of the potential energy :type universe: :class:`~MMTK.Universe.Universe` :param friction: the friction coefficient for each particle. Note: The friction coefficients are not mass-weighted, i.e. they have the dimension of an inverse time. :type friction: :class:`~MMTK.ParticleProperties.ParticleScalar` :param temperature: the temperature for which the amplitudes of the atomic displacement vectors are calculated. A value of None can be specified to have no scaling at all. In that case the mass-weighted norm of each normal mode is one. :type temperature: float :param subspace: the basis for the subspace in which the normal modes are calculated (or, more precisely, a set of vectors spanning the subspace; it does not have to be orthogonal). This can either be a sequence of :class:`~MMTK.ParticleProperties.ParticleVector` objects or a tuple of two such sequences. In the second case, the subspace is defined by the space spanned by the second set of vectors projected on the complement of the space spanned by the first set of vectors. The first set thus defines directions that are excluded from the subspace. The default value of None indicates a standard normal mode calculation in the 3N-dimensional configuration space. :param delta: the rms step length for numerical differentiation. The default value of None indicates analytical differentiation. Numerical differentiation is available only when a subspace basis is used as well. Instead of calculating the full force constant matrix and then multiplying with the subspace basis, the subspace force constant matrix is obtained by numerical differentiation of the energy gradients along the basis vectors of the subspace. If the basis is much smaller than the full configuration space, this approach needs much less memory. :type delta: float :param sparse: a flag that indicates if a sparse representation of the force constant matrix is to be used. This is of interest when there are no long-range interactions and a subspace of smaller size then 3N is specified. In that case, the calculation will use much less memory with a sparse representation. :type sparse: bool """ if universe == None: return Features.checkFeatures(self, universe) Core.NormalModes.__init__(self, universe, subspace, delta, sparse, ['array', 'inv_relaxation_times']) self.friction = friction self.temperature = temperature self.weights = N.sqrt(friction.array) self.weights = self.weights[:, N.NewAxis] self._forceConstantMatrix() ev = self._diagonalize() self.inv_relaxation_times = ev self.sort_index = N.argsort(self.inv_relaxation_times) self.array.shape = (self.nmodes, self.natoms, 3) self.cleanup()
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R*self.getOption('T') delta_t = self.getOption('delta_t') if 'steps_per_trial' in self.call_options.keys(): steps_per_trial = self.getOption('steps_per_trial') ntrials = self.getOption('steps')/steps_per_trial else: steps_per_trial = self.getOption('steps') ntrials = 1 if 'normalize' in self.call_options.keys(): normalize = self.getOption('normalize') else: normalize = False # Seed the random number generator if 'random_seed' in self.call_options.keys(): np.random.seed(self.getOption('random_seed')) self.universe.initializeVelocitiesToTemperature(self.getOption('T')) # Get the universe variables needed by the integrator masses = self.universe.masses() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') comm = self.getOption('mpi_communicator') evaluator = self.universe.energyEvaluator(threads=nt, mpi_communicator=comm) evaluator = evaluator.CEvaluator() late_args = ( masses.array, fixed.array, evaluator, N.zeros((0, 2), N.Int), N.zeros((0, ), N.Float), N.zeros((1,), N.Int), N.zeros((0,), N.Float), N.zeros((2,), N.Float), N.zeros((0,), N.Float), N.zeros((1,), N.Float), delta_t, self.getOption('first_step'), steps_per_trial, self.getActions(), 'Hamiltonian Monte Carlo step') # Variables for velocity assignment m3 = np.repeat(np.expand_dims(masses.array,1),3,axis=1) sigma_MB = np.sqrt((self.getOption('T')*Units.k_B)/m3) natoms = self.universe.numberOfAtoms() xs = [] energies = [] # Store initial configuration and potential energy xo = np.copy(self.universe.configuration().array) self.sampling_universe.configuration().array[-natoms:,:] = xo pe_o = self.sampling_universe.energy() # <- Using sampling Hamiltonian # rather than guidance Hamiltonian acc = 0 for t in range(ntrials): # Initialize the velocity v = self.universe.velocities() v.array = np.multiply(sigma_MB,np.random.randn(natoms,3)) # Store total energy eo = pe_o + 0.5*np.sum(np.multiply(m3,np.square(v.array))) # Run the velocity verlet integrator self.run(MMTK_dynamics.integrateVV, (self.universe, self.universe.configuration().array, self.universe.velocities().array) + late_args) # Decide whether to accept the move self.sampling_universe.configuration().array[-natoms:,:] = \ self.universe.configuration().array pe_n = self.sampling_universe.energy() # <- Using sampling Hamiltonian # rather than guidance Hamiltonian en = pe_n + 0.5*np.sum(np.multiply(m3,np.square(v.array))) # TODO: Confirm acceptance criterion if ((en<eo) or (np.random.random()<N.exp(-(en-eo)/RT))) and \ ((abs(pe_o-pe_n)/RT<250.) or (abs(eo-en)/RT<250.)): xo = np.copy(self.universe.configuration().array) pe_o = pe_n acc += 1 if normalize: self.universe.normalizePosition() else: self.universe.setConfiguration(Configuration(self.universe,xo)) xs.append(np.copy(self.universe.configuration().array)) energies.append(pe_o) return (xs, energies, acc, ntrials, delta_t)
def __call__(self, **options): if (self.confs is None) or len(self.confs)<2: return ([self.universe.configuration().array], [self.universe.energy()], \ 0, 0, 0.0) # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R*self.getOption('T') ntrials = min(self.getOption('ntrials'), len(self.confs)) # Seed the random number generator if 'random_seed' in self.call_options.keys(): np.random.seed(self.getOption('random_seed')) acc = 0. energies = [] closest_poses = [] xo_Cartesian = np.copy(self.universe.configuration().array) if self.extended: (closest_pose_o, distance_o) = self._closest_pose_Cartesian(\ xo_Cartesian[self.molecule.heavy_atoms,:]) else: xo_BAT = self._BAT_util.BAT(xo_Cartesian, extended=self.extended) (closest_pose_o, distance_o) = self._closest_pose_BAT(xo_BAT[self._BAT_to_perturb]) # Only attempt smart darting within # a sphere of radius epsilon of the minimum if distance_o > self.epsilon: return ([self.universe.configuration().array], [self.universe.energy()], \ 0, 0, 0.0) if self.extended: xo_BAT = self._BAT_util.BAT(xo_Cartesian, extended=self.extended) eo = self.universe.energy() # report = '' for t in range(ntrials): # Choose a pose to dart towards dart_towards = closest_pose_o while dart_towards==closest_pose_o: dart_towards = np.random.choice(len(self.weights), p=self.weights) # Generate a trial move xn_BAT = np.copy(xo_BAT) xn_BAT[self._BAT_to_perturb] = xo_BAT[self._BAT_to_perturb] + self.darts[closest_pose_o][dart_towards] # Check that the trial move is closest to dart_towards if self.extended: xn_Cartesian = self._BAT_util.Cartesian(xn_BAT) (closest_pose_n, distance_n) = self._closest_pose_Cartesian(\ xn_Cartesian[self.molecule.heavy_atoms,:]) if (closest_pose_n!=dart_towards): print ' attempted dart from pose %d (%f) to pose %d'%(\ closest_pose_o,distance_o,dart_towards) + \ ' landed near pose %d (%f)!'%(closest_pose_n, distance_n) continue else: (closest_pose_n, distance_n) = self._closest_pose_BAT(\ xn_BAT[self._BAT_to_perturb]) if (closest_pose_n!=dart_towards): print ' attempted dart from pose %d (%f) to pose %d'%(\ closest_pose_o,distance_o,dart_towards) + \ ' landed near pose %d (%f)!'%(closest_pose_n, distance_n) continue xn_Cartesian = self._BAT_util.Cartesian(xn_BAT) # Determine energy of new state self.universe.setConfiguration(Configuration(self.universe, xn_Cartesian)) en = self.universe.energy() # report += 'Attempting move from near pose %d with energy %f to pose %d with energy %f. '%(closest_pose_o,eo,closest_pose_n,en) # Accept or reject the trial move if (abs(en-eo)<1000) and \ ((en<eo) or (np.random.random()<np.exp(-(en-eo)/RT)*\ self._p_attempt(closest_pose_n,closest_pose_o)/\ self._p_attempt(closest_pose_o,closest_pose_n))): xo_Cartesian = xn_Cartesian xo_BAT = xn_BAT eo = 1.*en closest_pose_o = closest_pose_n distance_o = distance_n acc += 1 # report += 'Accepted.\n' # else: # report += 'Rejected.\n' # # print report self.universe.setConfiguration(Configuration(self.universe, xo_Cartesian)) return ([np.copy(xo_Cartesian)], [eo], acc, ntrials, 0.0)
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R * self.getOption('T') delta_t = self.getOption('delta_t') if 'steps_per_trial' in self.call_options.keys(): steps_per_trial = self.getOption('steps_per_trial') ntrials = self.getOption('steps') / steps_per_trial else: steps_per_trial = self.getOption('steps') ntrials = 1 if 'max_diff' in self.call_options.keys(): max_diff = self.getOption('max_diff') else: max_diff = 1000. if 'normalize' in self.call_options.keys(): normalize = self.getOption('normalize') else: normalize = False # Seed the random number generator if 'random_seed' in self.call_options.keys(): np.random.seed(self.getOption('random_seed')) # Get the universe variables needed by the integrator masses = self.universe.masses() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') comm = self.getOption('mpi_communicator') evaluator = self.universe.energyEvaluator(threads=nt, mpi_communicator=comm) evaluator = evaluator.CEvaluator() late_args = (masses.array, fixed.array, evaluator, N.zeros((0, 2), N.Int), N.zeros( (0, ), N.Float), N.zeros((1, ), N.Int), N.zeros((0, ), N.Float), N.zeros( (2, ), N.Float), N.zeros( (0, ), N.Float), N.zeros((1, ), N.Float), delta_t, self.getOption('first_step'), steps_per_trial, self.getActions(), 'Velocity Verlet step') xs = [] energies = [] # Store initial configuration and potential energy xo = np.copy(self.universe.configuration().array) pe_o = self.universe.energy() acc = 0 for t in range(ntrials): # Initialize the velocity self.universe.initializeVelocitiesToTemperature( self.getOption('T')) # Store total energy eo = pe_o + self.universe.kineticEnergy() # Run the velocity verlet integrator self.run(MMTK_dynamics.integrateVV, (self.universe, self.universe.configuration().array, self.universe.velocities().array) + late_args) # Decide whether to accept the move pe_n = self.universe.energy() en = pe_n + self.universe.kineticEnergy() diff = np.abs(en - eo) if (not np.isnan(en)) and (diff < max_diff): xo = np.copy(self.universe.configuration().array) pe_o = pe_n acc += 1 if normalize: self.universe.normalizePosition() else: # print diff self.universe.setConfiguration(Configuration( self.universe, xo)) xs.append(np.copy(self.universe.configuration().array)) energies.append(pe_o) return (xs, energies, acc, ntrials, delta_t)
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) random.seed(self.getOption('seed')) np.random.seed(self.getOption('seed')) memid = np.random.randint(2000, 9999) np.random.seed(int(time.time() + os.getpid())) Random.initializeRandomNumbersFromTime() # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R * self.getOption('T') delta_t = self.getOption('delta_t') server = self.getOption('server') ligand_dir = self.getOption('ligand_dir') dyn_type = self.getOption('dyn_type') server_cmd = '' server_cmd = server + ' -mol2 ' + ligand_dir + 'ligand.mol2' + ' -rb ' + ligand_dir + 'ligand.rb' + ' -gaff gaff.dat -frcmod ' + ligand_dir + 'ligand.frcmod -ictd ' + dyn_type + ' -memid ' + str( memid) + ' > tdout' #print server_cmd tdserver = subprocess.Popen(server_cmd, shell=True, preexec_fn=os.setsid) sleep(0.1) if 'steps_per_trial' in self.call_options.keys(): steps_per_trial = self.getOption('steps_per_trial') ntrials = self.getOption('steps') / steps_per_trial else: steps_per_trial = self.getOption('steps') ntrials = 1 if 'normalize' in self.call_options.keys(): normalize = self.getOption('normalize') else: normalize = False # Get the universe variables needed by the integrator masses = self.universe.masses() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') comm = self.getOption('mpi_communicator') evaluator = self.universe.energyEvaluator(threads=nt, mpi_communicator=comm) evaluator = evaluator.CEvaluator() # Deal with reordering #print "objectList = ", self.universe.objectList() #print "objectList prmtop_order = ", self.universe.objectList()[0].prmtop_order #print "atomList = ", self.universe.objectList()[0].atomList() names = [] order = [] for a in self.universe.objectList()[0].atomList(): names.append(a.name) for i in self.universe.objectList()[0].prmtop_order: order.append(i.number) #print "names = ", names #print "order = ", order descorder = list('') for o in order: descorder = descorder + list(str(o)) descorder = descorder + list('|') descorder = descorder + list('1') descorder = descorder + list('|') descorder = descorder + list(str(memid)) descorder = descorder + list('|') #print descorder #print 'Py T ', self.getOption('T'), ' dt ', delta_t, ' trls ', ntrials, 'stps/trl ', steps_per_trial xs = [] energies = [] k = 0 acc = 0 for t in range(ntrials): # Initialize the velocity self.universe.initializeVelocitiesToTemperature( self.getOption('T')) #print "Python vels= ", #for t in self.universe.velocities(): print t, #print # Store previous configuration and initial energy xo = self.universe.copyConfiguration() pe_o = self.universe.energy() eo = pe_o + self.universe.kineticEnergy() ke_o = self.universe.kineticEnergy() # Run the velocity verlet integrator late_args = (masses.array, fixed.array, evaluator, N.zeros((0, 2), N.Int), N.zeros( (0, ), N.Float), N.zeros( (1, ), N.Int), N.zeros((0, ), N.Float), N.zeros((2, ), N.Float), N.zeros( (0, ), N.Float), N.zeros((1, ), N.Float), delta_t, self.getOption('first_step'), steps_per_trial, self.getActions(), ''.join(descorder)) #self.run(bTD_dynamics.integrateRKM_SPLIT, #tdserver = subprocess.Popen(server_cmd, shell=True, preexec_fn=os.setsid) #sleep(0.1) self.run(bTD_dynamics.integrateRKM_INTER3, (self.universe, self.universe.configuration().array, self.universe.velocities().array) + late_args) # Decide whether to accept the move pe_n = self.universe.energy() ke_n = self.universe.kineticEnergy() en = pe_n + ke_n random_number = np.random.random() expression = np.exp(-(en - eo) / RT) #expression = np.exp(-(pe_n-pe_o)/RT) #print ' stps Py PEo ', pe_o, ' KEo ', ke_o, ' Eo ', eo, ' PEn ', pe_n, ' KEn ', ke_n, ' En ', en, ' rand ', random_number, ' exp ', expression if (((en < eo) or (random_number < expression)) and (not np.isnan(en))): #if ((pe_n<pe_o) or (random_number<expression)): #or (t==0): # Always acc 1st step for now acc += 1 #print 'Py MC acc' if normalize: self.universe.normalizeConfiguration() descorder[-7] = '1' else: #print 'Py MC nacc' self.universe.setConfiguration(xo) pe_n = pe_o descorder[-7] = '0' xs.append(self.universe.copyConfiguration().array) energies.append(pe_n) # Kill the server tdserver.terminate() os.killpg(tdserver.pid, signal.SIGTERM) # Send the signal to all the process groups os.system('ipcrm -M ' + str(memid)) # Free shared memory #Return return (xs, energies, float(acc) / float(ntrials), delta_t)
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) RT = R*self.getOption('T') delta_t = self.getOption('delta_t') if 'steps_per_trial' in self.call_options.keys(): steps_per_trial = self.getOption('steps_per_trial') ntrials = self.getOption('steps')/steps_per_trial else: steps_per_trial = self.getOption('steps') ntrials = 1 if 'normalize' in self.call_options.keys(): normalize = self.getOption('normalize') else: normalize = False # Get the universe variables needed by the integrator masses = self.universe.masses() fixed = self.universe.getAtomBooleanArray('fixed') nt = self.getOption('threads') comm = self.getOption('mpi_communicator') evaluator = self.universe.energyEvaluator(threads=nt, mpi_communicator=comm) evaluator = evaluator.CEvaluator() late_args = ( masses.array, fixed.array, evaluator, N.zeros((0, 2), N.Int), N.zeros((0, ), N.Float), N.zeros((1,), N.Int), N.zeros((0,), N.Float), N.zeros((2,), N.Float), N.zeros((0,), N.Float), N.zeros((1,), N.Float), delta_t, self.getOption('first_step'), steps_per_trial, self.getActions(), 'Velocity Verlet step') xs = [] energies = [] acc = 0 for t in range(ntrials): # Initialize the velocity self.universe.initializeVelocitiesToTemperature(self.getOption('T')) # Store previous configuration and initial energy xo = self.universe.copyConfiguration() pe_o = self.universe.energy() eo = pe_o + self.universe.kineticEnergy() # Run the velocity verlet integrator self.run(MMTK_dynamics.integrateVV, (self.universe, self.universe.configuration().array, self.universe.velocities().array) + late_args) # Decide whether to accept the move pe_n = self.universe.energy() en = pe_n + self.universe.kineticEnergy() if not math.isnan(en): acc += 1 if normalize: self.universe.normalizePosition() else: self.universe.setConfiguration(xo) pe_n = pe_o xs.append(self.universe.copyConfiguration().array) energies.append(pe_n) return (xs, energies, float(acc)/float(ntrials), delta_t)