# -*- coding: utf-8 -*- """ A profiling run that tests the dynamics of calling propagate through the lammpsWalker API vs running dynamcis directly. """ import lammpsWalker import dynamics import os nsteps = 1000000 stepLength = 5 temperature = 310.0 damping_coefficient = 30.0 scratchdir = os.path.abspath("data") inputFilename = os.path.abspath("data/input.enk") logFilename = scratchdir + "/log.lammps" os.chdir(scratchdir) # lets instantiate a walker object to sample this window. wlkr = lammpsWalker.lammpsWalker(inputFilename, logFilename, index=0, debug=False) # set langevin dynamics object and pass it to the walker. dyn = dynamics.langevin(temperature, damping_coefficient, shake = True) wlkr.setDynamics(dyn) wlkr.setTimestep(1.0) wlkr.drawVel() for i in range(nsteps / stepLength): wlkr.propagate(stepLength)
def main(debug=False): """ definition of main scripting file for debugging purposes. """ # time the execution startTime = time() if debug: print "WARNING: Debug passed as True. Will dump maximum set of internal values." #---------------SET SIMULATION PARAMETERS ----------- params = {} params = setParameters(params) print "parameters initialized as: ", params print "Building scratch directory." # construct the wkdir. This is where the intermediate dynamics files will be written. fileIO.makeWkdir(params['scratchdir']) # make sure we've built the scratchdir since we'll assume it exists for the rest of the code assert os.path.exists(params['scratchdir']), "The scratch directory was not created." # we're going to move the wokring directory into the data directory os.chdir(os.path.dirname(params['inputFilename'])) #--------------- INITIALIZATION OF PARTITION INSTANCE-------- # construct the umbrella data structure # commented out below this block is the origional construction lines for the partition module. # here we're simply loading this from a binary pickle written to file. This obviates the need to # reconstruct the neighborlist every call if os.path.exists(params['systemFile']): with open(params['systemFile'], "r") as f_handle: system = pickle.load(f_handle) else: system = partition_mod.partition(params['ncells']) if debug: print system # now we construct the umbrella windows system.umbrellas = system.createUmbrellas(params['cvrange'], params['wrapping'], basisType=params['basisType'], neighborList=False) with open(params['systemFile'], "w") as f_handle: pickle.dump(system, f_handle, protocol=2) # double check we've created as many windows as we said in ncells assert len(system.umbrellas) == params['ncells'], "The number of cells specified does not equal the number of umbrellas created." # debug prints if debug: for i in range(len(system.umbrellas)): print "umbrella", i, system.umbrellas[i].center, system.umbrellas[i].width # ------------------ SETTING THE DYNAMICS PARAMETERS FOR SAMPLING THE WINDOWS ---------------- # now set up partition with a list of associated ranks system.rank_window_index = range(len(system.umbrellas)) # -------------- INITIALIZATION OF SYSTEM OBSERVABLES ------- # here we add a list of observables to compute pmf_prototype = observables.pmf("pmf", np.zeros((180,180))) system.addObservable(pmf_prototype) """ # now we check to make sure we've correctly set up the local observables for window in system.umbrellas: assert hasattr(window, "local_observables"), str(rank) + ": The local observables in window " + str(system.umbrellas.index(window)) + " was not created." for window in system.umbrellas: assert len(window.local_observables) == len(system.observables), str(rank) + ": The number of window observables does not match the number of partition observables." """ #----------------MAIN LOOP---------------- print "Sampling via equilibrium US." for k in range(params['iterations']): # ---------- RESET DATA USED FOR CURRENT ITERATION ------------- # reset the M matrix to zeros for this iteration of the algorithm # this matrix will get populated from the inner loop system.M = np.zeros((len(system.umbrellas), len(system.umbrellas))) system.nsamples_M = np.zeros((len(system.umbrellas), len(system.umbrellas))) # start a timer on root rank st = time() # this loop does one iteration of the update for i in range(10): print "sampling window", i # lets instantiate a walker object to sample this window. wlkr = lammpsWalker.lammpsWalker(params['inputFilename'], params['logFilename'], index=i, debug=debug) # set langevin dynamics object and pass it to the walker. dyn = dynamics.langevin(params['temperature'], params['damping_coefficient'], shake = True) wlkr.setDynamics(dyn) wlkr.setTimestep(1.0) wlkr.drawVel() # set colvars for this walker wlkr.addColvars('c1', "dihedral", [9, 30, 37, 44]) wlkr.addColvars('c2','dihedral', [30, 37, 44, 64]) #wlkr.setOutput("traj.out", "dcd", params['scratchdir'] + "/" + str(i) + ".dcd", nSteps=1000) #let's add an output for writing out the configurations in hdf5 format so we have an estimate for the local distribution if os.path.exists(params['scratchdir'] + "/ep." + str(i) + ".h5py"): f_handle = h5py.File(params['scratchdir'] + "/ep." + str(i) + ".h5py", "r") config = random.choice(f_handle.keys()) wlkr.setConfig(f_handle[config][:]) wlkr.drawVel() f_handle.close() else: try: if os.path.exists(params['startingPoints'] + "/start." + str(i) + ".npy"): config = np.load(params['startingPoints'] + "/start." + str(i) + ".npy") wlkr.setConfig(config) wlkr.drawVel() else: dragWalker(wlkr, system.umbrellas[i], nSteps=5) assert system.umbrellas[i](wlkr.getColvars(), system.umbrellas) > 0.0, "The walker in " + str(i) + " did not initialize in the support of the window." np.save(params['startingPoints'] + "/start." + str(i), wlkr.getConfig()) except AssertionError: pass # enter the sampling routine. system.sample_US(wlkr, params['walkerSteps'], i, k, params, debug=True) # now we are done populating the samples array, close the walker wlkr.close() del wlkr if debug: print system.umbrellas[i].local_observables[0].data # report time it too for root to move out of the barrier (ie all ranks have sampled) print "Elapsed time in sampling routine on root rank after barrier: ", time() - st # now let's time the communication section st = time() # ------------ EIGENVALUE PROBLEM -------------- """ Step 2) solution of the eigenvalue problem at each rank """ # at rank, compute G and z system.updateF('overlap') system.k += 1 #system.computeZ() if debug: print system.z """ Step 3) estimation of observables on each rank """ system.computeObservables() """ Step 4) all reduction of averaged observables to each processor """ if debug: print system.observables[0].data """ Step 5) writing local and global estimates of the observables on root rank only """ f_handle = h5py.File(params['scratchdir'] + "/F.out", "a") f_handle.create_dataset("F." + str(k), data=system.F) f_handle.close() f_handle = h5py.File(params['scratchdir'] + "/z.out", "a") f_handle.create_dataset("z." + str(k), data=system.z) f_handle.close() for obs in system.observables: f_handle = h5py.File(params['scratchdir'] + "/" + obs.name, "a") f_handle.create_dataset(obs.name + "." + str(k), data=obs.data) f_handle.close() print "Elapsed time in communication routine on root rank after barrier: ", time() - st print "Done!" print "Total wall clock time was: " + str(time() - startTime) + " seconds." return 0