def test_no_throw(self):
if not available:
self.skipTest(skipMsg)
no_throw = True
msg = ""
try:
bc = get_ternary_BC()
eci = get_example_ecis(bc)
atoms = bc.atoms.copy()
CE(atoms, bc, eci=eci)
mc = Montecarlo(atoms, 1000)
mc.insert_symbol_random_places("Mg", num=10, swap_symbs=["Al"])
# Note: convergence_factor should never be
# set to a negative value! Here it is done
# to make the test converged after one step
bias = AdaptiveBiasReactionPathSampler(
mc_obj=mc,
react_crd_init=DummyReacCrdInit(),
react_crd=[-1.0, 1.0],
convergence_factor=-1.0)
bias.run()
except Exception as exc:
msg = str(exc)
no_throw = False
self.assertTrue(no_throw, msg=msg)
def test_chemical_potential(self):
if not available:
self.skipTest(avail_msg)
bc = get_ternary_BC()
ecis = {"c1_0": 0.0, "c1_1": 0.0}
atoms = bc.atoms.copy()
bf = bc.basis_functions
calc = CE(atoms, bc, eci=ecis)
groups = [{"Al": 2}, {"Mg": 1, "Si": 1}]
symbs = ["Al", "Mg", "Si"]
T = 400
chem_pots = [-0.2, -0.1, 0.0, 0.1, 0.2, 1.0]
all_al = ["Al" for _ in range(len(atoms))]
num_atom_per_fu = 2
for mu in chem_pots:
calc.set_symbols(all_al)
mc = PseudoBinarySGC(atoms,
T,
chem_pot=mu,
symbols=symbs,
groups=groups)
# At this point the chemical potentials should
# be updated
changes = [(0, "Al", "Mg"), (1, "Al", "Si")]
energy = calc.get_energy()
for change in changes:
calc.update_cf(change)
new_energy = calc.get_energy()
self.assertAlmostEqual(new_energy - energy, mu)
mc.reset_ecis()
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 test_with_bias_potential(self):
if not available:
self.skipTest(avail_msg)
msg = ""
try:
os.remove("test_db_ternary.db")
except Exception:
pass
no_throw = True
try:
bc = get_ternary_BC()
ecis = get_example_ecis(bc=bc)
atoms = bc.atoms.copy()
calc = CE(atoms, bc, eci=ecis)
groups = [{"Al": 2}, {"Mg": 1, "Si": 1}]
symbs = ["Al", "Mg", "Si"]
T = 400
mc = PseudoBinarySGC(atoms,
T,
chem_pot=-0.2,
symbols=symbs,
groups=groups)
conc_init = PseudoBinaryConcInitializer(mc)
reac_crd = np.linspace(0.0, 1.0, 10)
bias_pot = reac_crd**2
bias = PseudoBinaryFreeEnergyBias(conc_init, reac_crd, bias_pot)
mc.add_bias(bias)
mc.runMC(mode="fixed", steps=100, equil=False)
os.remove("test_db_ternary.db")
except Exception as exc:
msg = "{}: {}".format(type(exc).__name__, str(exc))
no_throw = False
self.assertTrue(no_throw, msg)
def test_no_throw(self):
if not available:
self.skipTest(avail_msg)
msg = ""
try:
os.remove("test_db_ternary.db")
except Exception:
pass
no_throw = True
try:
bc = get_ternary_BC()
ecis = get_example_ecis(bc=bc)
atoms = bc.atoms.copy()
calc = CE(atoms, bc, eci=ecis)
groups = [{"Al": 2}, {"Mg": 1, "Si": 1}]
symbs = ["Al", "Mg", "Si"]
T = 400
mc = PseudoBinarySGC(atoms,
T,
chem_pot=-0.2,
symbols=symbs,
groups=groups)
mc.runMC(mode="fixed", steps=100, equil=False)
os.remove("test_db_ternary.db")
except Exception as exc:
msg = "{}: {}".format(type(exc).__name__, str(exc))
no_throw = False
self.assertTrue(no_throw, msg)
def test_run(self):
if not available:
self.skipTest(reason)
bc = get_ternary_BC()
eci = get_example_ecis(bc)
atoms = bc.atoms.copy()
calc = CE(atoms, bc, eci=eci)
mc = Montecarlo(atoms, 1000000)
mc.insert_symbol_random_places("Mg", swap_symbs=["Al"], num=3)
performance_monitor = MultithreadPerformance(4)
performance_monitor.run(mc, 100)
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_raise_error_on_invalid_chem_pot(self):
if not available:
self.skipTest(avail_msg)
bc = get_ternary_BC()
ecis = get_example_ecis(bc=bc)
ecis.pop('c1_1')
atoms = bc.atoms.copy()
calc = CE(atoms, bc, eci=ecis)
atoms.set_calculator(calc)
groups = [{"Al": 2}, {"Mg": 1, "Si": 1}]
symbs = ["Al", "Mg", "Si"]
T = 400
with self.assertRaises(InvalidChemicalPotentialError):
PseudoBinarySGC(atoms,
T,
chem_pot=-0.2,
symbols=symbs,
groups=groups)
def test_with_ternay(self):
if ( not has_ase_with_ce ):
msg = "ASE version does not have CE"
self.skipTest( msg )
return
no_throw = True
msg = ""
try:
ground_states = []
elements = ["Al", "Mg", "Si"]
for i in range(3):
ce_bulk = get_ternary_BC()
eci = get_example_ecis(bc=ce_bulk)
atoms = ce_bulk.atoms.copy()
for atom in atoms:
atom.symbol = elements[i]
gs = {
"atoms": atoms,
"bc":ce_bulk,
"eci":eci,
"cf":get_example_cf(bc=ce_bulk, atoms=atoms)
}
ground_states.append(gs)
boundary = PhaseBoundaryTracker( ground_states )
T = [10,20]
mc_args = {
"steps":10,
"mode":"fixed",
"equil":False
}
res = boundary.separation_line_adaptive_euler( init_temp=100,min_step=99,stepsize=100, mc_args=mc_args, symbols=["Al","Mg","Si"] )
fname = "test_phase_boundary_ternary.h5"
save_phase_boundary(fname, res)
process_phase_boundary(fname)
except Exception as exc:
no_throw = False
msg = str(exc)
self.assertTrue( no_throw, msg=msg )
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)