def nvtw(num_particles, num_procs, num_equil, num_prod, num_hours, dccb_begin, temperature, mu, steps_per, model):
mc = fst.MakeMonteCarlo()
#mc.set(fst.MakeRandomMT19937(fst.args({"seed": "1633373856"})))
beta = 1./temperature
if model == "lj":
mc.add(fst.MakeConfiguration(fst.args({"cubic_box_length": "8",
"particle_type0": fst.install_dir() + "/forcefield/lj.fstprt"})))
mc.add(fst.MakePotential(fst.MakeLennardJones()))
mc.add(fst.MakePotential(fst.MakeLongRangeCorrections()))
elif model == "sqw":
config = fst.MakeConfiguration(fst.args({"cubic_box_length": "8", "particle_type0": fst.install_dir() + "/forcefield/atom.fstprt"}))
config.set_model_param("cutoff", 0, 1.5)
mc.add(config)
mc.add(fst.MakePotential(fst.MakeSquareWell()))
elif model == "spce":
mc.add(fst.MakeConfiguration(fst.args({"cubic_box_length": "20",
"particle_type0": fst.install_dir() + "/forcefield/spce.fstprt"})))
mc.add(fst.MakePotential(fst.MakeEwald(fst.args({"alpha": str(5.6/20),
"kmax_squared": "38"}))))
mc.add(fst.MakePotential(fst.MakeModelTwoBodyFactory(fst.MakeLennardJones(), fst.MakeChargeScreened()),
fst.args({"table_size": "1e6"})))
mc.add(fst.MakePotential(fst.MakeChargeScreenedIntra(), fst.MakeVisitModelBond()))
mc.add(fst.MakePotential(fst.MakeChargeSelf()))
mc.add(fst.MakePotential(fst.MakeLongRangeCorrections()))
beta = 1./fst.kelvin2kJpermol(temperature, mc.configuration())
else:
assert(False) # model not recognized
# fill box with larger temperature and mu
mc.set(fst.MakeThermoParams(fst.args({"beta": "0.01", "chemical_potential": "10"})))
mc.set(fst.MakeMetropolis());
#trial_args = {"particle_type": "0", "site": "0", "reference_index": ref, "num_steps": num_steps}
mc.add(fst.MakeTrialTranslate(fst.args({"tunable_param": "0.1"})))
#mc.add(fst.MakeTrialGrow(fst.ArgsVector([dict({"translate": "true", "tunable_param": "0.1"}, **trial_args)])))
mc.add(fst.MakeTrialAdd(fst.args({"particle_type": "0", "weight": "4"})))
mc.add(fst.MakeTune(fst.args({"steps_per": steps_per})))
mc.add(fst.MakeCheckEnergy(fst.args({"steps_per": steps_per, "tolerance": "0.0001"})))
mc.add(fst.MakeLogAndMovie(fst.args({"steps_per": steps_per,
"file_name": model + str(num_particles)})))
mc.set(fst.MakeCheckpoint(fst.args({"file_name": "checkpoint" + str(num_particles) + ".fst",
"num_hours": str(0.1*num_procs*num_hours),
"num_hours_terminate": str(0.9*num_procs*num_hours)})))
mc.run(fst.MakeRun(fst.args({"until_num_particles": str(num_particles)})))
mc.run(fst.MakeRemoveTrial(fst.args({"name": "TrialAdd"})))
# nvt equilibration at desired temperature
mc.set(fst.MakeThermoParams(fst.args({"beta": str(beta),
"chemical_potential": str(mu)})))
mc.attempt(int((num_particles+1)*num_equil))
mc.run(fst.MakeRemoveModify(fst.args({"name": "Tune"})))
mc.add(fst.MakeTrialTransfer(fst.args({"particle_type": "0", "weight": "4"})))
#mc.add(fst.MakeTrialGrow(fst.ArgsVector([dict({"transfer": "true", "weight": "4"}, **trial_args)])))
mc.set(fst.MakeFlatHistogram(fst.args({
"Macrostate": "MacrostateNumParticles", "width": "1", "max": str(num_particles), "min": str(num_particles),
"Bias": "TransitionMatrix", "min_sweeps": "1"})))
mc.add(fst.MakeEnergy(fst.args({"steps_per_write": steps_per,
"file_name": "en" + str(num_particles) + ".txt"})))
mc.add(fst.MakeCriteriaWriter(fst.args({"steps_per": steps_per,
"file_name": "crit" + str(num_particles) + ".txt"})))
mc.attempt(int((num_particles+1)*num_prod))
def lj_system(box_length):
system = feasst.System()
config = feasst.Configuration(
feasst.Domain(feasst.args({"cubic_box_length": str(box_length)})),
feasst.args({"particle_type": feasst.install_dir() + "/forcefield/lj.fstprt"}))
config.set_model_param("cutoff", 0, args.cutoff)
system.add(config)
system.add(feasst.Potential(feasst.MakeLennardJones()))
return system
def system(config=None,
box_length=8.109613,
alphaL=6.870983963962610000,
kmax_squared=38,
rcut=4.891304347826090):
if not config:
config = feasst.Configuration(
feasst.MakeDomain(
feasst.args({"cubic_box_length": str(box_length)})),
feasst.args({
"particle_type0":
feasst.install_dir() +
"/plugin/ewald/forcefield/data.rpm_plus",
"particle_type1":
feasst.install_dir() +
"/plugin/ewald/forcefield/data.rpm_minus"
}))
config.set_model_param("cutoff", 0, rcut)
config.set_model_param("cutoff", 1, rcut)
system = feasst.System()
system.add(config)
system.add(
feasst.Potential(
feasst.MakeEwald(
feasst.args({
"kmax_squared":
str(kmax_squared),
"alpha":
str(alphaL /
system.configuration().domain().min_side_length())
}))))
# Unfortunatley, swig isn't accepting the below method of constructing a two body factory
# system.add(feasst.Potential(feasst.MakeModelTwoBodyFactory(
# feasst.ModelTwoBodyVector([feasst.MakeLennardJones(), feasst.MakeChargeScreened()]))))
two = feasst.MakeModelTwoBodyFactory()
two.add(feasst.MakeHardSphere())
two.add(feasst.MakeChargeScreened())
system.add(feasst.Potential(two))
system.add(feasst.Potential(feasst.MakeChargeSelf()))
# system.precompute()
return system
def lj_system(box_length, cutoff):
system = feasst.System()
config = feasst.Configuration(
feasst.MakeDomain(feasst.args({"cubic_box_length": str(box_length)})),
feasst.args(
{"particle_type": feasst.install_dir() + "/forcefield/lj.fstprt"}))
config.set_model_param("cutoff", 0, cutoff)
system.add(config)
system.add(feasst.Potential(feasst.MakeLennardJones()))
if system.configuration().domain().is_cell_enabled():
#system.add_to_optimized(feasst.Potential(feasst.MakeLennardJones(), feasst.MakeVisitModelCell()))
system.add_to_reference(
feasst.Potential(feasst.MakeHardSphere(),
feasst.MakeVisitModelCell()))
return system
def run_fst(params):
with open("launch.txt", "w") as myfile:
myfile.write("""
Configuration {config_params}
Potential Model LennardJones
Potential VisitModel LongRangeCorrections
ThermoParams
Metropolis
Checkpoint file_name checkpoint.fst
WriteCheckpoint
""".format(**params))
syscode = subprocess.call(fst.install_dir() +
"/build/bin/fst < launch.txt > launch.log",
shell=True,
executable='/bin/bash')
if syscode > 0: sys.exit(1)
def configuration(box_length=8, forcefield='data.lj', num=0):
"""Return an LJ configuration with cubic box and (optionally) cell list.
box_length -- the length of the cubic peroidic boundary conditions
forcefield -- the file describing the particle
num -- the number of particles of the first type to add.
"""
config = feasst.Configuration(
feasst.MakeDomain(
feasst.args({
"cubic_box_length": str(box_length),
"init_cells": "3"
})), # optionally attempt to create a cell list
feasst.args({
"particle_type":
feasst.install_dir() + '/forcefield/' + forcefield
}))
for _ in range(num):
config.add_particle_of_type(0)
return config
import sys
import feasst
sys.path.insert(0, feasst.install_dir() + '/plugin/system/tutorial/')
import lj_system
sys.path.insert(0, feasst.install_dir() + '/plugin/monte_carlo/tutorial/')
import analyze
sys.path.insert(0, feasst.install_dir() + '/plugin/flat_histogram/tutorial/')
import fh
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--nopara", help="disable prefetch", dest='nopara', action='store_true')
parser.set_defaults(nopara=False)
parser.add_argument("--nofh", help="disable fh", dest='nofh', action='store_true')
parser.set_defaults(nofh=False)
parser.add_argument("--nobalance", help="disable load_balance", dest='nobalance', action='store_true')
parser.set_defaults(nobalance=False)
parser.add_argument("--cutoff", type=float, default=4.)
parser.add_argument("--target_prob", type=float, default=0.2)
parser.add_argument("--rel_disp_prob", type=float, default=5)
parser.add_argument("--max_move", type=float, default=0.185)
parser.add_argument("--density", type=float, default=0.85)
parser.add_argument("--temperature", type=float, default=0.88)
parser.add_argument("--chemical_potential", type=float, default=-2.35)
parser.add_argument("--window_half_width", type=int, default=10)
parser.add_argument("--iterations", type=int, default=20)
args = parser.parse_args()
print(args)
print(feasst.install_dir())
assert(feasst.install_dir() == '/home/hwh/gcfetch/feasst')
import sys
import feasst as fst
sys.path.insert(0, fst.install_dir() + '/plugin/system/tutorial/')
import lj_system
sys.path.insert(0, fst.install_dir() + '/plugin/monte_carlo/tutorial/')
import analyze
def criteria_flathist(
temperature=1.5,
chemical_potential=-2.352321,
macro_min=0, # minimum macrostate
macro_max=370, # maximum macrostate
tmmc=True, # use Transition-Matrix (TM) if true, else Wang-Landau (WL)
iterations=20): # number of sweeps (TM) or flatness (WL)
"""Return a flat histogram acceptance criteria with number of particles as the macrostate"""
if tmmc:
bias = fst.MakeTransitionMatrix(
fst.args({"min_sweeps": str(iterations)}))
else:
bias = fst.MakeWangLandau(fst.args({"min_flatness": str(iterations)}))
return fst.MakeFlatHistogram(
fst.MakeMacrostateNumParticles(
fst.Histogram(
fst.args({
"width": "1",
"min": str(macro_min),
"max": str(macro_max)
}))), bias,
fst.args({
"beta": str(1. / temperature),
type=int,
help="SLURM job array index",
default=0)
parser.add_argument("--seed",
type=str,
help="random number generator seed",
default="time")
parser.add_argument("--density",
type=float,
help="number density, num/volume",
default=0.776)
parser.add_argument("--num", type=int, help="number of particles", default=500)
parser.add_argument("--data",
type=str,
help="LMP forcefield data file",
default=fst.install_dir() + "/forcefield/lj.fstprt")
parser.add_argument("--beta",
type=float,
help="inverse temperature",
default=1 / 0.9)
parser.add_argument("--equilibration_trials",
type=int,
help="number of trials for equilibration",
default=int(5e7))
parser.add_argument(
"--trials",
type=int,
help="total number of trials (equilibration and production)",
default=int(3e8))
parser.add_argument("--num_hours",
type=float,
def test_srsw_alt(self,
num_particles=500,
density=0.001,
steps_per=1e5,
beta=1. / 0.9,
fstprt=fst.install_dir() + "/forcefield/lj.fstprt",
num_equil=1e7,
num_prod=1e7):
"""Compare with the reported average energy from the NIST SRSW.
https://mmlapps.nist.gov/srs/LJ_PURE/mc.htm
https://www.nist.gov/programs-projects/nist-standard-reference-simulation-website
num_particles -- number of LJ particles
density -- number density
steps_per -- steps between each Anaylze/Modify
"""
params = {"box_length": (num_particles / density)**(1. / 3.)}
params = dict(locals(), **params)
with open('tutorial_1_lj_nvt.txt', 'w') as fsttxt:
fsttxt.write("""
Checkpoint file_name checkpoint.fst
RandomMT19937 seed time
Configuration cubic_box_length {box_length} particle_type {fstprt}
Potential Model LennardJones
Potential VisitModel LongRangeCorrections
ThermoParams beta 0.1 chemical_potential 10
Metropolis
TrialTranslate tunable_param 2. tunable_target_acceptance 0.2
TrialAdd particle_type 0
Run until_num_particles {num_particles}
RemoveTrial name TrialAdd
ThermoParams beta {beta}
Tune steps_per {steps_per}
CheckEnergy steps_per {steps_per} tolerance 1e-8
# equilibrate
Run num_attempts {num_equil}
RemoveModify name Tune
# production analysis and output
Log steps_per {steps_per} file_name lj.txt
Energy steps_per_write {steps_per} file_name en.txt
# Run num_attempts {num_prod} # optionally run production here instead of python
WriteCheckpoint
""".format(**params))
import pyfeasst
syscode = subprocess.call(
fst.install_dir() +
"/build/bin/fst < tutorial_1_lj_nvt.txt >> launch.log",
shell=True,
executable='/bin/bash')
if syscode > 0: sys.exit(1)
mc = fst.MonteCarlo().deserialize(
pyfeasst.read_checkpoint('checkpoint.fst'))
# run production trials with an alternative running average of the energy
# this demonstrates custom on-the-fly analysis in python scripts.
energy_alt = fst.Accumulator()
for _ in range(int(params["num_prod"])):
mc.attempt(1)
energy_alt.accumulate(mc.criteria().current_energy())
energy = fst.SeekAnalyze().reference("Energy", mc).accumulator()
# test that the two methods for computing the energy give the same result
self.assertAlmostEqual(energy.average(),
energy_alt.average(),
delta=1e-6)
# test the average against the NIST SRSW
stdev = (energy.block_stdev()**2 + (1.89E-05)**2)**(1. / 2.)
self.assertAlmostEqual(-9.9165E-03 * num_particles,
energy.average(),
delta=2.576 * stdev)
parser.add_argument("--max_particles",
type=int,
help="maximum number of particles",
default=270)
parser.add_argument("--cubic_box_length",
type=float,
help="cubic_box_length",
default=8)
parser.add_argument("--temperature",
type=float,
help="temperature",
default=0.3)
parser.add_argument("--particle",
type=str,
help="fstprt file that describes trimer",
default=fst.install_dir() +
"/forcefield/trimer_0.4L.fstprt")
parser.add_argument("--mu", type=float, help="chemical potential", default=-1)
parser.add_argument("--min_sweeps",
type=int,
help="minimum number of TM sweeps before termination",
default=100)
args = parser.parse_args()
print("args:", args)
def config():
config = fst.MakeConfiguration(
fst.args({
"cubic_box_length": str(args.cubic_box_length),
"particle_type": args.particle
def mc(thread, mn, mx):
steps_per = str(int(1e6))
mc = fst.MakeMonteCarlo()
mc.add(
fst.MakeConfiguration(
fst.args({
"cubic_box_length":
str(args.cubic_box_length),
"particle_type0":
fst.install_dir() + "/forcefield/hard_sphere.fstprt"
})))
mc.add(fst.MakePotential(fst.MakeHardSphere()))
# mc.add_to_optimized(fst.MakePotential(fst.MakeHardSphere(), fst.MakeVisitModelCell(fst.args({"min_length": "1"}))))
mc.set(
fst.MakeThermoParams(
fst.args({
"beta": "1",
"chemical_potential": str(args.mu)
})))
mc.set(
fst.MakeFlatHistogram(
fst.MakeMacrostateNumParticles(
fst.Histogram(
fst.args({
"width": "1",
"max": str(mx),
"min": str(mn)
}))),
# fst.MakeTransitionMatrix(fst.args({"min_sweeps": str(args.min_sweeps)})),
fst.MakeWLTM(
fst.args({
"collect_flatness": "18",
"min_flatness": "22",
"min_sweeps": str(args.min_sweeps)
}))))
mc.add(
fst.MakeTrialTranslate(
fst.args({
"new_only": "true",
"weight": "1.",
"tunable_param": "1."
})))
mc.add(
fst.MakeTrialTransfer(fst.args({
"weight": "4",
"particle_type": "0"
})))
mc.add(
fst.MakeCheckEnergy(
fst.args({
"steps_per": steps_per,
"tolerance": "0.0001"
})))
mc.add(
fst.MakeTune(
fst.args({
"steps_per": steps_per,
"stop_after_phase": "0"
})))
mc.add(
fst.MakeLogAndMovie(
fst.args({
"steps_per": steps_per,
"file_name": "clones" + str(thread),
"file_name_append_phase": "True"
})))
mc.add(
fst.MakePairDistribution(
fst.args({
"steps_per_update": "1000",
"steps_per_write": steps_per,
"dr": "0.025",
"file_name": "gr" + str(thread) + ".txt",
"file_name_append_phase": "True",
"start_after_phase": "0",
"multistate": "True",
"multistate_aggregate": "False"
})))
mc.add(fst.MakeCriteriaUpdater(fst.args({"steps_per": steps_per})))
mc.add(
fst.MakeCriteriaWriter(
fst.args({
"steps_per": steps_per,
"file_name": "clones" + str(thread) + "_crit.txt",
"file_name_append_phase": "True"
})))
mc.set(
fst.MakeCheckpoint(
fst.args({
"file_name":
"checkpoint" + str(thread) + ".fst",
"num_hours":
str(0.1 * args.num_procs * args.num_hours),
"num_hours_terminate":
str(0.9 * args.num_procs * args.num_hours)
})))
return mc
def mc(thread, mn, mx):
steps_per = int(1e4)
mc = fst.MakeMonteCarlo()
mc.add(
fst.MakeConfiguration(
fst.args({
"cubic_box_length":
"12",
"particle_type0":
fst.install_dir() +
"/plugin/charge/forcefield/rpm_plus.fstprt",
"particle_type1":
fst.install_dir() +
"/plugin/charge/forcefield/rpm_minus.fstprt",
"cutoff":
"4.891304347826090",
"charge0":
str(1. / math.sqrt(fst.CODATA2018().charge_conversion())),
"charge1":
str(-1. / math.sqrt(fst.CODATA2018().charge_conversion()))
})))
mc.add(
fst.MakePotential(
fst.MakeEwald(
fst.args({
"alpha": str(6.87098396396261 / 12),
"kmax_squared": "38"
}))))
mc.add(
fst.MakePotential(
fst.MakeModelTwoBodyFactory(fst.MakeHardSphere(),
fst.MakeChargeScreened()),
fst.args({"table_size": "1e6"})))
mc.add(fst.MakePotential(fst.MakeChargeSelf()))
num_steps = "1"
ref = "-1"
if mx >= args.dccb_begin:
mc.run(
fst.MakeAddReference(
fst.args({
"potential_index": "1",
"cutoff": "1",
"use_cell": "true"
})))
ref = "0"
num_steps = "4"
beta = 1. / args.temperature
mc.set(
fst.MakeThermoParams(
fst.args({
"beta": str(beta),
"chemical_potential0": str(args.beta_mu / beta),
"chemical_potential1": str(args.beta_mu / beta)
})))
mc.set(
fst.MakeFlatHistogram(
fst.MakeMacrostateNumParticles(
fst.Histogram(
fst.args({
"width": "1",
"max": str(mx),
"min": str(mn)
}))),
# fst.MakeTransitionMatrix(fst.args({"min_sweeps": str(args.min_sweeps)})),
fst.MakeWLTM(
fst.args({
"collect_flatness": "18",
"min_flatness": "22",
"min_sweeps": str(args.min_sweeps)
})),
fst.MakeAEqualB(fst.args({"extra_A": "1"}))))
mc.add(
fst.MakeTrialTranslate(
fst.args({
"weight": "1.",
"tunable_param": "1."
})))
for particle_type in range(mc.configuration().num_particle_types()):
mc.add(
fst.MakeTrialTransfer(
fst.args({
"weight": "4",
"particle_type": str(particle_type),
"reference_index": ref,
"num_steps": num_steps
})))
mc.add(
fst.MakeCheckEnergy(
fst.args({
"steps_per": str(steps_per),
"tolerance": "0.0001"
})))
mc.add(
fst.MakeTune(
fst.args({
"steps_per": str(steps_per),
"stop_after_phase": "0"
})))
mc.add(
fst.MakeLogAndMovie(
fst.args({
"steps_per": str(steps_per),
"file_name": "clones" + str(thread),
"file_name_append_phase": "True"
})))
mc.add(
fst.MakeEnergy(
fst.args({
"steps_per_write": str(steps_per),
"file_name": "en" + str(thread) + ".txt.",
"file_name_append_phase": "True",
"start_after_phase": "0",
"multistate": "True"
})))
mc.add(fst.MakeCriteriaUpdater(fst.args({"steps_per": str(steps_per)})))
mc.add(
fst.MakeCriteriaWriter(
fst.args({
"steps_per": str(steps_per),
"file_name": "clones" + str(thread) + "_crit.txt",
"file_name_append_phase": "True"
})))
mc.set(
fst.MakeCheckpoint(
fst.args({
"file_name":
"checkpoint" + str(thread) + ".fst",
"num_hours":
str(0.1 * args.num_procs * args.num_hours),
"num_hours_terminate":
str(0.9 * args.num_procs * args.num_hours)
})))
return mc
def mc(thread, mn, mx):
steps_per = str(int(1e5))
mc = fst.MakeMonteCarlo()
#mc.set(fst.MakeRandomMT19937(fst.args({"seed": "12345"})))
#mc.set(fst.MakeRandomMT19937(fst.args({"seed": "1634926410"})))
chi = 0.7 # patch coverage
patch_angle = 2 * math.asin(math.sqrt(chi / 2)) * 180 / math.pi
print('patch_angle', patch_angle)
mc = fst.MonteCarlo()
config = fst.MakeConfiguration(
fst.args({
"cubic_box_length":
"8",
"particle_type0":
fst.install_dir() +
"/plugin/patch/forcefield/two_patch_linear.fstprt"
}))
config.add(fst.MakeGroup(fst.args({"site_type0": "0"})))
mc.add(config)
mc.add(
fst.MakePotential(
fst.MakeHardSphere(),
fst.MakeVisitModelCell(
fst.args({
"min_length": "1",
"cell_group": "1"
})), fst.args({"group_index": "1"})))
patch = fst.MakeVisitModelInnerPatch(
fst.args({"patch_degrees_of_type1": str(patch_angle)}))
mc.add(
fst.MakePotential(
fst.MakeSquareWell(),
fst.MakeVisitModel(patch),
#fst.MakeVisitModelCell(patch, fst.args({"min_length": "1.5", "cell_group": "1"})),
fst.args({"group_index": "1"})))
mc.set(
fst.MakeThermoParams(
fst.args({
"beta": str(1. / args.temperature),
"chemical_potential": str(args.mu)
})))
mc.set(
fst.MakeFlatHistogram(
fst.MakeMacrostateNumParticles(
fst.Histogram(
fst.args({
"width": "1",
"max": str(mx),
"min": str(mn)
}))),
# fst.MakeTransitionMatrix(fst.args({"min_sweeps": str(args.min_sweeps)})),
fst.MakeWLTM(
fst.args({
"collect_flatness": "18",
"min_flatness": "22",
"min_sweeps": str(args.min_sweeps)
}))))
mc.add(
fst.MakeTrialTranslate(
fst.args({
"weight": "0.5",
"tunable_param": "0.1"
})))
mc.add(
fst.MakeTrialRotate(fst.args({
"weight": "0.5",
"tunable_param": "20."
})))
mc.add(
fst.MakeTrialTransfer(fst.args({
"weight": "4",
"particle_type": "0"
})))
# mc.add(fst.MakeTrialGrow(fst.ArgsVector([{"translate": "true", "site": "0", "tunable_param": "1"}]),
# {"reference_index": ref, "num_steps": num_steps}))
# mc.add(fst.MakeTrialGrow(fst.ArgsVector([{"transfer": "true", "site": "0", "weight": "4"}]),
# {"reference_index": ref, "num_steps": num_steps}))
mc.add(
fst.MakeCheckEnergy(
fst.args({
"steps_per": steps_per,
"tolerance": "0.0001"
})))
mc.add(
fst.MakeTune(
fst.args({
"steps_per": steps_per,
"stop_after_phase": "0"
})))
mc.add(
fst.MakeLog(
fst.args({
"steps_per": steps_per,
"file_name": "clones" + str(thread) + ".txt",
"file_name_append_phase": "True"
})))
mc.add(
fst.MakeMoviePatch(
fst.args({
"steps_per": steps_per,
"file_name": "clones" + str(thread) + ".xyz",
"file_name_append_phase": "True"
})))
mc.add(
fst.MakeEnergy(
fst.args({
"steps_per_write": steps_per,
"file_name": "en" + str(thread) + ".txt",
"file_name_append_phase": "True",
"start_after_phase": "0",
"multistate": "True"
})))
mc.add(fst.MakeCriteriaUpdater(fst.args({"steps_per": steps_per})))
mc.add(
fst.MakeCriteriaWriter(
fst.args({
"steps_per": steps_per,
"file_name": "clones" + str(thread) + "_crit.txt",
"file_name_append_phase": "True"
})))
mc.set(
fst.MakeCheckpoint(
fst.args({
"file_name":
"checkpoint" + str(thread) + ".fst",
"num_hours":
str(0.1 * args.num_procs * args.num_hours),
"num_hours_terminate":
str(0.9 * args.num_procs * args.num_hours)
})))
return mc
import feasst
import pyfeasst
def run_file(filename):
if 'checkpoint' not in filename.name:
if 'build' not in str(filename.parent):
with pyfeasst.cd(filename.parent):
print("Running:", filename, "in", filename.parent)
pyfeasst.bash_command(
"rm tutorial_failures.txt tutorial_log.txt")
pyfeasst.bash_command(
"jupyter nbconvert --to notebook --inplace --ExecutePreprocessor.timeout=10000 --execute "
+ str(filename) +
" > tutorial_log.txt 2>&1; grep \"Error\|Assertion\" tutorial_log.txt >> tutorial_failures.txt"
)
pyfeasst.bash_command("grep \"FAILED (fa\" " + str(filename) +
" >> tutorial_failures.txt")
pyfeasst.bash_command("grep \"Error\" " + str(filename) +
" >> tutorial_failures.txt")
pyfeasst.bash_command("grep \"ERROR\" " + str(filename) +
" >> tutorial_failures.txt")
pyfeasst.bash_command("grep \"feasst::CustomException\" " +
str(filename) +
" >> tutorial_failures.txt")
#for filename in Path(feasst.install_dir()).rglob('*.ipynb'): run_file(filename)
pool = multiprocessing.Pool(4)
zip(pool.map(run_file, Path(feasst.install_dir()).rglob('*.ipynb')))
import sys
import feasst
sys.path.insert(0, feasst.install_dir() + '/plugin/system/tutorial/')
import lj_system
sys.path.insert(0, feasst.install_dir() + '/plugin/monte_carlo/tutorial/')
import analyze
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--nopipe",
help="disable pipeline",
dest='nopipe',
action='store_true')
parser.set_defaults(nopipe=False)
parser.add_argument("--cutoff", type=float)
parser.add_argument("--target_prob", type=float)
parser.add_argument("--max_move", type=float)
args = parser.parse_args()
print(args)
# assert(feasst.install_dir() == '/home/local/NIST/hwh/feasst1.0')
# assert(feasst.install_dir() == '/home/local/NIST/hwh/msd2/feasst')
assert (feasst.install_dir() == '/home/hwh/msd4/feasst')
#accept_to_param={
# #0.75: 0.04,
# #0.5: 0.085,
# #0.45: 0.099,
# #0.4: 0.111,
# 0.35: 0.125,
# #0.3: 0.14,
import feasst
monte_carlo = feasst.MonteCarlo()
monte_carlo.set(feasst.MakeRandomMT19937(feasst.args({"seed": "time"})))
monte_carlo.add(
feasst.Configuration(
feasst.MakeDomain(feasst.args({"cubic_box_length": "8"})),
feasst.args(
{"particle_type": feasst.install_dir() + "/forcefield/data.lj"})))
monte_carlo.add(feasst.Potential(feasst.MakeLennardJones()))
monte_carlo.add(feasst.Potential(feasst.MakeLongRangeCorrections()))
monte_carlo.add(feasst.MakeMetropolis(feasst.args({"beta": "1.5"})))
monte_carlo.add(
feasst.MakeTrialTranslate(
feasst.args({
"tunable_param": "2.",
"tunable_target_acceptance": "0.2"
})))
steps_per = int(1e3)
monte_carlo.add(feasst.MakeTuner(feasst.args({"steps_per": str(steps_per)})))
feasst.SeekNumParticles(50)\
.with_metropolis(feasst.args({"beta": "0.1", "chemical_potential": "10"}))\
.with_trial_add().run(monte_carlo)
monte_carlo.add(feasst.MakeLog(feasst.args({"steps_per": str(steps_per)})))
monte_carlo.add(
feasst.MakeMovie(
feasst.args({
"steps_per": str(steps_per),
"file_name": "movie.xyz"
})))
monte_carlo.add(
from pathlib import Path
import feasst
import pyfeasst
pyfeasst.bash_command("rm tutorial_failures.txt")
for filename in Path(feasst.install_dir()).rglob('*.ipynb'):
if 'checkpoint' not in filename.name:
with pyfeasst.cd(filename.parent):
print("Running:", filename, "in", filename.parent)
pyfeasst.bash_command(
"jupyter nbconvert --to notebook --inplace --ExecutePreprocessor.timeout=10000 --execute "
+ str(filename))
pyfeasst.bash_command("grep \"FAILED (fa\" " + str(filename) +
" >> tutorial_failures.txt")
pyfeasst.bash_command("grep \"Error\" " + str(filename) +
" >> tutorial_failures.txt")
def mc(thread, mn, mx):
steps_per = int(1e5)
avb, dccb = avb_or_dccb(mx)
mc = fst.MakeMonteCarlo()
mc.add(
fst.MakeConfiguration(
fst.args({
"cubic_box_length":
"20",
"physical_constants":
"CODATA2010",
"particle_type0":
fst.install_dir() + "/forcefield/spce.fstprt"
})))
mc.add(
fst.MakePotential(
fst.MakeEwald(
fst.args({
"alpha": str(5.6 / 20),
"kmax_squared": "38"
}))))
mc.add(
fst.MakePotential(
fst.MakeModelTwoBodyFactory(fst.MakeLennardJones(),
fst.MakeChargeScreened()),
fst.args({"table_size": "1e6"})))
mc.add(
fst.MakePotential(fst.MakeChargeScreenedIntra(),
fst.MakeVisitModelBond()))
mc.add(fst.MakePotential(fst.MakeChargeSelf()))
mc.add(fst.MakePotential(fst.MakeLongRangeCorrections()))
if dccb or avb:
mc.run(
fst.MakeAddReference(
fst.args({
"potential_index": "1",
"cutoff": "3.16555789",
"use_cell": "true"
})))
if avb:
initialize_neighbor_list(mc)
beta = 1. / fst.kelvin2kJpermol(525, mc.configuration())
mc.set(
fst.MakeThermoParams(
fst.args({
"beta": str(beta),
"chemical_potential": str(-8.14 / beta)
})))
mc.set(
fst.MakeFlatHistogram(
fst.MakeMacrostateNumParticles(
fst.Histogram(
fst.args({
"width": "1",
"max": str(mx),
"min": str(mn)
}))),
fst.MakeTransitionMatrix(fst.args({"min_sweeps": "10"}))))
mc.add(
fst.MakeTrialTranslate(
fst.args({
"weight": "1.",
"tunable_param": "1.",
})))
mc.add(
fst.MakeTrialRotate(fst.args({
"weight": "1.",
"tunable_param": "1."
})))
mc.add(
fst.MakeTrialTransfer(fst.args({
"particle_type": "0",
"weight": "4"
})))
regrow1 = [{
"angle": "true",
"mobile_site": "1",
"anchor_site": "0",
"anchor_site2": "2"
}]
regrow2 = [{
"angle": "true",
"mobile_site": "2",
"anchor_site": "0",
"anchor_site2": "1"
}]
regrow12 = [{
"bond": "true",
"mobile_site": "1",
"anchor_site": "0"
}] + copy.deepcopy(regrow2)
regrow21 = [{
"bond": "true",
"mobile_site": "2",
"anchor_site": "0"
}] + copy.deepcopy(regrow1)
if dccb:
grow012 = [{
"transfer": "true",
"site": "0",
"weight": "4"
}] + copy.deepcopy(regrow12)
grow021 = [{
"transfer": "true",
"site": "0",
"weight": "4"
}] + copy.deepcopy(regrow21)
for grow in [regrow1, regrow2]:
grow[0]["weight"] = "0.3"
for grow in [regrow12, regrow21]:
grow[0]["weight"] = "0.2"
for grow in [grow012, grow021, regrow12, regrow21, regrow1, regrow2]:
grow[0]["particle_type"] = "0"
mc.add(
fst.MakeTrialGrow(
fst.ArgsVector(grow),
fst.args({
"reference_index": "0",
"num_steps": "4"
})))
if avb:
for avbtype in ["transfer_avb", "regrow_avb2", "regrow_avb4"]:
avb = [{
avbtype: "true",
"site": "0",
"neighbor_index": "0",
"target_particle_type": "0",
"target_site": "0"
}]
avb_012 = copy.deepcopy(avb) + copy.deepcopy(regrow12)
avb_021 = copy.deepcopy(avb) + copy.deepcopy(regrow21)
for grow in [avb_012, avb_021]:
grow[0]["weight"] = "0.5"
grow[0]["particle_type"] = "0"
mc.add(
fst.MakeTrialGrow(
fst.ArgsVector(grow),
fst.args({
"num_steps": "4",
"reference_index": "0"
})))
mc.add(
fst.MakeCheckEnergyAndTune(
fst.args({
"steps_per": str(steps_per),
"tolerance": "0.0001"
})))
mc.add(
fst.MakeLogAndMovie(
fst.args({
"steps_per": str(steps_per),
"file_name": "clones" + str(thread)
})))
mc.add(fst.MakeCriteriaUpdater(fst.args({"steps_per": str(steps_per)})))
mc.add(
fst.MakeCriteriaWriter(
fst.args({
"steps_per": str(steps_per),
"file_name": "clones" + str(thread) + "_crit.txt"
})))
mc.add(
fst.MakeEnergy(
fst.args({
"steps_per_write": str(steps_per),
"file_name": "en" + str(thread),
"multistate": "true"
})))
mc.set(
fst.MakeCheckpoint(
fst.args({
"file_name":
"checkpoint" + str(thread) + ".fst",
"num_hours_terminate":
str(0.9 * args.num_procs * args.num_hours)
})))
return mc
def mc(thread, mn, mx):
steps_per = str(int(1e6))
mc = fst.MakeMonteCarlo()
mc.add(
fst.MakeConfiguration(
fst.args({
"cubic_box_length":
"8",
"particle_type0":
fst.install_dir() + "/forcefield/lj.fstprt"
})))
mc.add(fst.MakePotential(fst.MakeLennardJones()))
mc.add(fst.MakePotential(fst.MakeLongRangeCorrections()))
trial_args = {"particle_type": "0", "site": "0"}
if mx >= args.dccb_begin:
mc.run(
fst.MakeAddReference(fst.args({
"cutoff": "1",
"use_cell": "true"
})))
trial_args["reference_index"] = "0"
trial_args["num_steps"] = "4"
mc.set(
fst.MakeThermoParams(
fst.args({
"beta": str(1. / args.temperature),
"chemical_potential": str(args.mu)
})))
mc.set(
fst.MakeFlatHistogram(
fst.MakeMacrostateNumParticles(
fst.Histogram(
fst.args({
"width": "1",
"max": str(mx),
"min": str(mn)
}))),
# fst.MakeTransitionMatrix(fst.args({"min_sweeps": str(args.min_sweeps)})),
fst.MakeWLTM(
fst.args({
"collect_flatness": "18",
"min_flatness": "22",
"min_sweeps": str(args.min_sweeps)
}))))
#mc.add(fst.MakeTrialTranslate(fst.args({"weight": "1.", "tunable_param": "1."})))
#mc.add(fst.MakeTrialTransfer(fst.args({"weight": "4", "particle_type": "0",
mc.add(
fst.MakeTrialGrow(
fst.ArgsVector([
dict({
"translate": "true",
"tunable_param": "1"
}, **trial_args)
])))
mc.add(
fst.MakeTrialGrow(
fst.ArgsVector(
[dict({
"transfer": "true",
"weight": "4"
}, **trial_args)])))
mc.add(
fst.MakeCheckEnergy(
fst.args({
"steps_per": steps_per,
"tolerance": "0.0001"
})))
mc.add(
fst.MakeTune(
fst.args({
"steps_per": steps_per,
"stop_after_phase": "0"
})))
mc.add(
fst.MakeLogAndMovie(
fst.args({
"steps_per": steps_per,
"file_name": "clones" + str(thread),
"file_name_append_phase": "True"
})))
mc.add(
fst.MakeEnergy(
fst.args({
"steps_per_write": steps_per,
"file_name": "en" + str(thread) + ".txt",
"file_name_append_phase": "True",
"start_after_phase": "0",
"multistate": "True"
})))
mc.add(fst.MakeCriteriaUpdater(fst.args({"steps_per": steps_per})))
mc.add(
fst.MakeCriteriaWriter(
fst.args({
"steps_per": steps_per,
"file_name": "clones" + str(thread) + "_crit.txt",
"file_name_append_phase": "True"
})))
mc.set(
fst.MakeCheckpoint(
fst.args({
"file_name":
"checkpoint" + str(thread) + ".fst",
"num_hours":
str(0.1 * args.num_procs * args.num_hours),
"num_hours_terminate":
str(0.9 * args.num_procs * args.num_hours)
})))
return mc
import sys
import math
import unittest
import argparse
import feasst
sys.path.insert(0, feasst.install_dir() + '/plugin/monte_carlo/py')
import lj
import pyfeasst
sys.path.insert(0, feasst.install_dir() + '/plugin/flat_histogram/py')
import fh
class TestLJ_FH_benchmark(unittest.TestCase):
def test(self):
#return
serial = False
serial = True
if serial:
criteria = feasst.MakeFlatHistogram(feasst.args(
{"beta": str(1./1.5),
"chemical_potential": "-2.35231"}
))
criteria.set(feasst.MakeMacrostateGrowthExpanded(
feasst.Histogram(feasst.args({"width": "0.5", "max": "10"})),
#feasst.args({"soft_max": "10"})
))
criteria.set(feasst.MakeTransitionMatrix(feasst.args({"min_sweeps": "10"})))
, "num_steps_to_update": str(int(1e6))}
mc2 = fh.monte_carlo(criteria=criteria, forcefield='data.dimer', run=False)
mc2.add(feasst.MakeCriteriaWriter(feasst.args({"steps_per": str(int(1e6))})))
mc2.run_until_complete()
