def TI_sampling(in_gromos_system: Gromos_System, project_dir: str, step_name="lambda_sampling", lambda_values: List[float] = np.arange(0, 1.1, 0.1), subSystem: _SubmissionSystem = LOCAL(), n_simulation_repetitions: int = 3, n_equilibrations: int = 1): work_dir = bash.make_folder(project_dir + "/" + step_name) in_gromos_system.save(work_dir) sys_path = in_gromos_system.save( work_dir + "/" + step_name + "_input.obj") #Ugly workaround for deepcopy general_system_name_prefix = in_gromos_system.name lam_systems = [] for lam in lambda_values: lam = np.round(lam, 2) lam_system = Gromos_System.load(sys_path) lam_system.name = general_system_name_prefix + "_l_" + str(lam) lam_system.work_folder = work_dir # IMD ## Pertubation ###Pertubation of system. pert_block = PERTURBATION(NTG=1, NRDGL=0, RLAM=lam, DLAMT=0, ALPHC=0.5, ALPHLJ=0.5, NLAM=2, NSCALE=0) lam_system.imd.add_block(block=pert_block) ###Calculate additional lambda points for end-states if (not hasattr(lam_system, "PRECALCLAM")): precalc_lam_block = PRECALCLAM(NRLAM=2, MINLAM=0, MAXLAM=1) lam_system.imd.add_block(block=precalc_lam_block) # Submit out_gromos_system, jobID = _TI_lam_step( in_gromos_system=lam_system, project_dir=work_dir, step_name=lam_system.name, submission_system=subSystem, simulation_runs=n_simulation_repetitions, equilibration_runs=n_equilibrations) out_gromos_system.save(out_gromos_system.work_folder + "/sd_out_system.obj") lam_systems.append(out_gromos_system) return lam_system, jobID
def test_rebase(self): new_base = bash.make_folder(tmp_test_dir + "/rebase") self.subSys_files.work_folder = new_base self.subSys_files.rebase_files()
def chain_submission( simSystem: Gromos_System, out_dir_path: str, out_prefix: str, chain_job_repetitions: int, worker_script: str, job_submission_system: _SubmissionSystem, jobname: str, run_analysis_script_every_x_runs: int = 0, in_analysis_script_path: str = "", start_run_index: int = 1, prefix_command: str = "", previous_job_ID: int = None, work_dir: str = None, initialize_first_run: bool = True, reinitialize_every_run: bool = False, verbose: bool = False, verbose_lvl: int = 1, ) -> Tuple[int, str, Gromos_System]: """ this function submits a chain of simulation steps to the queuing system and does the file managment. Parameters ---------- simSystem : Gromos_System simulation system out_dir_path : str out directory path out_prefix : str out prefix for simulation files chain_job_repetitions : int how often, should the simulation be repeated (in continuation) worker_script : str worker, that should be submitted. This script will be executed at each scheduled job. job_submission_system : _SubmissionSystem submission system, what type of submission? jobname : str name of the simulation job run_analysis_script_every_x_runs : int, optional run analysis in between - (careful will not be overwritten, make sure final analysis is correct.), by default 0 in_analysis_script_path : str, optional analysis script for simulation, that should be applied (will at least be applied after the full simulation chain.), by default "" start_run_index : int, optional start index of the job chain., by default 1 prefix_command : str, optional any bash prefix commands, before submitting?, by default "" previous_job_ID : int, optional ID of the prefious job, to be chained to. , by default None work_dir : str, optional dir to wich the work in progress will be written. if None a tmp-srcatch dir will be used with LSF!, by default None initialize_first_run : bool, optional should the velocities for the first run be initialized?, by default True reinitialize_every_run : bool, optional should in every run, the velocities be reinitialized?, by default False verbose : bool, optional more bla bla, by default False verbose_lvl : int, optional nicely define ammount of bla bla, by default 1 Returns ------- Tuple[int, str, Gromos_System] Tuple[previous_job_ID, tmp_jobname, simSystem] will return the last job_ID, the last tmp_jobname and the final gromosSystem. Raises ------ ValueError if submission fails. This can habe various reasons, always check also the present files! (*omd etc.) """ if verbose: print("\nChainSubmission - " + out_prefix + "\n" + "=" * 30 + "\n") if (verbose) and verbose_lvl >= 2: print("start_run_index " + str(start_run_index)) if (verbose) and verbose_lvl >= 2: print("job reptitions " + str(chain_job_repetitions)) if job_submission_system is not LOCAL: simSystem._future_promise = True ana_id = None job_submission_system.job_duration = job_submission_system.job_duration for runID in range(start_run_index, chain_job_repetitions + 1): if verbose: print("\n submit " + jobname + "_" + str(runID) + "\n" + spacer3) tmp_outprefix = out_prefix + "_" + str(runID) tmp_jobname = jobname + "_" + str(runID) tmp_outdir = out_dir_path + "/" + tmp_outprefix tmp_out_cnf = tmp_outdir + "/" + tmp_outprefix + ".cnf" # Checks if run should be skipped! do_skip, previous_job_ID = do_skip_job( tmp_out_cnf=tmp_out_cnf, simSystem=simSystem, tmp_jobname=tmp_jobname, job_submission_system=job_submission_system, previous_job=previous_job_ID, verbose=verbose, ) if not do_skip: bash.make_folder(tmp_outdir) # build COMMANDS: if len(prefix_command) > 1: prefix_command += " && " # We will write the arguments to the python script in a bash array # to make it simpler to read in our input files. md_args = "md_args=(\n" md_args += "-out_dir " + tmp_outdir + "\n" md_args += "-in_cnf_path " + simSystem.cnf.path + "\n" md_args += "-in_imd_path " + simSystem.imd.path + "\n" md_args += "-in_top_path " + simSystem.top.path + "\n" md_args += "-runID " + str(runID) + "\n" # OPTIONAL ARGS if simSystem.disres is not None: md_args += "-in_disres_path " + simSystem.disres.path + "\n" if simSystem.ptp is not None: md_args += "-in_perttopo_path " + simSystem.ptp.path + "\n" if simSystem.refpos is not None: md_args += "-in_refpos_path " + simSystem.refpos.path + "\n" if simSystem.qmmm is not None: md_args += "-in_qmmm_path " + simSystem.qmmm.path + " " if simSystem.posres is not None: md_args += "-in_posres_path " + simSystem.posres.path + "\n" md_args += "-nmpi " + str(job_submission_system.nmpi) + "\n" md_args += "-nomp " + str(job_submission_system.nomp) + "\n" md_args += "-initialize_first_run " + str( initialize_first_run) + "\n" md_args += "-reinitialize_every_run " + str( reinitialize_every_run) + "\n" md_args += "-gromosXX_bin_dir " + str( simSystem.gromosXX.bin) + "\n" md_args += "-gromosXX_check_binary_paths " + str( simSystem.gromosXX._check_binary_paths) + "\n" if work_dir is not None: md_args += "-work_dir " + str(work_dir) + "\n" if hasattr(simSystem.imd, "WRITETRAJ"): if simSystem.imd.WRITETRAJ.NTWX > 0: md_args += "-out_trc " + str(True) + "\n" if simSystem.imd.WRITETRAJ.NTWE > 0: md_args += "-out_tre " + str(True) + "\n" if simSystem.imd.WRITETRAJ.NTWV > 0: md_args += "-out_trv " + str(True) + "\n" if simSystem.imd.WRITETRAJ.NTWF > 0: md_args += "-out_trf " + str(True) + "\n" if simSystem.imd.WRITETRAJ.NTWG > 0: md_args += "-out_trg " + str(True) + "\n" md_args += "-zip_trajectories " + str( job_submission_system.zip_trajectories) + "\n" md_args += ")\n" # closing the bash array which stores all arguments. # add zip option here # MAIN commands md_script_command = prefix_command + "\n\n" + md_args + "\n" md_script_command += "python3 " + worker_script + ' "${md_args[@]}" \n' if verbose: print("PREVIOUS ID: ", previous_job_ID) if verbose_lvl >= 2: print("COMMAND: ", md_script_command) # SCHEDULE THE COMMANDS try: if verbose: print("\tSIMULATION") os.chdir(tmp_outdir) sub_job = Submission_job( command=md_script_command, jobName=tmp_jobname, submit_from_dir=tmp_outdir, queue_after_jobID=previous_job_ID, outLog=tmp_outdir + "/" + out_prefix + "_md.out", errLog=tmp_outdir + "/" + out_prefix + "_md.err", sumbit_from_file=True, ) previous_job_ID = job_submission_system.submit_to_queue( sub_job) if verbose: print("SIMULATION ID: ", previous_job_ID) except ValueError as err: # job already in the queue raise ValueError("ERROR during submission of main job " + str(tmp_jobname) + ":\n" + "\n".join(err.args)) # OPTIONAL schedule - analysis inbetween. if (runID > 1 and run_analysis_script_every_x_runs != 0 and runID % run_analysis_script_every_x_runs == 0 and runID < chain_job_repetitions): if (verbose) and verbose_lvl >= 2: print("\tINBETWEEN ANALYSIS") sub_job = Submission_job( command=in_analysis_script_path, jobName=jobname + "_intermediate_ana_run_" + str(runID), outLog=tmp_outdir + "/" + out_prefix + "_inbetweenAna.out", errLog=tmp_outdir + "/" + out_prefix + "_inbetweenAna.err", queue_after_jobID=previous_job_ID, ) try: ana_id = job_submission_system.submit_to_queue(sub_job) if (verbose) and verbose_lvl >= 2: print("\n") except ValueError as err: # job already in the queue print("ERROR during submission of analysis command of " + sub_job.jobName + ":\n") print("\n".join(err.args)) else: if (verbose) and verbose_lvl >= 2: print("Did not submit!") if (verbose) and verbose_lvl >= 2: print("\n") if (verbose) and verbose_lvl >= 2: print("job_postprocess ") prefix_command = "" # Resulting cnf is provided to use it in further approaches. simSystem.cnf = Cnf(tmp_out_cnf, _future_file=True) if ana_id is not None: previous_job_ID = ana_id return previous_job_ID, tmp_jobname, simSystem
def do( in_simulation_dir: str, out_analysis_dir: str, sim_prefix: str, # in_system:Gromos_System, n_processes: int = 1, control_dict: dict = None, verbose: bool = True, ): """ This function is a analysis framework structure, that starts an analysis folder containing a data folder with all concatenated files, from which analysis can be started. Parameters ---------- in_simulation_dir : str input simulation directory (with succesfully finished simulations) out_analysis_dir : str output directory sim_prefix : str prefix of the simulation == name of simulation n_processes : int, optional WARNING: parallelization is currently not implemented!, by default 1 control_dict : dict, optional control structure, steering the executions, by default None verbose : bool, optional bla bla, by default True """ if not os.path.exists(out_analysis_dir) and not os.path.isdir( out_analysis_dir): bash.make_folder(out_analysis_dir) if not isinstance(control_dict, dict): warnings.warn( "Recieved a non dict control-dict! Using the template. \n\tGot:" + str(control_dict)) control_dict = template_control_dict # ORGANIZE FILES out_data_dir = out_analysis_dir + "/data" if not os.path.isdir(out_data_dir): os.mkdir(out_data_dir) if control_dict["concat"]["do"]: project_concatenation( in_folder=in_simulation_dir, in_prefix=sim_prefix, out_folder=out_data_dir, control_dict=control_dict["concat"]["sub"], verbose=verbose, ) # in_simSystem=in_system, # Other Analysis parts print(control_dict) if control_dict["simulation_folder"]["do"]: sub_dict = control_dict["simulation_folder"]["sub"] if os.path.exists(in_simulation_dir): if sub_dict["tar"]: out_tar_dir = bash.compress_tar(in_path=in_simulation_dir) if verbose: print("Tarred simulation folder: " + str(out_tar_dir)) bash.remove_file(in_simulation_dir, additional_options="-r") if sub_dict["remove"]: bash.remove_file(in_simulation_dir, additional_options="-r") else: warnings.warn( "Simulation dir was not present. Skipped Compression.\nGiven Path: " + in_simulation_dir)
def work( out_dir: str, in_cnf_path: str, in_imd_path: str, in_top_path: str, runID: int = 1, in_perttopo_path: str = None, in_disres_path: str = None, in_posres_path: str = None, in_refpos_path: str = None, in_qmmm_path: str = None, out_trc: bool = False, out_tre: bool = False, out_trg: bool = False, out_trv: bool = False, out_trf: bool = False, out_trs: bool = False, nmpi: int = 1, nomp: int = 1, reinitialize_every_run: bool = False, initialize_first_run: bool = True, gromosXX_bin_dir: str = None, gromosXX_check_binary_paths: bool = True, work_dir: str = None, zip_trajectories: bool = True, **kwargs, ): """ Executed by repex_EDS_long_production_run as workers Parameters ---------- out_dir : str final output dir in_cnf_path : str input coordinates in_imd_path : str input imd-parameter file in_top_path : str input topology in_perttopo_path : str input pertubation in_disres_path : str input disres in_qmmm_path : str input qmmm nmpi : int, optional number of mpi cores (def.=1) nomp : int, optional number of omp cores (def.= 1) out_trg : bool, optional True if trg shall be written out. out_trv : bool, optional True if trv shall be written out. out_trf : bool, optional True if trf shall be written out. out_trs : bool, optional True if trs shall be written out. gromosXX_bin_dir : str, optional path to gromos binary directory work_dir : str, optional work directory zip_trajectories: bool determines whether trajectories are zipped Returns ------- int return number """ time.sleep(time_wait_s_for_filesystem) # WORKDIR SetUP if work_dir is None or work_dir == "None": if "TMPDIR" in os.environ: work_dir = os.environ["TMPDIR"] else: print("Could not find TMPDIR!\n Switched to outdir for work") work_dir = out_dir if not os.path.isdir(work_dir): bash.make_folder(work_dir) elif isinstance(work_dir, str) and work_dir != "None": if work_dir == "out_dir": work_dir = out_dir if not os.path.isdir(work_dir): bash.make_folder(work_dir) else: if not os.path.isdir(work_dir): bash.make_folder(work_dir) else: raise ValueError(f"work_dir is not a valid path, work_dir: {work_dir}") print("workDIR: " + str(work_dir)) # Check if the calculation is running on multiple nodes: if "LSB_HOSTS" in os.environ: hosts = os.environ["LSB_HOSTS"].split() else: hosts = [] multi_node = True if len(hosts) > 1 else False # run a euler script to create tmpdir on all nodes if multi_node: os.system("remote_tmpdir create") os.chdir(work_dir) # Prepare IMD file: tmp_prefix = os.path.basename(out_dir) tmp_imd_path = out_dir + "/" + tmp_prefix + ".imd" imd_file = imd.Imd(in_imd_path) cnf_file = cnf.Cnf(in_cnf_path) # check init_block - if specified! # What kind of simulation is_stochastic_dynamics_sim = False is_vacuum = False if imd_file.BOUNDCOND.NTB == 0: is_vacuum = True if hasattr(imd_file, "STOCHDYN"): if imd_file.STOCHDYN.NTSD: is_stochastic_dynamics_sim = True # Adapt Initializations: if reinitialize_every_run or (initialize_first_run and runID == 1): imd_file.INITIALISE.NTIVEL = 1 if hasattr(imd_file, "CONSTRAINT"): imd_file.INITIALISE.NTISHK = 0 if ( imd_file.CONSTRAINT.NTC > 0) else 1 if hasattr(imd_file, "MULTIBATH"): imd_file.INITIALISE.NTINHT = 0 if ( imd_file.MULTIBATH.ALGORITHM <= 1) else 1 imd_file.INITIALISE.NTISHI = 0 if (hasattr(cnf_file, "LATTICESHIFTS")) else 1 imd_file.INITIALISE.NTIRTC = 0 imd_file.INITIALISE.NTICOM = 0 imd_file.INITIALISE.NTISTI = 0 if is_stochastic_dynamics_sim: imd_file.INITIALISE.NTISTI = 1 elif initialize_first_run and runID > 1: imd_file.INITIALISE.NTIVEL = 0 imd_file.INITIALISE.NTISHI = 0 imd_file.INITIALISE.NTISHK = 0 imd_file.INITIALISE.NTINHT = 0 imd_file.INITIALISE.NTINHB = 0 imd_file.INITIALISE.NTIRTC = 0 imd_file.INITIALISE.NTICOM = 0 imd_file.INITIALISE.NTISTI = 0 if is_stochastic_dynamics_sim or is_vacuum: imd_file.INITIALISE.NTISTI = 1 # adjust sim time if continuation: if runID > 1: imd_file.STEP.T = imd_file.STEP.T + (imd_file.STEP.NSTLIM * imd_file.STEP.DT) * (runID - 1) # Write out: tmp_imd_path = imd_file.write(tmp_imd_path) # RUN print("input: ", type(gromosXX_bin_dir), gromosXX_bin_dir) gromosXX = mdGromosXX.GromosXX( gromosXX_bin_dir=gromosXX_bin_dir, _check_binary_paths=gromosXX_check_binary_paths) print("gromosXX._bin: ", type(gromosXX._bin), gromosXX._bin) print("gromosXX.bin: ", type(gromosXX.bin), gromosXX.bin) try: print(spacer + "\n start MD " + str(os.path.basename(tmp_imd_path)) + "\n") # TODO: This is a stupid workaround as Euler tends to place nans in the euler angles, that should not be there! if hasattr(cnf_file, "GENBOX") and any( [math.isnan(x) for x in cnf_file.GENBOX.euler]): cnf_file.GENBOX.euler = [0.0, 0.0, 0.0] cnf_file.write(in_cnf_path) try: omd_file_path = gromosXX.md_run( in_topo_path=in_top_path, in_coord_path=in_cnf_path, in_imd_path=tmp_imd_path, in_pert_topo_path=in_perttopo_path, in_disres_path=in_disres_path, in_posresspec_path=in_posres_path, in_refpos_path=in_refpos_path, in_qmmm_path=in_qmmm_path, nmpi=nmpi, nomp=nomp, out_prefix=tmp_prefix, out_tre=out_tre, out_trc=out_trc, out_trg=out_trg, out_trs=out_trs, out_trf=out_trf, out_trv=out_trv, verbose=True, ) print("Waiting to find: ", omd_file_path.replace(".omd", ".cnf")) bash.wait_for_fileSystem(omd_file_path.replace(".omd", ".cnf")) md_failed = False except Exception as err: print("Failed! process returned: \n Err: \n" + "\n".join(err.args)) md_failed = True traceback.print_exc() raise err # zip the files after the simulation. n_cpu_zip = nmpi if nmpi >= nomp else nomp if not multi_node and zip_trajectories: zip_files.do(in_simulation_dir=work_dir, n_processes=n_cpu_zip) # Copy the files back to the proper directory when calc occured on scratch if out_dir != work_dir: if not multi_node: bash.move_file(work_dir + "/*", out_dir) else: for host in hosts: command = "ssh " + host + ' "mv ${TMPDIR}/* ' + out_dir + '"' os.system(command) os.system( "remote_tmpdir delete") # Works for both multi or single node # Note: If job is multi-node, it is simpler to zip things in out_dir after copying back if multi_node and zip_trajectories: zip_files.do(in_simulation_dir=out_dir, n_processes=n_cpu_zip) except Exception as err: print("\nFailed during simulations: ", file=sys.stderr) print(type(err), file=sys.stderr) print(err.args, file=sys.stderr) print("GROMOS OUTPUT:") omd_outs = glob.glob(out_dir + "/" + tmp_prefix + "*.omd") if len(omd_outs) > 1: omd_file_content = open(omd_outs[0], "r").read_lines() if len(omd_file_content) > 1: print("\t" + "\n\t".join(omd_file_content)) else: print("\t None") exit(1) if md_failed: print("\nFailed during simulations: \n Checkout: \n " + str(tmp_prefix) + ".omd", file=sys.stderr) exit(1) exit(0)
def simulation(in_gromos_system: Gromos_System, project_dir: str, step_name: str = "sim", in_imd_path=None, submission_system: _SubmissionSystem = LOCAL(), simulation_runs: int = 1, equilibration_runs: int = 0, previous_simulation_run: int = None, nmpi: int = 1, force_simulation: bool = False, analysis_script: callable = simulation_analysis.do, analysis_control_dict: dict = None, verbose: bool = False) -> (Gromos_System, int): #PREPERATIONS try: try: step_dir = project_dir + "/" + step_name bash.make_folder(step_dir) out_input_dir = step_dir + "/input" out_simulation_dir = step_dir + "/simulation" out_analysis_dir = step_dir + "/analysis" bash.make_folder(out_input_dir) ##Prepare gromos system: in_gromos_system = copy.deepcopy( in_gromos_system) #don't mutate outer systems in_gromos_system.work_folder = out_input_dir in_gromos_system.name = step_name if (not in_imd_path is None and in_gromos_system.imd.path is None): in_gromos_system.imd = in_imd_path in_gromos_system.adapt_imd() elif (not (in_gromos_system.cnf._future_file or in_gromos_system.imd._future_file)): in_gromos_system.adapt_imd() out_analysis_cnf = out_analysis_dir + "/data/" + in_gromos_system.name + ".cnf" print(spacer) print(step_name) print(spacer) #Write out, all non promised files #TODO: REMOVE - print(in_gromos_system.all_file_paths) in_gromos_system._update_all_file_paths() in_gromos_system.write_files() #TODO: REMOVE - print(in_gromos_system.all_file_paths) # %% ##Write Out Ana Script # IN args in_analysis_control_dict = analysis_control_dict n_analysis_processors = 1 #Maybe in the future: 5 if(nmpi>5) else 1 verbose = verbose except Exception as err: raise Exception("Could not prepare the gromos System\n\t" + "\n\t".join(map(str, err.args))) # do analysis_control_dict = simulation_analysis.template_control_dict if ( in_analysis_control_dict is None) else in_analysis_control_dict analysis_vars = OrderedDict({ "in_simulation_dir": out_simulation_dir, "sim_prefix": in_gromos_system.name, "out_analysis_dir": out_analysis_dir, "gromosPP_bin_dir": in_gromos_system.gromosPP._bin, "control_dict": analysis_control_dict, "n_processes": n_analysis_processors, "verbose": verbose, }) try: in_analysis_script_path = utils.write_job_script( out_script_path=step_dir + "/job_analysis.py", target_function=analysis_script, variable_dict=analysis_vars) except Exception as err: raise Exception("Could not prepare the analysis script\n\t" + "\n\t".join(map(str, err.args))) ##Write Out schedulling Script ###Build analysis_script MD_job_vars = OrderedDict({ "in_simSystem": in_gromos_system, "out_dir_path": out_simulation_dir, "simulation_run_num": simulation_runs, "equilibration_run_num": equilibration_runs, "submission_system": submission_system, "analysis_script_path": in_analysis_script_path, "nmpi": nmpi, }) try: in_scheduler_script_path = utils.write_job_script( out_script_path=step_dir + "/schedule_MD_job.py", target_function=simulation_scheduler.do, variable_dict=MD_job_vars) except Exception as err: raise Exception("Could not prepare the scheduling script\n\t" + "\n\t".join(map(str, err.args))) except Exception as err: traceback.print_exception(*sys.exc_info()) raise Exception("Could not prepare the command block\n\t" + "\n\t".join(map(str, err.args))) # %% ##schedule try: if ((os.path.exists(out_analysis_cnf) and os.path.exists(out_simulation_dir + ".tar")) and not force_simulation): print(utils.spacer2 + "FOUND RESULT: " + out_analysis_cnf + "\n GOING TO SKIPT THIS SUBMISSION!") #warnings.warn("Skipping active submission, as result CNF was found: \n"+out_analysis_cnf) last_jobID = None else: last_jobID = simulation_scheduler.do( in_simSystem=in_gromos_system, out_dir_path=out_simulation_dir, simulation_run_num=simulation_runs, equilibration_run_num=equilibration_runs, submission_system=submission_system, previous_job_ID=previous_simulation_run, analysis_script_path=in_analysis_script_path, nmpi=nmpi) except Exception as err: traceback.print_exception(*sys.exc_info()) raise Exception("Could not submit the commands\n\t" + "\n\t".join(map(str, err.args))) # Return the promise final system final_cnf_file = out_analysis_dir + "/data/" + in_gromos_system.name + ".cnf" if (os.path.exists(final_cnf_file)): in_gromos_system.cnf = cnf.Cnf(final_cnf_file) else: in_gromos_system.cnf = cnf.Cnf(in_value=None) in_gromos_system.cnf._future_file = True in_gromos_system.cnf.path = out_analysis_dir + "/data/" + in_gromos_system.name + ".cnf" in_gromos_system.work_folder = step_dir return in_gromos_system, last_jobID
def _configure_gromosPP_autotools( build_dir: str, binary_dir: str = None, with_omp: bool = False, with_debug: bool = False, verbose: bool = True, _timing_dict: dict = {}, ): """ Setting the configurations for the compiling gromosPP process. (uses autotools) Parameters ---------- build_dir : str directory, that should be used for building binary_dir : str, optional directory in which the binaries should be written to, by default None with_omp : bool, optional should gromosPP be compiled with omp, by default False with_debug : bool, optional set gromos debug flag, by default False verbose : bool, optional compiling is fun, I can tell you more!, by default True _timing_dict : dict, optional structure for storing timings of process, by default {} """ root_dir = os.path.dirname(build_dir) os.chdir(root_dir) # Initial config _timing_dict["gromosPP_init_start"] = datetime.now() if verbose: print(spacer2 + "\t\t> INIT \n" + spacer2) print("start time: ", _timing_dict["gromosPP_init_start"]) print("workdir:", os.getcwd()) bash.execute("./Config.sh") _timing_dict["gromosPP_init_end"] = datetime.now() if verbose: print( "duration: ", str(_timing_dict["gromosPP_init_end"] - _timing_dict["gromosPP_init_start"]), "\n") # Configure bash.make_folder(build_dir) os.chdir(build_dir) _timing_dict["gromosPP_conf_start"] = datetime.now() log_file = build_dir + "/configure.log" if verbose: print(spacer2 + "\t\t> CONFIGURE \n" + spacer2) print("start time: ", _timing_dict["gromosPP_conf_start"]) print("log_file: ", log_file) options = {} if binary_dir is not None: options.update({"--bindir": binary_dir}) flags = [] if with_omp: flags.append("--enable-openmp") if with_debug: flags.append("--enable-debug") flags.append( " --with-gsl=$(gsl-config --prefix) ") # this is required for gromosPP cmd = ("../configure " + " ".join([key + "=" + val for key, val in options.items()]) + " " + " ".join([flag for flag in flags])) if verbose: print("command: ", cmd) bash.execute(cmd, catch_STD=log_file) _timing_dict["gromosPP_conf_end"] = datetime.now() if verbose: print( "duration: ", str(_timing_dict["gromosPP_conf_end"] - _timing_dict["gromosPP_conf_start"]), "\n")
def _configure_gromosXX_autotools( build_dir: str, binary_dir: str = None, with_cuda_dir: str = None, with_omp: bool = False, with_mpi: bool = False, with_debug: bool = False, verbose: bool = True, _timing_dict: dict = {}, ): """ Setting the configurations for the compiling gromosXX process. (uses autotools) Parameters ---------- build_dir : str directory, that should be used for building binary_dir : str, optional directory in which the binaries should be written to, by default None with_cuda_dir : str, optional use the following cuda path and activate cuda support, by default None with_omp : bool, optional should gromosXX be compiled with omp - Warning dont combine wiht mpi!, by default False with_mpi : bool, optional should gromosXX be compiled wiht mpi - Warning dont combine with omp!, by default False with_debug : bool, optional set gromos debug flag, by default False verbose : bool, optional compiling is fun, I can tell you more!, by default True _timing_dict : dict, optional structure for storing timings of process, by default {} Raises ------ ValueError if wrong value was passed """ root_dir = os.path.dirname(build_dir) os.chdir(root_dir) # Initial config _timing_dict["gromosXX_init_start"] = datetime.now() if verbose: print(spacer2 + "\t\t> INIT \n" + spacer2) print("start time: ", _timing_dict["gromosXX_init_start"]) print("workdir:", os.getcwd()) bash.execute("./Config.sh") _timing_dict["gromosXX_init_end"] = datetime.now() if verbose: print( "duration: ", str(_timing_dict["gromosXX_init_end"] - _timing_dict["gromosXX_init_start"]), "\n") # Configure bash.make_folder(build_dir) os.chdir(build_dir) log_file = build_dir + "/configure.log" _timing_dict["gromosXX_conf_start"] = datetime.now() if verbose: print(spacer2 + "\t\t> CONFIGURE \n" + spacer2) print("start time: ", _timing_dict["gromosXX_conf_start"]) print("workdir:", os.getcwd()) print("log_file: ", log_file) options = {} if binary_dir is not None: options.update({"--bindir": binary_dir}) if with_cuda_dir is not None: options.update({"--with-cuda": with_cuda_dir}) flags = [] if with_omp and with_mpi: raise ValueError("Can not use with_omp and with_mpi at the same time!") if with_omp: flags.append("--enable-openmp") if with_mpi: flags.append("--enable-mpi") if with_debug: flags.append("--enable-debug") cmd = ("../configure " + " ".join([key + "=" + val for key, val in options.items()]) + " " + " ".join([flag for flag in flags])) if verbose: print("command: ", cmd) bash.execute(cmd, catch_STD=log_file) _timing_dict["gromosXX_conf_end"] = datetime.now() if verbose: print( "duration: ", str(_timing_dict["gromosXX_conf_end"] - _timing_dict["gromosXX_conf_start"]), "\n")
def TI_sampling( in_gromos_system: Gromos_System, project_dir: str = None, step_name="lambda_sampling", lambda_values: List[float] = np.arange(0, 1.1, 0.1), subSystem: _SubmissionSystem = LOCAL(), n_productions: int = 3, n_equilibrations: int = 1, randomize: bool = False, dual_cnf: List[str] = None, verbose: bool = True, ): """ This function will automatically submit N independent (different lambda) MD simulations with a lambda dependent potential energy. Parameters ---------- in_gromos_system: Gromos_System input gromos system project_dir: str directory in which simulation input files are found step_name: str subdirectory of project_dir, in which we will write the output important: allows to run multiple random seeds with a different "step_name" lambda_values: List [float] List of lambda values for each independent simulation subSystem: _SubmissionSystem where will the calculation run n_productions: int number of chunks each independent simulation is broken down into n_equilibrations: int number of chunks of equilibration preceding the production for each independent simulation randomize: bool Choose a random number for the initial random seed (same for all lambda values) dual_cnf: List [str], optional If provided, should be the path to two conformations (matching end states A and B) which can be used as initial conformations Simulations with a lambda value between 0 and 0.5 will use the first as starting conformation Returns -------- lam_system: Gromos_System Gromos system of the simulation submitted last """ if project_dir is None: project_dir = in_gromos_system.work_folder work_dir = bash.make_folder(project_dir + "/" + step_name) # Select a random seed here so all lambda windows have the same if randomize: in_gromos_system.imd.randomize_seed() in_gromos_system.save(work_dir) general_system_name_prefix = in_gromos_system.name lam_systems = [] for lam in lambda_values: lam = np.round(lam, 4) lam_system = deepcopy(in_gromos_system) lam_system.name = general_system_name_prefix + "_l_" + str(lam) lam_system.work_folder = work_dir # Choose different conformations depending on lambda point. # e.g. this allows to use RE-EDS SSM conformations. # dual_cnf[i] contains the path of the cnf to use if dual_cnf is not None and lam <= 0.5: lam_system.cnf = Cnf(dual_cnf[0]) elif dual_cnf is not None: lam_system.cnf = Cnf(dual_cnf[1]) # IMD # Pertubation # Pertubation of system. pert_block = PERTURBATION(NTG=1, NRDGL=0, RLAM=lam, DLAMT=0, ALPHC=0.5, ALPHLJ=0.5, NLAM=2, NSCALE=0) lam_system.imd.add_block(block=pert_block) # Calculate additional lambda points if not hasattr(lam_system, "PRECALCLAM"): # Note: This assumes uniformely distributed lambda values precalc_lam_block = PRECALCLAM(NRLAM=len(lambda_values), MINLAM=0, MAXLAM=1) lam_system.imd.add_block(block=precalc_lam_block) # Submit out_gromos_system = _TI_lam_step( in_gromos_system=lam_system, project_dir=work_dir, step_name=lam_system.name, submission_system=subSystem, in_imd_path=None, simulation_runs=n_productions, equilibration_runs=n_equilibrations, verbose=verbose, ) out_gromos_system.save(out_gromos_system.work_folder + "/sd_out_system.obj") lam_systems.append(out_gromos_system) return lam_system
def project_concatenation( in_folder: str, in_topology_path: str, in_imd: str, num_replicas: int, control_dict: Dict[str, bool], out_folder: str, in_ene_ana_lib_path: str, out_file_prefix: str = "test", fit_traj_to_mol: int = 1, starting_time: float = 0, include_water_in_trc=True, additional_properties: Union[Tuple[str], List[str]] = ("solvtemp2", "totdisres"), n_processes: int = 1, gromosPP_bin_dir: str = None, verbose: bool = False, nofinal=False, boundary_conditions: str = "r cog", ) -> dict: if verbose: print("reading imd file: " + in_imd) imd_file = imd.Imd(in_imd) dt = float(imd_file.STEP.DT) dt_trc = int(imd_file.WRITETRAJ.NTWX) * dt dt_tre = int(imd_file.WRITETRAJ.NTWE) * dt tmp_dir = out_folder + "/tmp_file" if os.path.isdir(tmp_dir): bash.make_folder(tmp_dir) out_cnfs = out_tres = out_trcs = out_dcd = out_repdat = None p_conv = p_cnf = p_repdat = p_trc = p_tre = p_ene_ana = False submitted_trc_job = submitted_tre_job = False if n_processes > 1: p = mult.Pool(n_processes) manager = mult.Manager() if control_dict["cp_cnf"]: if verbose: print("\tStart cnfs") # find all cnf files in this project sim_dir_cnfs = gather_simulation_replica_file_paths( in_folder, num_replicas, filePrefix="", fileSuffixes=".cnf", verbose=verbose, finalNumberingSort=nofinal) # do parallel if n_processes > 1: out_cnfs = manager.dict() distribute = [(n, out_cnfs, sim_dir_cnfs, range(n, len(sim_dir_cnfs) + 1, n_processes), out_folder, verbose) for n in range(1, n_processes + 1)] # _async p_cnf = p.starmap(_thread_worker_cnfs, distribute) else: out_cnfs = {} _thread_worker_cnfs( job=-1, out_cnfs=out_cnfs, in_cnfs=sim_dir_cnfs, replica_range=list(sim_dir_cnfs.keys()), out_folder=out_folder, verbose=verbose, ) if verbose: print("Out cnfs: ", out_cnfs) if control_dict["cat_trc"]: print("\tStart Trc Cat") # find all trc files in this project trc_files = gather_simulation_replica_file_paths( in_folder, num_replicas, filePrefix="", fileSuffixes=[".trc", ".trc.gz", ".trc.tar.gz"], verbose=verbose, finalNumberingSort=nofinal, ) out_prefix = out_folder + "/" + out_file_prefix + "_" # concat all files to a single .trc if n_processes > 1: # parallel submitted_trc_job = True if verbose: print("going parallel: n_processes - " + str(n_processes)) out_trcs = manager.dict() distributed_jobs = [( n, range(n, len(trc_files) + 1, n_processes), trc_files, out_prefix, in_topology_path, out_trcs, dt_trc, starting_time, verbose, include_water_in_trc, ) for n in range(1, n_processes + 1)] # _async p_trc = p.starmap(_thread_worker_cat_trc, distributed_jobs) p.close() p.join() else: out_trcs = {} _thread_worker_cat_trc( job=-1, topology_path=in_topology_path, replicaID_range=list(trc_files.keys()), trc_files=trc_files, out_prefix=out_prefix, dt=dt_trc, time=starting_time, out_trcs=out_trcs, verbose=verbose, boundary_conditions=boundary_conditions, include_all=include_water_in_trc, ) if control_dict["cat_tre"]: print("\tStart Tre Cat") # find all trc files in this project tre_files = gather_simulation_replica_file_paths( in_folder, num_replicas, filePrefix="", fileSuffixes=[".tre", ".tre.tar.gz"], verbose=verbose, finalNumberingSort=nofinal, ) out_prefix = out_folder + "/" + out_file_prefix + "_" # concat all files to a single .trc if n_processes > 1: if verbose: print("going parallel: n_processes - " + str(n_processes), " for ", len(tre_files)) submitted_tre_job = True out_tres = manager.dict() distributed_jobs = [(n, range(n, len(tre_files) + 1, n_processes), tre_files, out_prefix, out_tres, verbose) for n in range(1, n_processes + 1)] p = mult.Pool(n_processes) p_tre = p.starmap(_thread_worker_cat_tre, distributed_jobs) p.close() p.join() else: out_tres = {} _thread_worker_cat_tre( job=-1, replicaID_range=tre_files.keys(), tre_files=tre_files, out_prefix=out_prefix, out_tres=out_tres, verbose=verbose, ) if control_dict["ene_ana"]: print("\tStart ene ana") # wait for async job creating the trcs. if submitted_tre_job: p_tre.wait() # gather potentials properties = list(additional_properties) # find all trc files in this project tre_files = gather_simulation_replica_file_paths( in_folder, num_replicas, filePrefix="", fileSuffixes=[".tre", ".tre.gz"], verbose=verbose, finalNumberingSort=nofinal, ) # ".tre.tar.gz" # isolate potentials if verbose: print("Isolate ene_ana:") if n_processes > 1: p = mult.Pool(n_processes) distribute_jobs = [( out_folder, out_folder, properties, list(tre_files.keys())[n::n_processes], in_ene_ana_lib_path, gromosPP_bin_dir, out_file_prefix, "", dt_tre, n, verbose, ) for n in range(n_processes)] p_ene_ana = p.starmap_async(thread_worker_isolate_energies, distribute_jobs) else: thread_worker_isolate_energies( in_en_file_paths=tre_files, out_folder=out_folder, properties=properties, out_prefix=out_file_prefix, in_ene_ana_lib=in_ene_ana_lib_path, gromosPP_path=gromosPP_bin_dir, dt=dt_tre, replicas=list(tre_files.keys()), verbose=verbose, ) if control_dict["convert_trcs"]: print("\tStart Trc Conversion") # wait for async job creating the trcs. if submitted_trc_job: p_trc.wait() # get files: final_trc_files = list( sorted(glob.glob(out_folder + "/*.trc*"), key=lambda x: int(x.split("_")[-1].split(".")[0]))) if n_processes > 1: out_dcd = manager.dict() distributed_jobs = [( n, range(n, num_replicas, n_processes), final_trc_files, in_topology_path, gromosPP_bin_dir, out_dcd, fit_traj_to_mol, verbose, ) for n in range(n_processes)] p_conv = p.starmap_async(_thread_worker_conv_trc, distributed_jobs) else: out_dcd = {} _thread_worker_conv_trc( job=-1, replica_range=range(num_replicas), trc_files=final_trc_files, in_topology_path=in_topology_path, gromos_path=gromosPP_bin_dir, out_traj=out_dcd, fit_traj_to_mol=1, verbose=verbose, boundary_conditions=boundary_conditions, ) if n_processes > 1: # wait for the jobs to finish if ((not p_conv or p_conv.wait()) and (not p_cnf or p_cnf.wait()) and (not p_repdat or p_repdat.wait()) and (not p_trc or p_trc.wait()) and (not p_tre or p_tre.wait()) and (not p_ene_ana or p_ene_ana.wait())): raise ChildProcessError("A process failed! ") p.close() p.join() out_dict = { "out_folder": out_folder, "cnfs": dict(out_cnfs), "repdat": out_repdat, "tres": dict(out_tres), "trcs": dict(out_trcs), "dcds": dict(out_dcd), } manager.shutdown() else: out_dict = { "out_folder": out_folder, "cnfs": out_cnfs, "repdat": out_repdat, "tres": out_tres, "trcs": out_trcs, "dcds": out_dcd, } if verbose: print("all jobs finished") return out_dict
def _thread_worker_cat_trc( job: int, replicaID_range: List[int], trc_files: Dict[int, List[str]], out_prefix: str, topology_path: str, out_trcs: dict, dt: float, time: float = 0, verbose: bool = False, boundary_conditions: str = "r cog", include_all: bool = False, ): """_thread_worker_cat_trc This thread worker_scripts concatenates all .trc files of one replica into one file. Parameters ---------- job : rank of this thread replicaID_range : x_range - list of all trc_files : Dict[int, List[str]] Dictionary containing all replicas, with list of all trc files concerning one trc. out_prefix : str output prefix verbose : bool verbosity? Returns ------- None """ gromPP = gromosPP.GromosPP() start_dir = os.getcwd() if verbose: print("JOB " + str(job) + ": range " + str(list(replicaID_range))) for replicaID in replicaID_range: out_path = out_prefix + str(replicaID) + ".trc" compress_out_path = out_path + ".gz" out_trcs.update({replicaID: compress_out_path}) if os.path.exists( compress_out_path): # found perfect compressed trc file:) warnings.warn("Skipped generating file as I found: " + compress_out_path) if os.path.exists(out_path): bash.remove_file(out_path) continue elif os.path.exists( out_path): # did not find compressed file. will compress warnings.warn("Skipped generating file as I found: " + out_path) continue else: # concat files if verbose: print("JOB " + str(job) + ": " + "write out " + out_path + "\n") out_dir = os.path.dirname(out_path) tmp_dir = bash.make_folder(out_dir + "/TMP_replica_" + str(replicaID), additional_option="-p") os.chdir(tmp_dir) if include_all: out_path = gromPP.frameout( in_top_path=topology_path, in_coord_path=" ".join(trc_files[replicaID]), periodic_boundary_condition=boundary_conditions, single_file=True, out_file_format="trc", out_file_path=out_path, time=time, dt=dt, include="ALL", ) else: out_path = gromPP.frameout( in_top_path=topology_path, in_coord_path=" ".join(trc_files[replicaID]), periodic_boundary_condition=boundary_conditions, single_file=True, out_file_format="trc", out_file_path=out_path, time=time, dt=dt, ) os.chdir(start_dir) bash.wait_for_fileSystem(out_path) bash.remove_folder(tmp_dir) if verbose: print("JOB " + str(job) + ": " + "write out " + out_path + "\t DONE\n") if verbose: print("JOB " + str(job) + ": " + "compress " + compress_out_path + "\n") compressed_trc = bash.compress_gzip(out_path, out_path=compress_out_path) if verbose: print("JOB " + str(job) + ": " + "compress " + compressed_trc + "\t DONE\n")
def simulation( in_gromos_simulation_system: Gromos_System, override_project_dir: str = None, step_name: str = "sim", in_imd_path: str = None, submission_system: _SubmissionSystem = LOCAL(), simulation_runs: int = 1, equilibration_runs: int = 0, previous_simulation_run: int = None, force_simulation: bool = False, initialize_first_run=False, reinitialize_every_run=False, analysis_script: callable = simulation_analysis.do, analysis_control_dict: dict = None, _no_double_submit_check: bool = False, _work_dir: str = None, verbose: bool = True, verbose_lvl: int = 1, _template_imd_path: str = None, ) -> Gromos_System: """ This function is a generic simulation block, that can be used to run and schedule simulations. Parameters ---------- in_gromos_simulation_system : Gromos_System gromos system that contains the information of the files, that are required for the simulation run. override_project_dir : str parent project directory step_name : str, optional name of the step - used as jobname and folder in the project dir. in_imd_path : str, optional if a path to an imd file is given here, it will be used! submission_system : _SubmissionSystem, optional the system, that should be used to submit a job simulation_runs : int, optional number of sequential simulation runs equilibration_runs : int, optional number of equilibration runs, that will not appear in the final traj previous_simulation_run : int, optional job-ID of the previous simulation force_simulation : bool, optional if simulation already exist, shall it be overwritten? analysis_script : callable, optional script that is used to analyse the job analysis_control_dict : dict, optional sub selection of steps, for the analysis script, that should be executed verbose : bool, optional "baeh, baeh, baeh" - a wise black-nose sheep from ausserberg. verbose_lvl : int, optional how much baeh? _template_imd_path : str, optional default template imd Returns ------- Gromos_System, returns a new gromos system which is containing the simulation info """ # PREPERATIONS try: try: gromos_system = deepcopy(in_gromos_simulation_system) if previous_simulation_run is not None: gromos_system._last_jobID = previous_simulation_run # check if override dir is given and set project to correct location if override_project_dir is not None: init_work_folder = override_project_dir step_dir = override_project_dir + "/" + step_name else: init_work_folder = gromos_system.work_folder step_dir = gromos_system.work_folder + "/" + step_name bash.make_folder(step_dir) out_input_dir = step_dir + "/input" out_simulation_dir = step_dir + "/simulation" out_analysis_dir = step_dir + "/analysis" bash.make_folder(out_input_dir) os.chdir(step_dir) # Prepare gromos system: gromos_system.work_folder = out_input_dir gromos_system.name = step_name if in_imd_path is not None: gromos_system.imd = in_imd_path elif hasattr(gromos_system.imd, "TITLE"): pass elif _template_imd_path is not None: if verbose: warnings.warn("Template_imd_path was used: " + _template_imd_path) gromos_system.imd = _template_imd_path gromos_system.prepare_for_simulation() else: raise ValueError( "Could not find any .imd path (gromos system has no imd, in_imd_path not given and also no _template_imd_path!)" ) out_analysis_cnf = out_analysis_dir + "/data/" + gromos_system.name + ".cnf" if verbose: print(spacer) print(step_name) print(spacer) # Write out, all non promised files gromos_system.rebase_files() # Write Out Ana Script in_analysis_control_dict = analysis_control_dict n_analysis_processors = 1 # Maybe in the future: 5 if(nmpi>5) else 1 except Exception as err: raise Exception("Could not prepare the gromos System\n\t" + "\n\t".join(map(str, err.args))) # do if analysis_script is not None: analysis_control_dict = (simulation_analysis.template_control_dict if (in_analysis_control_dict is None) else in_analysis_control_dict) analysis_vars = OrderedDict({ "in_simulation_dir": out_simulation_dir, "sim_prefix": gromos_system.name, "out_analysis_dir": out_analysis_dir, "gromosPP_bin_dir": gromos_system.gromosPP._bin, "control_dict": analysis_control_dict, "n_processes": n_analysis_processors, "verbose": verbose, "verbose_lvl": verbose_lvl, }) try: in_analysis_script_path = utils.write_job_script( out_script_path=step_dir + "/job_analysis.py", target_function=analysis_script, variable_dict=analysis_vars, ) except Exception as err: raise Exception("Could not prepare the analysis script\n\t" + "\n\t".join(map(str, err.args))) else: in_analysis_script_path = None # Write Out schedulling Script # Build analysis_script MD_job_vars = OrderedDict({ "in_simSystem": gromos_system, "out_dir_path": out_simulation_dir, "simulation_run_num": simulation_runs, "equilibration_run_num": equilibration_runs, "submission_system": submission_system, "analysis_script_path": in_analysis_script_path, "initialize_first_run": initialize_first_run, "reinitialize_every_run": reinitialize_every_run, "previous_job_ID": gromos_system._last_jobID, "_no_double_submit_check": _no_double_submit_check, "_work_dir": _work_dir, "verbose": verbose, "verbose_lvl": verbose_lvl, }) try: utils.write_job_script( out_script_path=step_dir + "/schedule_MD_job.py", target_function=simulation_scheduler.do, variable_dict=MD_job_vars, ) except Exception as err: raise Exception("Could not prepare the scheduling script\n\t" + "\n\t".join(map(str, err.args))) except Exception as err: traceback.print_exception(*sys.exc_info()) raise Exception("Could not prepare the command block\n\t" + "\n\t".join(map(str, err.args))) # schedule try: if (os.path.exists(out_analysis_cnf) and os.path.exists(out_simulation_dir + ".tar")) and not force_simulation: if verbose: print(utils.spacer2 + "FOUND RESULT: " + out_analysis_cnf + "\n GOING TO SKIPT THIS SUBMISSION!") # warnings.warn("Skipping active submission, as result CNF was found: \n"+out_analysis_cnf) last_jobID = 0 else: last_jobID = simulation_scheduler.do(**MD_job_vars) except Exception as err: traceback.print_exception(*sys.exc_info()) raise Exception("Could not submit the commands\n\t" + "\n\t".join(map(str, err.args))) time.sleep(time_wait_s_for_filesystem) # Return the promise final system if in_analysis_script_path is None and os.path.exists(out_simulation_dir): cnfs = list( sorted(glob.glob(out_simulation_dir + "/*/*cnf"), key=lambda x: int(x.split("_")[-1].split(".")[0]))) last_cnf = cnfs[-1] gromos_system.cnf = cnf.Cnf(last_cnf) elif os.path.exists(out_analysis_cnf): gromos_system.cnf = cnf.Cnf(out_analysis_cnf) else: gromos_system.cnf = cnf.Cnf(in_value=None) gromos_system.cnf._future_file = True gromos_system.cnf.path = out_analysis_dir + "/data/" + gromos_system.name + ".cnf" # Return trajectories if available gromos_system._traj_files_path = {} if hasattr(gromos_system.imd, "WRITETRAJ") and gromos_system.imd.WRITETRAJ.NTWX > 0: final_trc_file = out_analysis_dir + "/data/" + gromos_system.name + ".trc" if os.path.exists(final_trc_file + ".h5"): gromos_system.trc = final_trc_file + ".h5" elif os.path.exists(final_trc_file): gromos_system.trc = final_trc_file else: gromos_system.trc = Trc(traj_path=None, in_cnf=None) gromos_system.trc._future_file = True gromos_system.trc.path = final_trc_file if hasattr(gromos_system.imd, "WRITETRAJ") and gromos_system.imd.WRITETRAJ.NTWE > 0: final_tre_file = out_analysis_dir + "/data/" + gromos_system.name + ".tre" if os.path.exists(final_tre_file + ".h5"): gromos_system.tre = final_tre_file + ".h5" elif os.path.exists(final_tre_file): gromos_system.tre = final_tre_file else: gromos_system.tre = Tre(input_value=None) gromos_system.tre._future_file = True gromos_system.tre.path = final_tre_file if hasattr(gromos_system.imd, "WRITETRAJ") and gromos_system.imd.WRITETRAJ.NTWG > 0: final_trg_file = out_analysis_dir + "/data/" + gromos_system.name + ".trg" if os.path.exists(final_trg_file + ".h5"): gromos_system.trg = Trg(input_value=final_trg_file + ".h5") elif os.path.exists(final_trg_file): gromos_system.trg = Trg(input_value=final_trg_file) else: gromos_system.trg = Trg(input_value=None) gromos_system.trg._future_file = True gromos_system.trg.path = final_trg_file # Set work_folder to initial work folder path to avoid nested simulations # However, do not update all file names (work_folder_no_update) to avoid # compromising the file system structure gromos_system.work_folder_no_update(init_work_folder) gromos_system._last_jobID = last_jobID os.chdir(init_work_folder) return gromos_system
def do( in_simSystem: Gromos_System, out_dir_path: str, simulation_run_num: int, equilibration_run_num: int = 0, initialize_first_run=False, reinitialize_every_run=False, analysis_script_path: str = None, submission_system: _SubmissionSystem = LSF(), previous_job_ID: int = None, _no_double_submit_check: bool = False, _work_dir: str = None, verbose: bool = True, verbose_lvl: int = 1, ) -> int: """ This function schedules simulations starting from the gromos system. Parameters ---------- in_simSystem : Gromos_System system that should be submitted with the provided imd file out_dir_path : str out directory path for the simulation simulation_run_num : int number of simulations equilibration_run_num : int, optional number of the equilibraitons, by default 0 initialize_first_run : bool, optional should the velocities be initialized in the first run?, by default False reinitialize_every_run : bool, optional DEAPPRECIATED! should always the velocities be initialized, by default False analysis_script_path : str, optional path to the analysis script, that should be used for this simulaiton approach, by default None submission_system : _SubmissionSystem, optional system, to be used to submit the jobs, by default LSF() previous_job_ID : int, optional previous job ID, by default None _no_double_submit_check : bool, optional don't check if job was already submit to queue (increases performance!), by default False _work_dir : str, optional directory, to write out the tmp files, by default None verbose : bool, optional Baeh Baeh, by default True verbose_lvl : int, optional amount of Baehs, by default 1 Returns ------- int the last job id, that was submitted. Raises ------ IOError If error happens in preperation of simulation or in the submission """ submission_system.block_double_submission = _no_double_submit_check job_verb = True if (verbose and verbose_lvl > 2) else False # prepare try: if verbose: print("Script: ", __file__) if verbose and verbose_lvl > 2: print(spacer + "Simulation PREPERATION\n" + spacer + "\n") # Outdir bash.make_folder(out_dir_path) # final output_folder # workdir: if not isinstance(_work_dir, type(None)) and _work_dir != "None": if verbose and verbose_lvl > 2: print("\t -> Generating given workdir: " + _work_dir) bash.make_folder(_work_dir, "-p") os.chdir(_work_dir) else: if verbose and verbose_lvl > 2: print("\t -> Using on node workdir") # sim vars logs out_prefix = in_simSystem.name worker_script = workerScript.__file__ # CHECK PATH DEPENDENCIES - all Files present? # needed variables check_path_dependencies_paths = [ worker_script, out_dir_path, ] # Coord file is used by repex in_imd_path prepared_im # variable paths if _work_dir is not None and _work_dir != "out_dir": check_path_dependencies_paths.append(_work_dir) if not in_simSystem.top._future_file: check_path_dependencies_paths.append(in_simSystem.top.path) if not in_simSystem.cnf._future_file: check_path_dependencies_paths.append(in_simSystem.cnf.path) if not in_simSystem.imd._future_file: check_path_dependencies_paths.append(in_simSystem.imd.path) if in_simSystem.ptp is not None: check_path_dependencies_paths.append(in_simSystem.ptp.path) if in_simSystem.disres is not None: check_path_dependencies_paths.append(in_simSystem.disres.path) if in_simSystem.posres is not None: check_path_dependencies_paths.append(in_simSystem.posres.path) if in_simSystem.refpos is not None: check_path_dependencies_paths.append(in_simSystem.refpos.path) if in_simSystem.qmmm is not None: check_path_dependencies_paths.append(in_simSystem.qmmm.path) bash.check_path_dependencies(check_path_dependencies_paths, verbose=job_verb) except Exception as err: print( "#####################################################################################" ) print("\t\tERROR in Preperations") print( "#####################################################################################" ) traceback.print_exception(*sys.exc_info()) raise IOError("ERROR in Preperations to submission!") from err # RUN Job try: if verbose: print("\n" + spacer + "Simulation Setup:\n" + spacer) if verbose: print("steps_per_run: ", in_simSystem.imd.STEP.NSTLIM) if verbose: print("equis: ", equilibration_run_num) if verbose: print("simulation runs: ", simulation_run_num) # Submission # EQ eq_job_id = None if equilibration_run_num > 0: # EQUILIBRATION tmp_outprefix = "eq_" + out_prefix tmp_jobname = in_simSystem.name + "_eq" eq_job_id, tmp_jobname, in_simSystem = chain_submission( simSystem=in_simSystem, out_dir_path=out_dir_path, out_prefix=tmp_outprefix, jobname=tmp_jobname, chain_job_repetitions=equilibration_run_num, worker_script=workerScript.__file__, job_submission_system=submission_system, start_run_index=1, prefix_command="", previous_job_ID=previous_job_ID, work_dir=_work_dir, initialize_first_run=initialize_first_run, reinitialize_every_run=reinitialize_every_run, verbose=job_verb, ) # MD tmp_outprefix = out_prefix tmp_jobname = in_simSystem.name previous_job_ID = previous_job_ID if (eq_job_id is None) else eq_job_id previous_job_ID, tmp_jobname, in_simSystem = chain_submission( simSystem=in_simSystem, out_dir_path=out_dir_path, out_prefix=tmp_outprefix, jobname=tmp_jobname, chain_job_repetitions=equilibration_run_num + simulation_run_num, start_run_index=equilibration_run_num + 1, worker_script=workerScript.__file__, job_submission_system=submission_system, prefix_command="", previous_job_ID=previous_job_ID, work_dir=_work_dir, initialize_first_run=initialize_first_run, reinitialize_every_run=reinitialize_every_run, verbose=job_verb, ) ana_previous_job_ID = previous_job_ID if analysis_script_path is not None: tmp_jobname = in_simSystem.name + "_ana" ana_log = os.path.dirname(analysis_script_path) + "/ana_out.log" if verbose: print(spacer + "\n submit final analysis part \n") if verbose: print(ana_log) if verbose: print(analysis_script_path) sub_job = Submission_job( command="python3 " + analysis_script_path, jobName=tmp_jobname, outLog=ana_log, queue_after_jobID=previous_job_ID, ) ana_previous_job_ID = submission_system.submit_to_queue(sub_job) if verbose: print("ANA jobID: " + str(previous_job_ID)) except Exception as err: print( "#####################################################################################" ) print("\t\tERROR in Submission") print( "#####################################################################################" ) traceback.print_exception(*sys.exc_info()) raise IOError("ERROR in SUBMISSION!") from err # in_simSystem._future_promise = False #reset future promising if necessary return ana_previous_job_ID