def task_fail(walker): n = walker.state['num'] if n == 1: raise ValueError("No soup for you!!") else: return Walker(WalkerState(**{'num' : n+1}), walker.weight)
def _runtest(self, num_walkers, num_cycles, dimension, debug_prints=False): print("Random walk simulation with: ") print("Dimension =", dimension) print("Probability =", self.probability) print("Number of Walkers", num_walkers) print("Number of Cycles", num_cycles) # set up initial state for walkers positions = np.zeros((1, dimension)) init_state = WalkerState(positions=positions, time=0.0) # create list of init_walkers initial_weight = 1 / num_walkers init_walkers = [] # init_walkers, n_cycles = get_final_state(path, num_walkers) init_walkers = [ Walker(init_state, initial_weight) for i in range(num_walkers) ] # set up raunner for system runner = RandomWalkRunner(dimension=dimension, probability=self.probability) units = dict(UNIT_NAMES) # instantiate a revo unbindingboudaryconditiobs segment_length = 10 # set up the reporter randomwalk_system_top_json = self.generate_topology() hdf5_reporter = WepyHDF5Reporter(self.hdf5_reporter_path, mode='w', save_fields=SAVE_FIELDS, topology=randomwalk_system_top_json, resampler=self.resampler, units=dict(UNITS), n_dims=dimension) # running the simulation sim_manager = Manager(init_walkers, runner=runner, resampler=self.resampler, work_mapper=Mapper(), reporters=[hdf5_reporter]) # run a simulation with the manager for n_steps cycles of length 1000 each steps = [segment_length for i in range(num_cycles)] print("Start simulation") sim_manager.run_simulation(num_cycles, steps, debug_prints=debug_prints) print("Finished Simulation")
def run_segment(self, walker, segment_length): # documented in superclass # Gets the current posiotion of RandomWalk Walker positions = walker.state['positions'] # Make movements for the segment_length steps for _ in range(segment_length): # calls walk function for one step movement new_positions = self._walk(positions) positions = new_positions # makes new state form new positions new_state = WalkerState(positions=new_positions, time=0.0) # creates new_walker from new state and current weight new_walker = Walker(new_state, walker.weight) return new_walker
def run_segment(self, walker, segment_length, **kwargs): """Runs a random walk simulation for the given number of steps. Parameters ---------- walker : object implementing the Walker interface The walker for which dynamics will be propagated. segment_length : int The numerical value that specifies how much dynamical steps are to be run. Returns ------- new_walker : object implementing the Walker interface Walker after dynamics was run, only the state should be modified. """ # Gets the current posiotion of RandomWalk Walker positions = walker.state['positions'] # Make movements for the segment_length steps for _ in range(segment_length): # calls walk function for one step movement new_positions = self._walk(positions) positions = new_positions # makes new state form new positions new_state = WalkerState(positions=new_positions, time=0.0) # creates new_walker from new state and current weight new_walker = Walker(new_state, walker.weight) return new_walker
def __init__(self, native_state=None, cutoff_rmsd=0.2, initial_states=None, initial_weights=None, ligand_idxs=None, binding_site_idxs=None, **kwargs): """Constructor for RebindingBC. Arguments --------- native_state : object implementing the State interface The reference bound state. Will be automatically centered. cutoff_rmsd : float The cutoff RMSD for considering a walker bound. initial_states : list of objects implementing the State interface The list of possible states that warped walkers will assume. initial_weights : list of float, optional List of normalized probabilities of the initial_states provided. If not given, uniform probabilities will be used. ligand_idxs : arraylike of int The indices of the atom positions in the state considered the ligand. binding_site_idxs : arraylike of int The indices of the atom positions in the state considered the binding site. Raises ------ AssertionError If any of the following kwargs are not given: native_state, initial_states, ligand_idxs, receptor_idxs. """ super().__init__(initial_states=initial_states, initial_weights=initial_weights, ligand_idxs=ligand_idxs, receptor_idxs=binding_site_idxs **kwargs) # test inputs assert native_state is not None, "Must give a native state" assert type(cutoff_rmsd) is float native_state_d = native_state.dict() # save the native state and center it around it's binding site native_state_d['positions'] = center_around(native_state['positions'], binding_site_idxs) native_state = WalkerState(**native_state_d) # save attributes self._native_state = native_state self._cutoff_rmsd = cutoff_rmsd
def task_pass(walker): # simulate it actually taking some time n = walker.state['num'] return Walker(WalkerState(**{'num' : n+1}), walker.weight)
def gen_walkers(): return [Walker(WalkerState(**{'num' : arg}), 1/len(ARGS)) for arg in ARGS]
def gen_walkers(n_args): args = range(n_args) return [Walker(WalkerState(**{'num': arg}), 1 / len(args)) for arg in args]
def init(self, continue_run=None, init_walkers=None, **kwargs): # do the inherited stuff super().init(**kwargs) # open and initialize the HDF5 file logging.info("Initializing HDF5 file at {}".format(self.file_path)) self.wepy_h5 = WepyHDF5(self.file_path, mode=self.mode, topology=self._tmp_topology, units=self.units, sparse_fields=list(self._sparse_fields.keys()), feature_shapes=self._feature_shapes, feature_dtypes=self._feature_dtypes, n_dims=self._n_dims, main_rep_idxs=self.main_rep_idxs, alt_reps=self.alt_reps_idxs) # if we specify save fields only save these for the initial walkers if self.save_fields is not None: state_fields = list(init_walkers[0].state.dict().keys()) # make sure all the save_fields are present in the state assert all([True if save_field in state_fields else False for save_field in self.save_fields]), \ "Not all specified save_fields present in walker states" filtered_init_walkers = [] for walker in init_walkers: # make a new state by filtering the attributes of the old ones state_d = { k: v for k, v in walker.state.dict().items() if k in self.save_fields } # and saving alternate representations as we would # expect them # if there are any alternate representations set them for alt_rep_name, alt_rep_idxs in self.alt_reps_idxs.items(): alt_rep_path = 'alt_reps/{}'.format(alt_rep_name) # if the idxs are None we want all of the atoms if alt_rep_idxs is None: state_d[alt_rep_path] = state_d['positions'][:] # otherwise get only the atoms we want else: state_d[alt_rep_path] = state_d['positions'][ alt_rep_idxs] # if the main rep is different then the full state # positions set that if self.main_rep_idxs is not None: state_d['positions'] = state_d['positions'][ self.main_rep_idxs] # then making the new state new_state = WalkerState(**state_d) filtered_init_walkers.append(Walker(new_state, walker.weight)) # otherwise save the full state else: filtered_init_walkers = init_walkers self.wepy_h5.set_mode(mode='r+') with self.wepy_h5: # if this is a continuation run of another run we want to # initialize it as such # initialize a new run run_grp = self.wepy_h5.new_run(filtered_init_walkers, continue_run=continue_run) self.wepy_run_idx = run_grp.attrs['run_idx'] # initialize the run record groups using their fields self.wepy_h5.init_run_fields_resampling(self.wepy_run_idx, self.resampling_fields) # the enumeration for the values of resampling self.wepy_h5.init_run_fields_resampling_decision( self.wepy_run_idx, self.decision_enum) self.wepy_h5.init_run_fields_resampler(self.wepy_run_idx, self.resampler_fields) # set the fields that are records for tables etc. unless # they are already set if 'resampling' not in self.wepy_h5.record_fields: self.wepy_h5.init_record_fields('resampling', self.resampling_records) if 'resampler' not in self.wepy_h5.record_fields: self.wepy_h5.init_record_fields('resampler', self.resampler_records) # if there were no warping fields set there is no boundary # conditions and we don't initialize them if self.warping_fields is not None: self.wepy_h5.init_run_fields_warping(self.wepy_run_idx, self.warping_fields) self.wepy_h5.init_run_fields_progress(self.wepy_run_idx, self.progress_fields) self.wepy_h5.init_run_fields_bc(self.wepy_run_idx, self.bc_fields) # table records if 'warping' not in self.wepy_h5.record_fields: self.wepy_h5.init_record_fields('warping', self.warping_records) if 'boundary_conditions' not in self.wepy_h5.record_fields: self.wepy_h5.init_record_fields('boundary_conditions', self.bc_records) if 'progress' not in self.wepy_h5.record_fields: self.wepy_h5.init_record_fields('progress', self.progress_records) # if this was opened in a truncation mode, we don't want to # overwrite old runs with future calls to init(). so we # change the mode to read/write 'r+' if self.mode == 'w': self.set_mode(0, 'r+')
if __name__=="__main__": if sys.argv[1] == "--help" or sys.argv[1] == '-h': print("arguments: n_cycles, n_walkers, dimension") else: num_cycles = int(sys.argv[1]) num_walkers = int(sys.argv[2]) dimension = int(sys.argv[3]) h5_path = str(sys.argv[4]) # set up the distance function rw_distance = RandomWalkDistance(); # set up initial state for walkers positions = np.zeros((1, dimension)) init_state = WalkerState(positions=positions, time=0.0) #set up the Wexplore Resampler with the parameters resampler = WExploreResampler(distance=rw_distance, init_state=init_state, max_n_regions=MAX_N_REGIONS, max_region_sizes=MAX_REGION_SIZES, pmin=PMIN, pmax=PMAX, debug_mode=True) # set up a RandomWalkProfilier rw_profiler = RandomwalkProfiler(resampler, hdf5_reporter_path=h5_path) rw_profiler.run_test(num_walkers=num_walkers, num_cycles=num_cycles,
def get_char_distance(dimension, num_walkers): """Calculate the characteristic value. Runs one cycle simulation and calculates the characteristic distance value. Parameters ---------- dimension: int The dimension of the random walk space. num_walkers: int The number of walkers. Returns ------- characteristic distance : float The characteristic distance value. """ # set up initial state for walkers positions = np.zeros((1, dimension)) init_state = WalkerState(positions=positions, time=0.0) # set up the distance function rw_distance = RandomWalkDistance() # set up the REVO Resampler with the parameters resampler = REVOResampler(distance=rw_distance, pmin=PMIN, pmax=PMAX, init_state=init_state, char_dist=1, merge_dist=MERGE_DIST) # create list of init_walkers initial_weight = 1 / num_walkers init_walkers = [ Walker(init_state, initial_weight) for i in range(num_walkers) ] # set up raunner for system runner = RandomWalkRunner(probability=PROBABILITY) n_steps = 10 mapper = Mapper() # running the simulation sim_manager = Manager(init_walkers, runner=runner, resampler=resampler, work_mapper=mapper) print("Running simulation") #runs for one cycle sim_manager.init(num_walkers) new_walkers = sim_manager.run_segment(init_walkers, n_steps, 0) dist_matrix, _ = resampler._all_to_all_distance(new_walkers) return np.average(dist_matrix)
def _run(self, num_runs, num_cycles, num_walkers): """Runs a random walk simulation. Parameters ---------- num_runs: int The number independet simulations. num_cycles: int The number of cycles that will be run in the simulation. num_walkers: int The number of walkers. """ print("Random walk simulation with: ") print("Dimension = {}".format(self.dimension)) print("Probability = {}".format(self.probability)) print("Number of Walkers = {}".format(num_walkers)) print("Number of Cycles ={}".format(num_cycles)) # set up initial state for walkers positions = np.zeros((1, self.dimension)) init_state = WalkerState(positions=positions, time=0.0) # create list of init_walkers initial_weight = 1 / num_walkers init_walkers = [] init_walkers = [ Walker(init_state, initial_weight) for i in range(num_walkers) ] # set up raunner for system runner = RandomWalkRunner(probability=self.probability) units = dict(UNIT_NAMES) # instantiate a revo unbindingboudaryconditiobs segment_length = 10 # set up the reporter randomwalk_system_top_json = self.generate_topology() hdf5_reporter = WepyHDF5Reporter(file_path=self.hdf5_filename, mode='w', save_fields=SAVE_FIELDS, topology=randomwalk_system_top_json, resampler=self.resampler, units=dict(UNITS), n_dims=self.dimension) # running the simulation sim_manager = Manager(init_walkers, runner=runner, resampler=self.resampler, work_mapper=Mapper(), reporters=[hdf5_reporter]) # run a simulation with the manager for n_steps cycles of length 1000 each steps = [segment_length for i in range(num_cycles)] ### RUN the simulation for run_idx in range(num_runs): print("Starting run: {}".format(run_idx)) sim_manager.run_simulation(num_cycles, steps) print("Finished run: {}".format(run_idx)) print("Finished Simulation")