def get_eci():
bc = CEBulk(**bc_kwargs)
bc.reconfigure_settings()
cf = CorrFunction(bc)
cf = cf.get_cf(bc.atoms)
eci = {key: 0.001 for key in cf.keys()}
return eci
def test_network(self):
if (not available):
self.skipTest("ASE version does not have CE!")
return
msg = ""
no_throw = True
try:
db_name = "test_db_network.db"
conc = Concentration(basis_elements=[["Al", "Mg"]])
a = 4.05
ceBulk = CEBulk(crystalstructure="fcc",
a=a,
size=[3, 3, 3],
concentration=conc,
db_name=db_name,
max_cluster_size=3,
max_cluster_dia=4.5)
ceBulk.reconfigure_settings()
cf = CorrFunction(ceBulk)
atoms = ceBulk.atoms.copy()
cf = cf.get_cf(atoms)
eci = {key: 0.001 for key in cf.keys()}
calc = CE(atoms, ceBulk, eci=eci)
trans_mat = ceBulk.trans_matrix
for name, info in ceBulk.cluster_info[0].items():
if info["size"] == 2:
net_name = name
break
obs = NetworkObserver(calc=calc,
cluster_name=[net_name],
element=["Mg"])
# Several hard coded tests
calc.update_cf((0, "Al", "Mg"))
size = 2
clusters = ceBulk.cluster_info[0][net_name]["indices"]
for sub_clust in clusters:
calc.update_cf((sub_clust[0], "Al", "Mg"))
# Call the observer
obs(None)
res = obs.fast_cluster_tracker.get_cluster_statistics_python()
self.assertEqual(res["cluster_sizes"][0], size)
size += 1
obs.get_indices_of_largest_cluster_with_neighbours()
os.remove("test_db_network.db")
except Exception as exc:
msg = "{}: {}".format(type(exc).__name__, str(exc))
no_throw = False
self.assertTrue(no_throw, msg=msg)
def get_ternary_BC(ret_args=False):
db_name = "test_db_ternary.db"
max_dia = get_max_cluster_dia_name()
size_arg = {max_dia: 4.05}
conc = Concentration(basis_elements=[["Al", "Mg", "Si"]])
args = dict(crystalstructure="fcc", a=4.05, size=[4,4,4], concentration=conc, \
db_name=db_name, max_cluster_size=3, **size_arg)
ceBulk = CEBulk(**args)
ceBulk.reconfigure_settings()
if ret_args:
return ceBulk, args
return ceBulk
def get_ternary_BC():
db_name = "test_db_ternary.db"
conc_args = {
"conc_ratio_min_1":[[4,0,0]],
"conc_ratio_max_1":[[0,4,0]],
"conc_ratio_min_1":[[2,2,0]],
"conc_ratio_max_2":[[1,1,2]]
}
max_dia = get_max_cluster_dia_name()
size_arg = {max_dia:4.05}
ceBulk = CEBulk(crystalstructure="fcc", a=4.05, size=[4,4,4], basis_elements=[["Al","Mg","Si"]], \
conc_args=conc_args, db_name=db_name, max_cluster_size=3, **size_arg)
ceBulk.reconfigure_settings()
return ceBulk
def init_bulk_crystal(self):
conc = Concentration(basis_elements=[["Al", "Mg", "Si"]])
ceBulk = CEBulk(crystalstructure="fcc",
a=4.05,
size=[4, 4, 4],
concentration=conc,
db_name=db_name,
max_cluster_size=2,
max_cluster_dia=4.0)
ceBulk.reconfigure_settings()
ecis = get_example_ecis(bc=ceBulk)
atoms = ceBulk.atoms.copy()
calc = CE(atoms, ceBulk, ecis)
return ceBulk, atoms
def get_small_BC_with_ce_calc(lat="fcc"):
db_name = "test_db_{}.db".format(lat)
a = 4.05
conc = Concentration(basis_elements=[["Al", "Mg"]])
ceBulk = CEBulk( crystalstructure=lat, a=a, size=[3,3,3], concentration=conc, \
db_name=db_name, max_cluster_size=3, max_cluster_dia=4.5)
ceBulk.reconfigure_settings()
cf = CorrFunction(ceBulk)
corrfuncs = cf.get_cf(ceBulk.atoms)
eci = {name: 1.0 for name in corrfuncs.keys()}
calc = CE(ceBulk.atoms.copy(), ceBulk, eci)
#ceBulk.atoms.set_calculator(calc)
return ceBulk, calc
def init_bulk_crystal(self):
max_dia_name = get_max_cluster_dia_name()
size_arg = {max_dia_name: 4.05}
conc = Concentration(basis_elements=[["Al", "Mg", "Si"]])
ceBulk = CEBulk(crystalstructure="fcc",
a=4.05,
size=[3, 3, 3],
concentration=conc,
db_name=db_name,
max_cluster_size=3,
**size_arg)
ceBulk.reconfigure_settings()
atoms = ceBulk.atoms.copy()
calc = CE(atoms, ceBulk, ecis)
#ceBulk.atoms.set_calculator(calc)
return ceBulk, atoms
def test_gs_finder(self):
if (not has_CE):
self.skipTest("ASE version does not have CE")
return
no_throw = True
msg = ""
try:
db_name = "test_db_gsfinder.db"
conc_args = {
"conc_ratio_min_1": [[1, 0]],
"conc_ratio_max_1": [[0, 1]],
}
a = 4.05
ceBulk = CEBulk( crystalstructure="fcc", a=a, size=[3,3,3], basis_elements=[["Al","Mg"]], conc_args=conc_args, \
db_name=db_name, max_cluster_size=4)
cf = CorrFunction(ceBulk)
cf = cf.get_cf(ceBulk.atoms)
eci = {key: 1.0 for key in cf.keys()}
gsfinder = GSFinder()
comp = {"Al": 0.5, "Mg": 0.5}
gsfinder.get_gs(ceBulk, eci, composition=comp)
except Exception as exc:
msg = str(exc)
no_throw = False
self.assertTrue(no_throw, msg=msg)
def atoms_with_calc(N):
conc = Concentration(basis_elements=[["Al", "Mg", "Si"]])
kwargs = {
"crystalstructure": "fcc",
"a": 4.05,
"size": [4, 4, 4],
"concentration": conc,
"db_name": "data/almgsi_10dec.db",
"max_cluster_size": 4
}
ceBulk = CEBulk(**kwargs)
eci_file = "data/almgsi_fcc_eci_newconfig_dec10.json"
with open(eci_file, 'r') as infile:
ecis = json.load(infile)
db_name = "large_cell_db{}x{}x{}_dec10.db".format(N, N, N)
#ecis = {"c1_0": 1.0}
atoms = get_atoms_with_ce_calc(ceBulk, kwargs, ecis, size=[N, N, N], db_name=db_name)
symbs = [atom.symbol for atom in atoms]
diag = atoms.get_cell().T.dot([0.5, 0.5, 0.5])
pos = atoms.get_positions() - diag
lengths = np.sum(pos**2, axis=1)
indx = np.argmin(lengths)
symbs[indx] = "Mg"
atoms.get_calculator().set_symbols(symbs)
return atoms
def get_atoms(cubic=False):
conc = Concentration(basis_elements=[["Al", "Mg", "Si"]])
kwargs = {
"crystalstructure": "fcc",
"a": 4.05,
"size": [2, 2, 2],
"concentration": conc,
"db_name": "data/almgsi_free_eng.db",
"max_cluster_size": 4,
"max_cluster_dia": [7.8, 5.0, 5.0],
"cubic": cubic
}
N = 10
ceBulk = CEBulk(**kwargs)
print(ceBulk.basis_functions)
eci_file = "data/almgsi_fcc_eci.json"
eci_file = "data/eci_almgsi_aicc.json"
eci_file = "data/eci_bcs.json"
eci_file = "data/eci_almgsi_loocv.json"
eci_file = "data/eci_l1.json"
with open(eci_file, 'r') as infile:
ecis = json.load(infile)
db_name = "large_cell_db{}x{}x{}.db".format(N, N, N)
atoms = get_atoms_with_ce_calc(ceBulk,
kwargs,
ecis,
size=[N, N, N],
db_name=db_name)
return atoms
def get_small_BC_with_ce_calc(lat="fcc"):
db_name = "test_db_{}.db".format(lat)
conc_args = {
"conc_ratio_min_1":[[1,0]],
"conc_ratio_max_1":[[0,1]],
}
a = 4.05
ceBulk = CEBulk( crystalstructure=lat, a=a, size=[3,3,3], basis_elements=[["Al","Mg"]], conc_args=conc_args, \
db_name=db_name, max_cluster_size=3)
ceBulk.reconfigure_settings()
cf = CorrFunction(ceBulk)
corrfuncs = cf.get_cf(ceBulk.atoms)
eci = {name:1.0 for name in corrfuncs.keys()}
calc = CE( ceBulk, eci )
ceBulk.atoms.set_calculator(calc)
return ceBulk
def get_atoms_with_ce_calc(small_bc,
bc_kwargs,
eci=None,
size=[1, 1, 1],
db_name="temp_db.db"):
"""
Constructs a CE calculator for a supercell.
First, the correlation function from a small cell is calculated and then
a supercell is formed. Note that the correlation functions are the same
for the supercell.
:param ClusterExpansionSetting small_bc: Settings for small unitcell
:param dict bc_kwargs: dictionary of the keyword arguments used to
construct small_bc
:param dict eci: Effective Cluster Interactions
:param list size: The atoms in small_bc will be extended by this amount
:param str db_name: Database to store info in for the large cell
:return: Atoms object with CE calculator attached
:rtype: Atoms
"""
unknown_type = False
large_bc = small_bc
init_cf = None
error_happened = False
msg = ""
transfer_floating_point_classifier(bc_kwargs["db_name"], db_name)
max_size_eci = get_max_size_eci(eci)
if "max_cluster_size" in bc_kwargs.keys():
if max_size_eci > bc_kwargs["max_cluster_size"]:
msg = "ECI specifies a cluster size larger than "
msg += "ClusterExpansionSetting tracks!"
raise ValueError(msg)
atoms = small_bc.atoms.copy()
calc1 = CE(atoms, small_bc, eci)
init_cf = calc1.get_cf()
min_length = small_bc.max_cluster_dia
bc_kwargs["size"] = size
size_name = get_max_dia_name()
bc_kwargs[size_name] = min_length
bc_kwargs["db_name"] = db_name
if isinstance(small_bc, CEBulk):
large_bc = CEBulk(**bc_kwargs)
elif isinstance(small_bc, CECrystal):
large_bc = CECrystal(**bc_kwargs)
else:
unknown_type = True
atoms = large_bc.atoms.copy()
# Note this automatically attach the calculator to the
# atoms object
CE(atoms, large_bc, eci, initial_cf=init_cf)
return atoms
def init_bulk_crystal(self):
conc_args = {
"conc_ratio_min_1": [[2, 1, 1]],
"conc_ratio_max_1": [[0, 2, 2]],
}
ceBulk = CEBulk(crystalstructure="fcc",
a=4.05,
size=[4, 4, 4],
basis_elements=[["Al", "Mg", "Si"]],
conc_args=conc_args,
db_name=db_name,
max_cluster_size=2,
max_cluster_dia=4.0)
ceBulk.reconfigure_settings()
ecis = get_example_ecis(bc=ceBulk)
calc = CE(ceBulk, ecis)
ceBulk.atoms.set_calculator(calc)
return ceBulk
def get_example_ecis(bc=None,bc_kwargs=None):
if ( bc is not None ):
cf = CorrFunction(bc)
else:
bc = CEBulk(**bc_kwargs)
cf = CorrFunction(bc)
cf = cf.get_cf(bc.atoms)
eci = {key: 0.001 for key in cf.keys()}
return eci
def insert_atoms( self, bc_kwargs, size=[1,1,1], composition=None, cetype="CEBulk", \
T=None, n_steps_per_temp=10000, eci=None ):
"""
Insert a new atoms object into the database
"""
if (composition is None):
raise TypeError("No composition given")
allowed_ce_types = ["CEBulk", "CECrystal"]
if (not cetype in allowed_ce_types):
raise ValueError(
"cetype has to be one of {}".format(allowed_ce_types))
self.cetype = cetype
if (eci is None):
raise ValueError(
"No ECIs given! Cannot determine required energy range!")
if (cetype == "CEBulk"):
small_bc = CEBulk(**bc_kwargs)
small_bc.reconfigure_settings()
elif (ctype == "CECrystal"):
small_bc = CECrystal(**bc_kwargs)
small_bc.reconfigure_settings()
self._check_eci(small_bc, eci)
calc = get_ce_calc(small_bc, bc_kwargs, eci=eci, size=size)
calc.set_composition(composition)
bc = calc.BC
bc.atoms.set_calculator(calc)
formula = bc.atoms.get_chemical_formula()
if (self.template_atoms_exists(formula)):
raise AtomExistsError(
"An atom object with the specified composition already exists in the database"
)
Emin, Emax = self._find_energy_range(bc.atoms, T, n_steps_per_temp)
cf = calc.get_cf()
data = {"cf": cf}
# Store this entry into the database
db = connect(self.wl_db_name)
scalc = SinglePointCalculator(bc.atoms, energy=Emin)
bc.atoms.set_calculator(scalc)
outfname = "BC_wanglandau_{}.pkl".format(
bc.atoms.get_chemical_formula())
with open(outfname, 'wb') as outfile:
pck.dump(bc, outfile)
kvp = {
"Emin": Emin,
"Emax": Emax,
"bcfile": outfname,
"cetype": self.cetype
}
data["bc_kwargs"] = bc_kwargs
data["supercell_size"] = size
db.write(calc.BC.atoms, key_value_pairs=kvp, data=data)
def test_no_throw(self):
no_throw = True
if not available:
self.skipTest(reason)
return
msg = ""
# try:
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_bcnucleationdb.db",
"max_cluster_size": 3
}
ceBulk = CEBulk(**kwargs)
ceBulk.reconfigure_settings()
cf = CorrFunction(ceBulk)
cf = cf.get_cf(ceBulk.atoms)
ecis = {key: 1.0 for key in cf.keys()}
calc = CE(ceBulk, ecis)
ceBulk = calc.BC
ceBulk.atoms.set_calculator(calc)
T = 500
c_mg = 0.4
comp = {"Mg": c_mg, "Al": 1.0 - c_mg}
calc.set_composition(comp)
act_sampler = ActivitySampler(ceBulk.atoms,
T,
moves=[("Al", "Mg")],
mpicomm=comm)
act_sampler.runMC(mode="fixed", steps=1000)
act_sampler.get_thermodynamic()
# except Exception as exc:
# msg = str(exc)
# no_throw = False
self.assertTrue(no_throw, msg=msg)
def init_bulk_crystal(self):
conc_args = {
"conc_ratio_min_1": [[2, 1, 1]],
"conc_ratio_max_1": [[0, 2, 2]],
}
max_dia_name = get_max_cluster_dia_name()
size_arg = {max_dia_name: 4.05}
ceBulk = CEBulk(crystalstructure="fcc",
a=4.05,
size=[3, 3, 3],
basis_elements=[["Al", "Mg", "Si"]],
conc_args=conc_args,
db_name=db_name,
max_cluster_size=3,
**size_arg)
ceBulk.reconfigure_settings()
calc = CE(ceBulk, ecis)
ceBulk.atoms.set_calculator(calc)
return ceBulk
def test_no_throw(self):
if (not has_CE):
self.skipTest("ASE version does not have ASE")
return
no_throw = True
msg = ""
try:
conc_args = {
"conc_ratio_min_1": [[1, 0]],
"conc_ratio_max_1": [[0, 1]],
}
kwargs = {
"crystalstructure": "fcc",
"a": 4.05,
"size": [3, 3, 3],
"basis_elements": [["Al", "Mg"]],
"conc_args": conc_args,
"db_name": "temporary_bcnucleationdb.db",
"max_cluster_size": 3
}
ceBulk = CEBulk(**kwargs)
cf = CorrFunction(ceBulk)
cf_dict = cf.get_cf(ceBulk.atoms)
ecis = {key: 1.0 for key, value in cf_dict.items()}
#calc = CE( ceBulk, ecis, size=(3,3,3) )
calc = get_ce_calc(ceBulk,
kwargs,
ecis,
size=[6, 6, 6],
db_name="sc6x6x6.db")
ceBulk = calc.BC
ceBulk.atoms.set_calculator(calc)
chem_pot = {"c1_0": -1.069}
T = 300
mc = SGCFreeEnergyBarrier( ceBulk.atoms, T, symbols=["Al","Mg"], \
n_windows=5, n_bins=10, min_singlet=0.5, max_singlet=1.0 )
mc.run(nsteps=100, chem_pot=chem_pot)
mc.save(fname="free_energy_barrier.json")
# Try to load the object stored
mc = SGCFreeEnergyBarrier.load(ceBulk.atoms,
"free_energy_barrier.json")
mc.run(nsteps=100, chem_pot=chem_pot)
mc.save(fname="free_energy_barrier.json")
os.remove("sc6x6x6.db")
except Exception as exc:
msg = str(exc)
no_throw = False
self.assertTrue(no_throw, msg=msg)
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 load_from_dict(backup_data):
"""Rebuild the calculator from dictionary
:param dict backup_data: All nessecary arguments
"""
from ase.clease import CEBulk, CECrystal
classtype = backup_data["setting_kwargs"].pop("classtype")
if classtype == "CEBulk":
bc = CEBulk(**backup_data["setting_kwargs"])
elif classtype == "CECrystal":
bc = CECrystal(**backup_data["setting_kwargs"])
else:
raise ValueError("Unknown setting classtype: {}"
"".format(backup_data["setting_kwargs"]))
for symb in backup_data["symbols"]:
bc.atoms.symbol = symb
return CE(bc, eci=backup_data["eci"], initial_cf=backup_data["cf"])
def get_atoms(self, atomID, eci):
"""
Returns an instance of the atoms object requested
"""
db = connect(self.wl_db_name)
row = db.get(id=atomID)
bcfname = row.key_value_pairs["bcfile"]
init_cf = row.data["cf"]
try:
with open(bcfname, 'rb') as infile:
bc, atoms = pck.load(infile)
calc = CE(atoms, bc, eci, initial_cf=init_cf)
return atoms
except IOError as exc:
print(str(exc))
print("Will try to recover the CEBulk object")
bc_kwargs = row.data["bc_kwargs"]
cetype = row.key_value_pairs["cetype"]
if (cetype == "CEBulk"):
small_bc = CEBulk(**bc_kwargs)
small_bc.reconfigure_settings()
else:
small_bc = CECrystal(**bc_kwargs)
small_bc.reconfigure_settings()
size = row.data["supercell_size"]
atoms = get_atoms_with_ce_calc(small_bc,
bc_kwargs,
eci=eci,
size=size)
calc = atoms.get_calculator()
# Determine the composition
count = row.count_atoms()
for key in count.keys():
count /= float(row.natoms)
calc.set_composition(count)
return atoms
except:
raise RuntimeError(
"Did not manage to return the atoms object with the proper calculator attached..."
)
2. Initialize a Cluster Expansion calculator
3. Initialize a the Monte Carlo object
4. Simple use of Monte Carlo observers
"""
# First we import the CEBulk object from ASE
from ase.clease import CEBulk
from util import get_example_ecis
# Initialize the CEBulk object for a 4x4x4 expansion of a
# primitive FCC unitcell
conc_args = {"conc_ratio_min_1": [[0, 1]], "conc_ratio_max_1": [[1, 0]]}
bc = CEBulk(crystalstructure="fcc",
a=4.05,
conc_args=conc_args,
db_name="test_gs_db.db",
size=[3, 3, 3],
basis_elements=[["Al", "Mg"]],
max_cluster_size=3)
bc.reconfigure_settings() # Nessecary for unittests to pass
# Just use some example ECIs
eci = get_example_ecis(bc=bc)
# Initialize a Cluster Expansion calculator (C++ version is required)
from cemc import CE
calc = CE(bc, eci)
bc.atoms.set_calculator(calc)
# NOTE: At this point all changes to the atoms object has to be done via
# the calculator. The reason is that the calculator keeps track of the
def surface_energy():
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 = CEBulk(**kwargs)
eci_file = "data/almgsi_fcc_eci_newconfig.json"
with open(eci_file, 'r') as infile:
ecis = json.load(infile)
size = (8, 8, 8)
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)
print(calc.get_energy() / len(calc.atoms))
ceBulk = calc.BC
ceBulk.atoms.set_calculator(calc)
# Get the energy of MgSi
mgsi = wrap_and_sort_by_position(get_mgsi() * (4, 4, 4))
symbs = [atom.symbol for atom in mgsi]
calc.set_symbols(symbs)
view(calc.atoms)
mgsi_energy = calc.get_energy() / len(calc.atoms)
print("Energy MgSi: {} eV/atom".format(mgsi_energy))
# Get the energy of pure al
symbs = ["Al" for _ in range(len(mgsi))]
calc.set_symbols(symbs)
view(calc.atoms)
al_energy = calc.get_energy() / len(calc.atoms)
print("Energy Al: {} eV/atom".format(al_energy))
# Get the energy of a 50% mixture
mgsi = wrap_and_sort_by_position(get_mgsi() * (4, 4, 2))
# mgsi = get_mgsi_surface100_si_si()
from scipy.spatial import cKDTree as KDTree
cell = calc.atoms.get_cell()
tree = KDTree(calc.atoms.get_positions())
symbs = [atom.symbol for atom in calc.atoms]
for atom in mgsi:
pos = np.zeros((1, 3))
pos[0, :] = atom.position
wrapped = wrap_positions(pos, cell)
if not np.allclose(wrapped, atom.position):
continue
_, indx = tree.query(atom.position)
symbs[indx] = atom.symbol
calc.set_symbols(symbs)
view(calc.atoms)
# Surface energy
mix_energy = calc.get_energy()
print("Mix energy: {} eV ({} eV/atom)".format(mix_energy, mix_energy /
len(calc.atoms)))
num_al = 0
num_mgsi = 0
for atom in calc.atoms:
if atom.symbol == "Al":
num_al += 1
elif atom.symbol == "Mg" or atom.symbol == "Si":
num_mgsi += 1
assert num_al + num_mgsi == len(calc.atoms)
dE = mix_energy - num_al * al_energy - num_mgsi * mgsi_energy
cell = calc.atoms.get_cell()
a1 = cell[0, :]
a2 = cell[1, :]
normal = np.cross(a1, a2)
area = np.sqrt(normal.dot(normal))
# Convert units
surface_tension = dE / area
mJ = J / 1000.0 # milli joules
surface_tension *= (m * m / mJ)
unit_normal = normal / area
print("Surface tension: {} mJ/m^2".format(surface_tension))
print("Direction: {}".format(unit_normal))
def test_no_throw(self):
if not available:
self.skipTest("ASE version does not have CE!")
return
no_throw = True
msg = ""
try:
db_name = "temp_nuc_db.db"
if os.path.exists(db_name):
os.remove(db_name)
conc = Concentration(basis_elements=[["Al", "Mg"]])
kwargs = {
"crystalstructure": "fcc", "a": 4.05,
"size": [3, 3, 3],
"concentration": conc, "db_name": db_name,
"max_cluster_size": 3,
"max_cluster_dia": 4.5
}
ceBulk = CEBulk(**kwargs)
ceBulk.reconfigure_settings()
cf = CorrFunction(ceBulk)
cf = cf.get_cf(ceBulk.atoms)
ecis = {key: 0.001 for key in cf.keys()}
atoms = get_atoms_with_ce_calc(ceBulk, kwargs, ecis, size=[5, 5, 5],
db_name="sc5x5x5.db")
chem_pot = {"c1_0": -1.0651526881167124}
sampler = NucleationSampler(
size_window_width=10,
chemical_potential=chem_pot, max_cluster_size=20,
merge_strategy="normalize_overlap")
nn_name = get_network_name(ceBulk.cluster_family_names_by_size)
mc = SGCNucleation(
atoms, 30000, nucleation_sampler=sampler,
network_name=[nn_name], network_element=["Mg"],
symbols=["Al", "Mg"], chem_pot=chem_pot)
mc.runMC(steps=2, equil=False)
sampler.save(fname="test_nucl.h5")
mc = CanonicalNucleationMC(
atoms, 300, nucleation_sampler=sampler,
network_name=[nn_name], network_element=["Mg"],
concentration={"Al": 0.8, "Mg": 0.2}
)
symbs = [atom.symbol for atom in atoms]
symbs[0] = "Mg"
symbs[1] = "Mg"
mc.set_symbols(symbs)
#mc.runMC(steps=2)
sampler.save(fname="test_nucl_canonical.h5")
elements = {"Mg": 6}
calc = atoms.get_calculator()
calc.set_composition({"Al": 1.0, "Mg": 0.0})
mc = FixedNucleusMC(atoms, 300,
network_name=[nn_name], network_element=["Mg"])
mc.insert_symbol_random_places("Mg", num=1, swap_symbs=["Al"])
mc.runMC(steps=2, elements=elements, init_cluster=True)
os.remove("sc5x5x5.db")
except Exception as exc:
msg = str(exc)
msg += "\n" + traceback.format_exc()
no_throw = False
self.assertTrue(no_throw, msg=msg)
3. Initialize a the Monte Carlo object
4. Simple use of Monte Carlo observers
"""
# First we import the CEBulk object from ASE
from ase.clease import CEBulk
from ase.clease import Concentration
from util import get_example_ecis
# Initialize the CEBulk object for a 4x4x4 expansion of a
# primitive FCC unitcell
conc = Concentration([["Al", "Mg"]])
bc = CEBulk(crystalstructure="fcc",
a=4.05,
db_name="test_gs_db.db",
size=[3, 3, 3],
concentration=conc,
max_cluster_size=3,
max_cluster_dia=4.5)
bc.reconfigure_settings() # Nessecary for unittests to pass
# Just use some example ECIs
eci = get_example_ecis(bc=bc)
# Initialize a Cluster Expansion calculator (C++ version is required)
from cemc import CE
atoms = bc.atoms.copy()
calc = CE(atoms, bc, eci)
# NOTE: At this point all changes to the atoms object has to be done via
# the calculator. The reason is that the calculator keeps track of the
def get_ce_calc(small_bc,
bc_kwargs,
eci=None,
size=[1, 1, 1],
db_name="temp_db.db"):
"""
Constructs a CE calculator for a supercell.
First, the correlation function from a small cell is calculated and then
a supercell is formed. Note that the correlation functions are the same
for the supercell.
:param ClusterExpansionSetting small_bc: Settings for small unitcell
:param dict bc_kwargs: dictionary of the keyword arguments used to
construct small_bc
:param dict eci: Effective Cluster Interactions
:param list size: The atoms in small_bc will be extended by this amount
:param str db_name: Database to store info in for the large cell
:return: CE calculator for the large cell
:rtype: CE
"""
nproc = num_processors()
unknown_type = False
large_bc = small_bc
init_cf = None
error_happened = False
msg = ""
if not os.path.exists(db_name) and nproc > 1:
raise IOError("The database has to be prepared prior to calling "
"get_ce_calc")
try:
max_size_eci = get_max_size_eci(eci)
if "max_cluster_dia" in bc_kwargs.keys():
if max_size_eci > bc_kwargs["max_cluster_dia"]:
msg = "ECI specifies a cluster size larger than "
msg += "ClusterExpansionSetting tracks!"
raise ValueError(msg)
print("Initializing calculator with small BC")
calc1 = CE(small_bc, eci)
print("Initialization finished")
init_cf = calc1.get_cf()
min_length = small_bc.max_cluster_dia
bc_kwargs["size"] = size
size_name = get_max_dia_name()
bc_kwargs[size_name] = min_length
bc_kwargs["db_name"] = db_name
if isinstance(small_bc, CEBulk):
large_bc = CEBulk(**bc_kwargs)
elif isinstance(small_bc, CECrystal):
large_bc = CECrystal(**bc_kwargs)
else:
unknown_type = True
except MemoryError:
# No default error message here
error_happened = True
msg = "Memory Error. Most likely went out "
msg += " of memory when initializing an array"
except Exception as exc:
error_happened = True
msg = str(exc)
print(msg)
# Broad cast the error flag and raise error on all processes
error_happened = mpi_allreduce(error_happened)
all_msg = mpi_allgather(msg)
for item in all_msg:
if item != "":
msg = item
break
if error_happened:
raise RuntimeError(msg)
unknown_type = mpi_bcast(unknown_type, root=0)
if unknown_type:
msg = "The small_bc argument has to by of type "
msg += "CEBulk or CECrystal"
raise TypeError(msg)
calc2 = CE(large_bc, eci, initial_cf=init_cf)
return calc2
# dictionary
kwargs = {
"crystalstructure":"fcc",
"a":4.05,
"size":[3, 3, 3],
"basis_elements":[["Al","Mg"]],
"db_name": db_name,
"conc_args": conc_args,
"max_cluster_size": 3
}
# In this example, we just use some example ecis
eci = get_example_ecis(bc_kwargs=kwargs)
# Initialize a template CEBulk Object
ceBulk = CEBulk( **kwargs )
ceBulk.reconfigure_settings() # Nessecary for the unittests to pass
# Now we want to get a Cluster Expansion calculator for a big cell
mc_cell_size = [10,10,10]
from cemc import get_ce_calc
calc = get_ce_calc( ceBulk, kwargs, eci=eci, size=mc_cell_size, db_name="mc_obs.db")
ceBulk = calc.BC
ceBulk.atoms.set_calculator(calc)
conc = {
"Al":0.8,
"Mg":0.2
}
calc.set_composition(conc)