dpti package

Subpackages

• dpti.dags package
  • Submodules
  • dpti.dags.dp_ti_gdi module
    • GDIDAGFactory
      • GDIDAGFactory.create_loop_dag()
      • GDIDAGFactory.create_main_dag()
      • GDIDAGFactory.dagargs
      • GDIDAGFactory.default_args
    • GDIWorkflow
      • GDIWorkflow.get_dag_run_state()
      • GDIWorkflow.trigger_loop()
      • GDIWorkflow.wait_until_end()
  • dpti.dags.utils module
    • get_empty_submission()
• dpti.lib package
  • Submodules
  • dpti.lib.RemoteJob module
    • CloudMachineJob
      • CloudMachineJob.check_status()
      • CloudMachineJob.submit()
    • JobStatus
      • JobStatus.finished
      • JobStatus.running
      • JobStatus.terminated
      • JobStatus.unknow
      • JobStatus.unsubmitted
      • JobStatus.waiting
    • PBSJob
      • PBSJob.check_status()
      • PBSJob.submit()
    • RemoteJob
      • RemoteJob.block_call()
      • RemoteJob.block_checkcall()
      • RemoteJob.clean()
      • RemoteJob.download()
      • RemoteJob.get_job_root()
      • RemoteJob.upload()
    • SSHSession
      • SSHSession.close()
      • SSHSession.get_session_root()
      • SSHSession.get_ssh_client()
    • SlurmJob
      • SlurmJob.check_status()
      • SlurmJob.submit()
  • dpti.lib.dump module
    • box2dumpbox()
    • dumpbox2box()
    • get_atype()
    • get_dumpbox()
    • get_natoms()
    • get_natoms_vec()
    • get_natomtypes()
    • get_posi()
    • split_traj()
    • system_data()
  • dpti.lib.lammps module
    • get_last_dump()
    • get_natoms()
    • get_thermo()
    • get_thermo_old()
  • dpti.lib.lmp module
    • box2lmpbox()
    • from_system_data()
    • get_atoms()
    • get_atype()
    • get_id()
    • get_lmpbox()
    • get_natoms()
    • get_natoms_vec()
    • get_natomtypes()
    • get_posi()
    • lmpbox2box()
    • system_data()
    • to_system_data()
  • dpti.lib.ovito_file_convert module
  • dpti.lib.utils module
    • block_avg()
    • compute_nrefine()
    • copy_file_list()
    • create_dict_not_empty_key()
    • create_path()
    • cvt_conf()
    • get_file_md5()
    • get_first_matched_key_from_dict()
    • get_task_file_abspath()
    • integrate()
    • integrate_range()
    • integrate_range_hti()
    • integrate_range_simpson()
    • integrate_range_trapezoidal()
    • integrate_simpson()
    • integrate_simpson_nonuniform()
    • integrate_sys_err()
    • integrate_sys_err_simpson()
    • integrate_sys_err_trapezoidal()
    • integrate_trapezoidal()
    • interval_sys_err_trapezoidal()
    • link_file_in_dict()
    • make_iter_name()
    • parse_seq()
    • relative_link_file()
  • dpti.lib.vasp module
    • perturb_xz()
    • poscar_natoms()
    • poscar_scale()
    • poscar_vol()
    • reciprocal_box()
    • regulate_poscar()
    • sort_poscar()
  • dpti.lib.water module
    • add_bonds()
    • compute_bonds()
    • dist_via_oh_list()
    • min_ho()
    • min_oh_list()
    • min_oho()
    • min_oo()
    • posi_diff()
    • posi_shift()

Submodules

dpti.einstein module

dpti.einstein.compute_lambda(temp, mass)

dpti.einstein.compute_spring(temp, spring_k)

dpti.einstein.free_energy(job)

dpti.einstein.frenkel(job)

dpti.einstein.ideal_gas_fe(job)

dpti.equi module

dpti.equi.add_module_subparsers(main_subparsers)

dpti.equi.add_subparsers(module_subparsers)

dpti.equi.exec_args(args, parser)

dpti.equi.extract(job_dir, output)

dpti.equi.gen_equi_dump_settings(if_dump_avg_posi)

dpti.equi.gen_equi_ensemble_settings(ens)

dpti.equi.gen_equi_force_field(model, if_meam=False, meam_model=None)

dpti.equi.gen_equi_header(nsteps, thermo_freq, dump_freq, mass_map, temp, tau_t, tau_p, equi_conf, pres=None)

dpti.equi.gen_equi_lammps_input(nsteps, thermo_freq, dump_freq, mass_map, temp, tau_t, tau_p, equi_conf, model, timestep, if_dump_avg_posi, ens, pres=None, if_meam=False, meam_model=None)

dpti.equi.gen_equi_thermo_settings(timestep)

dpti.equi.handle_compute(args)

dpti.equi.handle_extract(args)

dpti.equi.handle_gen(args)

dpti.equi.handle_run(args)

dpti.equi.handle_stat_bond(args)

dpti.equi.make_task(iter_name, jdata, ens=None, temp=None, pres=None, if_dump_avg_posi=None, npt_dir=None)

dpti.equi.npt_equi_conf(npt_dir)

dpti.equi.post_task(iter_name, natoms=None, is_water=None)

dpti.equi.run_task(task_name, machine_file)

dpti.equi.water_bond(iter_name, skip=1)

dpti.gdi module

class dpti.gdi.GibbsDuhemFunc(jdata, mdata, task_path, inte_dir, pref=1.0, natoms=None, shift=[0, 0], verbose=False, if_meam=False, meam_model=None, workflow=None)

Bases: object

Methods

__call__(x, y)

Call self as a function.

dpti.gdi.add_module_subparsers(main_subparsers)

dpti.gdi.gdi_main_loop(jdata, mdata, gdidata_dict={}, gdidata_cli={}, workflow=None)

dpti.gdi.handle_gdi(args)

dpti.gdi.make_dpdt(temp, pres, inte_dir, task_path, mdata, natoms=None, shift=[0, 0], verbose=False, if_meam=False, meam_model=None, workflow=None)

dpti.hti module

dpti.hti.add_module_subparsers(main_subparsers)

dpti.hti.compute_task(job, free_energy_type='helmholtz', method='inte', scheme='simpson', manual_pv=None, manual_pv_err=None)

dpti.hti.handle_compute(args)

dpti.hti.handle_gen(args)

dpti.hti.handle_run(args)

dpti.hti.hti_phase_trans_analyze(job, jdata=None)

dpti.hti.make_iter_name(iter_index)

dpti.hti.make_tasks(iter_name, jdata, ref='einstein', switch='one-step', if_meam=None)

dpti.hti.post_tasks(iter_name, jdata, natoms=None, method='inte', scheme='s')

dpti.hti.print_thermo_info(info)

dpti.hti.refine_task(from_task, to_task, err, print_ref=False, if_meam=None, meam_model=None)

dpti.hti.run_task(task_dir, machine_file, task_name, no_dp=False)

dpti.hti_ice module

dpti.hti_ice.add_module_subparsers(main_subparsers)

dpti.hti_ice.add_subparsers(module_subparsers)

dpti.hti_ice.exec_args(args, parser)

dpti.hti_ice.handle_compute(args)

dpti.hti_ice.handle_gen(args)

dpti.hti_ice.handle_refine(args)

dpti.hti_ice.handle_run(args)

dpti.hti_liq module

dpti.hti_liq.add_module_subparsers(main_subparsers)

dpti.hti_liq.compute_task(job, free_energy_type='helmholtz', scheme='simpson', manual_pv=None, manual_pv_err=None)

dpti.hti_liq.handle_compute(args)

dpti.hti_liq.handle_gen(args)

dpti.hti_liq.handle_run(args)

dpti.hti_liq.make_iter_name(iter_index)

dpti.hti_liq.make_tasks(iter_name, jdata, if_meam=None)

dpti.hti_liq.post_tasks(iter_name, natoms)

dpti.hti_water module

dpti.hti_water.add_module_subparsers(main_subparsers)

dpti.hti_water.add_subparsers(module_subparsers)

dpti.hti_water.compute_ideal_mol(iter_name)

dpti.hti_water.exec_args(args, parser)

dpti.hti_water.handle_compute(args)

dpti.hti_water.handle_gen(args)

dpti.hti_water.handle_refine(args)

dpti.hti_water.handle_run(args)

dpti.hti_water.make_tasks(iter_name, jdata)

dpti.hti_water.post_tasks(iter_name, natoms, method='inte', scheme='s')

dpti.hti_water.refine_tasks(from_task, to_task, err)

dpti.hti_water.spring_inte(temp, kk, r0)

dpti.main module

dpti.main.create_parser()

dpti.main.main()

dpti.mti module

dpti.mti.add_module_subparsers(main_subparsers)

dpti.mti.add_subparsers(module_subparsers)

dpti.mti.exec_args(args, parser)

dpti.mti.handle_compute(args)

dpti.mti.handle_gen(args)

dpti.mti.handle_run(args)

dpti.mti.make_tasks(iter_name, jdata)

dpti.mti.post_tasks(iter_name, jdata, natoms_mol=None)

dpti.mti.run_task(task_name, jdata, machine_file)

dpti.old_equi module

dpti.old_equi.extract(job_dir, output)

dpti.old_equi.make_task(iter_name, jdata, ens=None, temp=None, pres=None, avg_posi=None, npt_conf=None, if_meam=None)

dpti.old_equi.npt_equi_conf(npt_name)

dpti.old_equi.post_task(iter_name, natoms=None, is_water=False)

dpti.old_equi.water_bond(iter_name, skip=1)

dpti.relax module

dpti.ti module

dpti.ti.add_module_subparsers(main_subparsers)

dpti.ti.compute_task(job, inte_method, Eo, Eo_err, To, scheme='simpson')

dpti.ti.handle_compute(args)

dpti.ti.handle_gen(args)

dpti.ti.handle_refine(args)

dpti.ti.handle_run(args)

dpti.ti.make_iter_name(iter_index)

dpti.ti.make_tasks(iter_name, jdata, if_meam=None)

dpti.ti.parse_seq_ginv(seq)

dpti.ti.post_tasks(iter_name, jdata, Eo, Eo_err=0, To=None, natoms=None, scheme='simpson', shift=0.0)

dpti.ti.post_tasks_mbar(iter_name, jdata, Eo, natoms=None)

dpti.ti.refine_task(from_task, to_task, err)

dpti.ti.run_task(task_name, machine_file)

dpti.ti_water module

dpti.ti_water.add_module_subparsers(main_subparsers)

dpti.ti_water.add_subparsers(module_subparsers)

dpti.ti_water.exec_args(args, parser)

dpti.ti_water.handle_compute(args)

dpti.ti_water.handle_gen(args)

dpti.ti_water.handle_refine(args)

dpti.ti_water.handle_run(args)