def test_pair_observer(self):
if not available:
self.skipTest(skip_msg)
no_throw = True
msg = ""
bc = get_ternary_BC()
ecis = get_example_ecis(bc=bc)
atoms = bc.atoms.copy()
calc = CE(atoms, bc, eci=ecis)
atoms.set_calculator(calc)
T = 1000
nn_names = [name for name in bc.cluster_family_names
if int(name[1]) == 2]
mc = FixedNucleusMC(
atoms, T, network_name=nn_names,
network_element=["Mg", "Si"])
mc.insert_symbol_random_places("Mg", swap_symbs=["Al"])
elements = {"Mg": 3, "Si": 3}
mc.grow_cluster(elements)
obs = PairObserver(mc.atoms, cutoff=4.1, elements=["Mg", "Si"])
mc.attach(obs)
mc.runMC(steps=200)
self.assertEqual(obs.num_pairs, obs.num_pairs_brute_force())
self.assertTrue(obs.symbols_is_synced())
def main():
atoms = atoms_with_calc(50)
# mc = SoluteChainMC(atoms, 350, cluster_elements=["Mg", "Si"],
# cluster_names=["c2_01nn_0"])
T = [10]
snapshot = Snapshot(trajfile="data/solute_chain{}_nostrain.traj".format(T[0]), atoms=atoms)
first = True
nano_part = get_nanoparticle()
for temp in T:
print("Current temperature {}".format(T))
mc = FixedNucleusMC(
atoms, temp, network_name=["c2_01nn_0"],
network_element=["Mg", "Si"],
max_constraint_attempts=1E6)
backup = MCBackup(mc, overwrite_db_row=False, db_name="data/mc_solute_no_strain.db")
mc.attach(backup, interval=20000)
strain = get_strain_observer(mc)
mc.add_bias(strain)
if first:
first = False
#mc.grow_cluster({"Mg": 1000, "Si": 1000})
symbs = insert_nano_particle(atoms.copy(), nano_part)
mc.set_symbols(symbs)
tag_by_layer_type(mc.atoms)
cnst = ConstrainElementByTag(atoms=mc.atoms, element_by_tag=[["Mg", "Al"], ["Si", "Al"]])
mc.add_constraint(cnst)
#mc.build_chain({"Mg": 500, "Si": 500})
fix_layer = FixEdgeLayers(thickness=5.0, atoms=mc.atoms)
mc.add_constraint(fix_layer)
mc.attach(snapshot, interval=20000)
mc.runMC(steps=19000, init_cluster=False)
def test_covariance_observer(self):
"""Test the covariance observer."""
if not available:
self.skipTest("ASE version does not have CE!")
msg = ""
no_throw = True
from cemc.mcmc import FixEdgeLayers
from cemc.mcmc import CovarianceMatrixObserver
bc, args = get_ternary_BC(ret_args=True)
ecis = get_example_ecis(bc=bc)
atoms = get_atoms_with_ce_calc(bc, args, eci=ecis, size=[8, 8, 8], db_name="covariance_obs.db")
T = 200
nn_names = [name for name in bc.cluster_family_names
if int(name[1]) == 2]
mc = FixedNucleusMC(
atoms, T, network_name=nn_names,
network_element=["Mg", "Si"])
fixed_layers = FixEdgeLayers(atoms=mc.atoms, thickness=3.0)
mc.add_constraint(fixed_layers)
elements = {"Mg": 6, "Si": 6}
mc.insert_symbol_random_places("Mg", num=1, swap_symbs=["Al"])
mc.grow_cluster(elements)
cov_obs = CovarianceMatrixObserver(atoms=mc.atoms, cluster_elements=["Mg", "Si"])
mc.attach(cov_obs)
for _ in range(10):
mc.runMC(steps=100, elements=elements, init_cluster=False)
obs_I = cov_obs.cov_matrix
indices = []
for atom in mc.atoms:
if atom.symbol in ["Mg", "Si"]:
indices.append(atom.index)
cluster = mc.atoms[indices]
pos = cluster.get_positions()
com = np.mean(pos, axis=0)
pos -= com
cov_matrix = np.zeros((3, 3))
for i in range(pos.shape[0]):
x = pos[i, :]
cov_matrix += np.outer(x, x)
self.assertTrue(np.allclose(obs_I, cov_matrix))
os.remove("covariance_obs.db")
def test_with_covariance_reac_crd(self):
if not available:
self.skipTest("ASE version does not have CE!")
msg = ""
no_throw = True
try:
bc = get_ternary_BC()
atoms = bc.atoms.copy()
ecis = get_example_ecis(bc=bc)
calc = CE(atoms, bc, eci=ecis)
#bc.atoms.set_calculator(calc)
T = 200
nn_names = [name for name in bc.cluster_family_names
if int(name[1]) == 2]
mc = FixedNucleusMC(
atoms, T, network_name=nn_names,
network_element=["Mg", "Si"])
elements = {"Mg": 4, "Si": 4}
mc.insert_symbol_random_places("Mg", num=1, swap_symbs=["Al"])
mc.grow_cluster(elements)
conc_init = CovarianceCrdInitializer(
fixed_nucl_mc=mc, matrix_element="Al",
cluster_elements=["Mg", "Si"])
mc.runMC(steps=100, init_cluster=False)
match, match_msg = self._spherical_nano_particle_matches(conc_init)
self.assertTrue(match, msg=match_msg)
except Exception as exc:
no_throw = False
msg = str(exc)
self.assertTrue(no_throw, msg=msg)
def main(option="relax", size=8):
from copy import deepcopy
ceBulk = BulkCrystal( **kwargs )
bc_copy = deepcopy(ceBulk)
print (ecis)
al,mg = get_pure_energies(ecis)
print ("Al energy: {} eV/atom".format(al))
print ("Mg energy: {} eV/atom".format(mg))
#exit()
#calc = CE( ceBulk, ecis, size=(3,3,3) )
calc = get_ce_calc(ceBulk, kwargs, ecis, size=[15,15,15])
ceBulk = calc.BC
ceBulk.atoms.set_calculator( calc )
#pure_energy = calc.get_energy()
#print (pure_energy)
#energy = calc.calculate( ceBulk.atoms, ["energy"],[(0,"Al","Mg")])
#print (energy)
#energy = calc.calculate( ceBulk.atoms, ["energy"], [()])
#exit()
if option == "heat":
print("Running with cluser size {}".format(size))
mc = FixedNucleusMC( ceBulk.atoms, 293, network_name=["c2_4p050_3"], network_element=["Mg"] )
cluster_entropy(mc, size=size)
return
elif option == "pure_phase":
pure_phase_entropy(bc_copy)
return
else:
sizes = range(3,51)
#sizes = np.arange(3, 51)
energies = []
cell = ceBulk.atoms.get_cell()
diag = 0.5*(cell[0, :] + cell[1, :] + cell[2, :])
pos = ceBulk.atoms.get_positions()
pos -= diag
lengths = np.sum(pos**2, axis=1)
indx = np.argmin(lengths)
symbs = [atom.symbol for atom in ceBulk.atoms]
symbs[indx] = "Mg"
print("Orig energy: {}".format(calc.get_energy()))
calc.set_symbols(symbs)
print("One atom: {}".format(calc.get_energy()))
exit()
for size in sizes:
elements = {"Mg": size}
T = np.linspace(50,1000,40)[::-1]
# Reset the symbols to only Mg
calc.set_symbols(symbs)
mc = FixedNucleusMC( ceBulk.atoms, T, network_name=["c2_4p050_3"], network_element=["Mg"] )
mc.grow_cluster(elements)
mc.current_energy = calc.get_energy()
low_en = LowestEnergyStructure( calc, mc, verbose=True )
mc.attach( low_en )
for temp in T:
print ("Temperature {}K".format(temp))
mc.T = temp
mc.runMC(steps=10000, init_cluster=False)
mc.reset()
mc.is_first = False
# atoms,clust = mc.get_atoms( atoms=low_en.atoms )
write( "{}cluster{}_all.cif".format(folder,size), low_en.atoms )
# write( "{}cluster{}_cluster.cif".format(folder,size), clust )
energies.append(low_en.lowest_energy)
print (sizes,energies)
data = np.vstack((sizes,energies)).T
np.savetxt( "{}energies_run2.txt".format(folder), data, delimiter=",")