def equil_and_relax(T, fname="", np_layer=0, nptype="spherical"):
bc = init_bc(50)
mc = Montecarlo(bc.atoms, T)
print ("Running at temperature {}K. Initializing from {}".format(T, fname))
layer_str = "-".join((str(item) for item in np_layers[np_layer]))
run_identifier = "{}K_layer{}".format(T, layer_str)
if fname != "":
# Initialize atoms object from file
from ase.io import read
atoms = read(fname)
symbs = [atom.symbol for atom in atoms]
mc.set_symbols(symbs)
run_identifier = "{}K_{}".format(T, atoms.get_chemical_formula())
else:
if nptype == "spherical":
# Initialize by setting a nano particle at the center
nanop = get_nanoparticle(layer=np_layer)
elif nptype == "cubic":
nanop = get_cubic_nano_particle(layer=np_layer)
run_identifier += "cubic"
else:
raise ValueError("Unknown type {}".format(nanop))
symbs = insert_nano_particle(bc.atoms.copy(), nanop)
mc.set_symbols(symbs)
print("Chemical formula: {}".format(mc.atoms.get_chemical_formula()))
nsteps = int(4E7)
camera = Snapshot(atoms=mc.atoms, trajfile=workdir+"/snapshots_equil{}.traj".format(run_identifier))
energy_evol = EnergyEvolution(mc)
mc_backup = MCBackup(mc, backup_file=workdir+"/mc_backup{}.pkl".format(run_identifier))
mc.attach(energy_evol, interval=100000)
mc.attach(camera, interval=nsteps/20)
mc.attach(mc_backup, interval=500000)
mc.runMC(steps=nsteps, equil=False)
write(workdir+"/equillibriated600K.xyz", mc.atoms)
def pure_phase_entropy(small_bc):
from cemc.mcmc import Montecarlo
from ase.clease.tools import wrap_and_sort_by_position
from ase.io import read
from cemc.mcmc import SiteOrderParameter, Snapshot
import dataset
T = [1, 5, 10, 20, 30, 40, 50, 75, 100, 150, 200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310,
320, 330, 340, 350, 360, 370, 380, 390, 400, 420, 440, 460, 480, 500]
calc = get_ce_calc(small_bc, kwargs, ecis, size=[10, 10, 10], db_name="data/db10x10x10Al3Mg.db")
bc = calc.BC
bc.atoms.set_calculator(calc)
atoms = read("data/al3mg_template.xyz")
atoms = wrap_and_sort_by_position(atoms)
symbs = [atom.symbol for atom in atoms]
calc.set_symbols(symbs)
site_order = SiteOrderParameter(bc.atoms)
db = dataset.connect("sqlite:///data/pure_al3mg3.db")
syst = db["thermodynamic"]
camera = Snapshot(trajfile="data/pure_phase_entropy.traj", atoms=bc.atoms)
for temp in T:
print("Current temperature: {}K".format(temp))
site_order.reset()
mc = Montecarlo(bc.atoms, temp)
mc.attach(site_order)
mc.attach(camera, interval=50000)
equil_param = {"window_length": 100000, "mode": "fixed"}
mc.runMC(mode="fixed", steps=500000, equil=True, equil_params=equil_param)
mean, stddev = site_order.get_average()
thermo = mc.get_thermodynamic()
thermo["site_order"] = mean
thermo["site_order_std"] = stddev
syst.insert(thermo)
def main():
energies = []
sizes = list(range(1, 6))
atoms = get_atoms()
two_atoms(atoms)
exit()
insert_np(6, atoms)
mc = Montecarlo(atoms, 0.1)
camera = Snapshot(atoms=mc.atoms, trajfile="/work/sophus/nuc_cluster.traj")
db = dataset.connect("sqlite:////work/sophus/mgsi_nuc_barrier_kamijo.db")
tbl = db["systems"]
mc.attach(camera, interval=100 * len(atoms))
num_mg = sum(1 for atom in atoms if atom.symbol == "Mg")
while num_mg > 2:
print(atoms.get_chemical_formula())
mc.runMC(mode="fixed", equil=False, steps=100 * len(atoms))
thermo = mc.get_thermodynamic()
tbl.insert(thermo)
# Remove one Mg atom and one Si atom
symbols = [a.symbol for a in atoms]
for i in range(20):
i = symbols.index("Si")
symbols[i] = "Al"
i = symbols.index("Mg")
symbols[i] = "Al"
mc.set_symbols(symbols)
num_mg = sum(1 for atom in atoms if atom.symbol == "Mg")
def main(size, T):
atoms = create_surface(size)
atoms = wrap_and_sort_by_position(atoms)
conc_args = {
"conc_ratio_min_1": [[64, 0, 0]],
"conc_ratio_max_1": [[24, 40, 0]],
"conc_ratio_min_2": [[64, 0, 0]],
"conc_ratio_max_2": [[22, 21, 21]]
}
kwargs = {
"crystalstructure": "fcc",
"a": 4.05,
"size": [4, 4, 4],
"basis_elements": [["Al", "Mg", "Si"]],
"conc_args": conc_args,
"db_name": "data/almgsi.db",
"max_cluster_size": 4
}
ceBulk = BulkCrystal(**kwargs)
eci_file = "data/almgsi_fcc_eci_newconfig.json"
with open(eci_file, 'r') as infile:
ecis = json.load(infile)
db_name = "large_cell_db{}x{}x{}.db".format(size[0], size[1], size[2])
calc = get_ce_calc(ceBulk, kwargs, ecis, size=size, db_name=db_name)
ceBulk = calc.BC
ceBulk.atoms.set_calculator(calc)
mc = Montecarlo(ceBulk.atoms, T)
symbs = [atom.symbol for atom in atoms]
mc.set_symbols(symbs)
# Write a copy of the current atoms object
from ase.io import write
shape_str = "-".join((str(item) for item in size))
uid_str = "{}K_{}".format(T, shape_str)
write(WORKDIR + "initial_config{}.xyz".format(uid_str), mc.atoms)
backup = MCBackup(mc,
backup_file=WORKDIR + "backup{}.xyz".format(uid_str),
db_name=WORKDIR + "mc_surface.db")
camera = Snapshot(atoms=mc.atoms,
trajfile=WORKDIR + "surface{}.traj".format(uid_str))
evol = EnergyEvolution(mc)
nsteps = int(10E6)
mc.attach(backup, interval=100000)
mc.attach(camera, interval=int(nsteps / 20))
mc.attach(evol, interval=10 * len(mc.atoms))
mc.runMC(mode="fixed", steps=nsteps, equil=False)
write(WORKDIR + "final_config{}.xyz".format(uid_str), mc.atoms)
def get_gs(self,
BC,
ecis=None,
composition=None,
temps=None,
n_steps_per_temp=1000,
atoms=None):
"""
Computes the ground states
:param BC: Instance of *CEBulk* or *CECrystal* from ASE
:param ecis: Dictionary with the Effecitve Cluster Interactions
:param composition: Dictionary with compositions (i.e. {"Mg":0.2,"Al":0.8})
:param temps: List of cooling temperatures
:param n_steps_per_temp: Number of MC steps per temperature
"""
if atoms is None:
atoms = BC.atoms.copy()
if atoms.get_calculator() is None:
if ecis is None:
raise ValueError("When a calculator is not attached "
"the ECIs has to be given!")
calc = CE(atoms, BC, ecis)
else:
calc = atoms.get_calculator()
#print (calc.get_cf())
if (temps is None):
temps = np.linspace(1, 1500, 30)[::-1]
if (composition is not None):
calc.set_composition(composition)
minimum_energy = LowestEnergyStructure(calc, None)
for T in temps:
print("Temperature {}".format(T))
mc_obj = Montecarlo(atoms, T)
mc_obj.constraints = self.constraints
minimum_energy.mc_obj = mc_obj
mc_obj.attach(minimum_energy)
mc_obj.runMC(steps=n_steps_per_temp, verbose=False, equil=False)
thermo = mc_obj.get_thermodynamic()
result = {
"atoms": minimum_energy.atoms,
"energy": minimum_energy.lowest_energy,
"cf": minimum_energy.lowest_energy_cf
}
return result
def main():
atoms = get_atoms(cubic=True)
T = 1500
mc = Montecarlo(atoms, T)
mc.insert_symbol_random_places("Mg", num=400, swap_symbs=["Al"])
mc.insert_symbol_random_places("Si", num=400, swap_symbs=["Al"])
snap = Snapshot(trajfile="data/mc_digi{}K.traj", atoms=atoms)
mc.attach(snap, interval=50000)
mc.runMC(steps=500000)
T = 293
mc = Montecarlo(atoms, T)
snap = Snapshot(trajfile="data/mc_digi{}K.traj", atoms=atoms)
mc.attach(snap, interval=50000)
mc.runMC(steps=500000)
def sa(au_comp, kwargs, eci, db_name, size):
bc = CEBulk(**kwargs)
atoms = get_atoms_with_ce_calc(bc, kwargs, eci, size, db_name="cu-au_quad.db")
temperatures = [1500, 1400, 1300, 1200, 1100, 1000, 900, 800, 700, 600,
500, 400, 300, 200, 100, 50, 25, 10]
N = len(atoms)
gs = wrap_and_sort_by_position(read("data/atoms_Au250Cu750.xyz"))
symbs = [atom.symbol for atom in gs]
atoms.get_calculator().set_symbols(symbs)
print(atoms.get_calculator().get_energy())
exit()
# Define parameters for equillibration
equil_params = {
"maxiter": 10 * N,
"mode": "fixed"
}
nsteps = 200 * N
calc = atoms.get_calculator()
comp = {"Au": au_comp, "Cu": 1.0-au_comp}
calc.set_composition(comp)
energies = []
for T in temperatures:
mc = Montecarlo(atoms, T, accept_first_trial_move_after_reset=True)
energy_obs = EnergyEvolution(mc)
energies.append(energy_obs.energies)
mc.attach(energy_obs, interval=100)
mc.runMC(mode="fixed", steps=nsteps, equil_params=equil_params)
thermo = mc.get_thermodynamic()
thermo["converged"] = True
thermo["temperature"] = T
cf = calc.get_cf()
db = dataset.connect("sqlite:///{}".format(db_name))
tbl = db["results"]
uid = tbl.insert(thermo)
cf_tbl = db["corrfunc"]
cf["runID"] = uid
cf_tbl.insert(cf)
fname = "data/atoms_{}_{}.xyz".format(atoms.get_chemical_formula(), thermo['energy'])
write(fname, atoms)
np.savetxt("data/energy_evolution_{}.csv".format(atoms.get_chemical_formula()),
np.array(energies).T, delimiter=",")
def gs_mgsi():
atoms = get_atoms(cubic=True)
symbs = ["Mg" for _ in range(len(atoms))]
for i in range(int(len(symbs) / 2)):
symbs[i] = "Si"
atoms.get_calculator().set_symbols(symbs)
T = [
1500, 1400, 1300, 1200, 1100, 1000, 900, 800, 600, 500, 400, 300, 200,
100, 50
]
snap = Snapshot(trajfile="mgsi_gs_search.traj", atoms=atoms)
for temp in T:
print("Temperature {}K".format(temp))
mc = Montecarlo(atoms, temp)
mc.attach(snap, interval=10 * len(atoms))
mc.runMC(mode="fixed", steps=100 * len(atoms), equil=False)
def run_huge():
conc_args = {
"conc_ratio_min_1":[[64,0,0]],
"conc_ratio_max_1":[[24,40,0]],
"conc_ratio_min_2":[[64,0,0]],
"conc_ratio_max_2":[[22,21,21]]
}
kwargs = {
"crystalstructure":"fcc",
"size":[4,4,4],
"basis_elements":[["Al","Mg","Si"]],
"conc_args":conc_args,
"db_name":"some_db.db",
"max_cluster_size":4,
"a":4.05,
"ce_init_alg":"fast"
}
ceBulk = BulkCrystal( **kwargs )
with open(eci_file, 'r') as infile:
eci = json.load(infile)
calc = get_ce_calc(ceBulk, kwargs, eci=eci, size=[50,50,50])
calc.BC.atoms.set_calculator(calc)
print(calc.BC.basis_functions)
comp = {
"Al":0.9,
"Mg":0.05,
"Si":0.05
}
calc.set_composition(comp)
T = 150
T = [2000, 1500, 1200, 1000, 800, 600, 400, 293]
camera = Snapshot(trajfile=traj_file, atoms=calc.BC.atoms)
for temp in T:
print("Current temperature {}K".format(temp))
mc = Montecarlo(calc.BC.atoms, temp)
mc.attach(camera, interval=125000*20)
mc.runMC(mode="fixed", steps=125000*100, equil=False)
def run(N, T):
bc = init_bc(N)
mc = Montecarlo(bc.atoms, T)
nanop = get_nanoparticle()
symbs = insert_nano_particle(bc.atoms.copy(), nanop)
mc.set_symbols(symbs)
order_param = SiteOrderParameter(mc.atoms)
nsteps = int(1E6)
equil_params = {"mode": "fixed", "window_length": int(1E5)}
mc.attach(order_param)
mc.runMC(steps=nsteps, equil=True, equil_params=equil_params)
thermo = mc.get_thermodynamic()
mean, std = order_param.get_average()
thermo["order_param_mean"] = mean
thermo["order_param_std"] = std
thermo.update(equil_params)
db = dataset.connect("sqlite:///{}".format(mc_db_name))
tbl = db["cluster_stability"]
tbl.insert(thermo)
fname = workdir + "/final_structure{}K.xyz".format(T)
write(fname, mc.atoms)
def run(T,mg_conc):
conc_args = {
"conc_ratio_min_1":[[1,0]],
"conc_ratio_max_1":[[0,1]],
}
kwargs = {
"crystalstructure":"fcc", "a":4.05, "size":[4,4,4], "basis_elements":[["Al","Mg"]],
"conc_args":conc_args, "db_name":"data/temporary_bcdb.db",
"max_cluster_size":4
}
ceBulk = BulkCrystal( **kwargs )
print (ceBulk.basis_functions)
eci_file = "data/ce_hydrostatic.json"
with open( eci_file, 'r' ) as infile:
ecis = json.load( infile )
print (ecis)
#calc = CE( ceBulk, ecis, size=(3,3,3) )
calc = get_ce_calc( ceBulk, kwargs, ecis, size=[10,10,10], free_unused_arrays_BC=True )
ceBulk = calc.BC
ceBulk.atoms.set_calculator( calc )
comp = {
"Al":1.0-mg_conc,
"Mg":mg_conc
}
calc.set_composition(comp)
mc_obj = Montecarlo( ceBulk.atoms, T, mpicomm=comm )
pairs = PairCorrelationObserver( calc )
network = NetworkObserver( calc=calc, cluster_name="c2_1414_1", element="Mg", nbins=100 )
mode = "fixed"
camera = Snapshot( "data/precipitation.traj", atoms=ceBulk.atoms )
mc_obj.attach( camera, interval=10000 )
mc_obj.attach( pairs, interval=1 )
mc_obj.attach( network, interval=500 )
mc_obj.runMC( mode=mode, steps=10000, equil=True )
pair_mean = pairs.get_average()
pair_std = pairs.get_std()
if ( rank == 0 ):
data = {
"pairs":pair_mean,
"pairs_std":pair_std,
"mg_conc":mg_conc,
"temperature":T
}
pairfname = "data/precipitation_pairs/precipitation_pairs_{}_{}K.json".format(int(1000*mg_conc),int(T))
with open(pairfname,'w') as outfile:
json.dump(data,outfile,indent=2, separators=(",",":"))
print ( "Thermal averaged pair correlation functions written to {}".format(pairfname) )
atoms = network.get_atoms_with_largest_cluster()
data = network.get_statistics() # This collects the histogram data from all processors
size,occurence = network.get_size_histogram()
data["histogram"] = {}
data["histogram"]["size"] = size.tolist()
data["histogram"]["occurence"] = occurence.tolist()
data["temperature"] = T
data["mg_conc"] = mg_conc
cluster_fname = "data/cluster_statistics_{}_{}K.json".format(int(1000*mg_conc),int(T))
atoms_fname = "data/largest_cluster_{}_{}K.cif".format( int(1000*mg_conc), int(T) )
if ( rank == 0 ):
print (occurence)
if ( rank == 0 ):
try:
with open( cluster_fname,'r') as infile:
data = json.load(infile)
old_size = np.array(data["histogram"]["size"])
old_hist = np.array(data["histogram"]["occurence"])
if ( np.allclose(old_size,size) ):
occurence += old_hist
data["histogram"]["occurence"] = occurence.tolist()
except Exception as exc:
print (str(exc))
with open( cluster_fname, 'w' ) as outfile:
json.dump( data, outfile, indent=2, separators=(",",":") )
print ("Cluster statistics written to {}".format(cluster_fname) )
write( atoms_fname, atoms )
print ("Atoms with largest cluster written to {}".format(atoms_fname))
#view(atoms)
#plt.plot( network.size_histogram, ls="steps")
#plt.show()
print ("Proc: {} reached final barrier".format(rank))
comm.barrier()
def thermodynamic_integration(phase):
alat = 3.8
conc_args = {}
conc_args['conc_ratio_min_1'] = [[1, 0]]
conc_args['conc_ratio_max_1'] = [[0, 1]]
kwargs = {
"crystalstructure": 'fcc',
"a": 3.8,
"size": [10, 10, 10],
"basis_elements": [['Cu', 'Au']],
"conc_args": conc_args,
"db_name": 'temp_sgc.db',
"max_cluster_size": 3,
"max_cluster_dist": 1.5 * alat
}
bc1 = BulkCrystal(**kwargs)
bf = bc1._get_basis_functions()[0]
with open("data/eci_aucu.json", 'r') as infile:
eci = json.load(infile)
db = dataset.connect("sqlite:///{}".format(canonical_db))
tbl = db["corrfunc"]
if phase == "Au" or phase == "Cu":
atoms1 = bc1.atoms
for atom in atoms1:
atom.symbol = phase
cf1 = get_pure_cf(eci, bf[phase])
else:
atoms = read(phase)
row = tbl.find_one(runID=gs[phase])
row.pop("id")
row.pop("runID")
cf1 = row
# TODO: Fix this when running with a pure phase
symbs = [atom.symbol for atom in atoms]
cf1 = get_pure_cf(eci, bf[bc1.atoms[0].symbol])
atoms = bc1.atoms
calc = CE(bc1, eci=eci, initial_cf=cf1)
calc.set_symbols(symbs)
atoms.set_calculator(calc)
sgc_db = dataset.connect("sqlite:///{}".format(sgc_db_name))
tbl = sgc_db["results"]
tbl_cf = sgc_db["corr_func"]
mu = 0.223
nsteps = 100 * len(atoms)
equil_param = {"mode": "fixed", "maxiter": 10 * len(atoms)}
order_param = SiteOrderParameter(atoms)
T = np.linspace(100, 600, 40)
# mu = np.linspace(0.223, 0.19, 20).tolist()
mu = [0.223]
for temp in T:
for m in mu:
chemical_potential = {"c1_0": m}
# mc = SGCMonteCarlo(atoms, temp, mpicomm=comm, symbols=["Au", "Cu"])
mc = Montecarlo(atoms, temp)
mc.attach(order_param)
init_formula = atoms.get_chemical_formula()
# mc.runMC(steps=nsteps, equil_params=equil_param,
# chem_potential=chemical_potential)
mc.runMC(steps=nsteps, equil_params=equil_param)
# thermo = mc.get_thermodynamic(reset_ecis=True)
thermo = mc.get_thermodynamic()
thermo["init_formula"] = init_formula
thermo["final_formula"] = atoms.get_chemical_formula()
avg, std = order_param.get_average()
thermo["order_avg"] = avg
thermo["order_std"] = std
thermo["valid"] = True
thermo["integration_path"] = "NN"
if rank == 0:
uid = tbl.insert(thermo)
cf = calc.get_cf()
cf["runID"] = uid
tbl_cf.insert(cf)
