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 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 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 (cetype == "CECrystal"): small_bc = CECrystal(**bc_kwargs) small_bc.reconfigure_settings() self._check_eci(small_bc, eci) atoms = get_atoms_with_ce_calc(small_bc, bc_kwargs, eci=eci, size=size) calc = atoms.get_calculator() calc.set_composition(composition) formula = 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(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(atoms, energy=Emin) atoms.set_calculator(scalc) outfname = "BC_wanglandau_{}.pkl".format(atoms.get_chemical_formula()) with open(outfname, 'wb') as outfile: pck.dump((calc.BC, atoms), outfile) kvp = { "Emin": Emin, "Emax": Emax, "bcfile": outfname, "cetype": self.cetype } data["bc_kwargs"] = small_bc.kwargs data["supercell_size"] = size db.write(atoms, key_value_pairs=kvp, data=data)
def test_ignore_atoms(self): if not has_ase_with_ce: self.skipTest("ASE does not have CE") from cemc.mcmc import FixedElement no_trow = True msg = "" try: from copy import deepcopy conc = Concentration(basis_elements=[['V', 'Li'], ['O']]) kwargs = { "crystalstructure": "rocksalt", "concentration": conc, "a": 4.12, 'size': [2, 2, 2], 'cubic': True, "max_cluster_size": 4, "max_cluster_dia": 4.12, "db_name": 'database.db', 'basis_function': 'sluiter', 'ignore_background_atoms': True } fix_elem = FixedElement(element="O") kw_args_cpy = deepcopy(kwargs) ceBulk = CEBulk(**kw_args_cpy) ecis = get_example_ecis(ceBulk) atoms = get_atoms_with_ce_calc(ceBulk, kwargs, eci=ecis, size=[3, 3, 3], db_name="ignore_test_large.db") calc = atoms.get_calculator() # Insert some Li atoms num_li = 5 symbols = [atom.symbol for atom in atoms] num_inserted = 0 for i in range(0, len(symbols)): if symbols[i] == "V": symbols[i] = "Li" num_inserted += 1 if num_inserted >= num_li: break calc.set_symbols(symbols) mc = Montecarlo(atoms, 800) mc.add_constraint(fix_elem) mc.runMC(steps=100, equil=False, mode="fixed") # Clean up files os.remove("ignore_test_large.db") os.remove("database.db") except Exception as exc: no_trow = False msg = str(exc) self.assertTrue(no_trow, msg=msg)
def test_self_interactions(self): if not has_ase_with_ce: self.skipTest("ASE does not have CE") from cemc.ce_calculator import SelfInteractionError a = 4.05 conc = Concentration(basis_elements=[["Au", "Cu", "Ti"]]) db_name = "test_self_interactoins.db" kwargs = dict(crystalstructure="fcc", a=a, size=[3, 3, 3], concentration=conc, db_name=db_name, max_cluster_size=2, max_cluster_dia=5.0) ceBulk = CEBulk(**kwargs) atoms = get_atoms_with_ce_calc(ceBulk, kwargs, eci={'c0': 1.0}, size=[8, 8, 8], db_name=db_name) with self.assertRaises(SelfInteractionError): atoms = get_atoms_with_ce_calc(ceBulk, kwargs, eci={'c0': 1.0}, size=[1, 1, 1], db_name=db_name) os.remove(db_name)
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]], } conc = Concentration(basis_elements=[["Al", "Mg"]]) kwargs = { "crystalstructure": "fcc", "a": 4.05, "size": [3, 3, 3], "concentration": conc, "db_name": "temporary_bcnucleationdb.db", "max_cluster_size": 3, "max_cluster_dia": 4.5 } 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) ) atoms = get_atoms_with_ce_calc(ceBulk, kwargs, ecis, size=[6, 6, 6], db_name="sc6x6x6.db") chem_pot = {"c1_0": -1.069} T = 300 mc = SGCFreeEnergyBarrier( 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(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 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 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 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..." )
def test_supercell(self): if not has_ase_with_ce: self.skipTest("ASE version does not have CE") return atoms, ceBulk, eci = self.get_calc("fcc") calc = atoms.get_calculator() db_name = "test_db_fcc_super.db" 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": 6.0 } kwargs_template = copy.deepcopy(kwargs) kwargs_template["size"] = [4, 4, 4] kwargs_template["db_name"] = "template_bc.db" template_supercell_bc = CEBulk(**kwargs_template) template_supercell_bc.reconfigure_settings() ceBulk = CEBulk(**kwargs) ceBulk.reconfigure_settings() atoms_sc = get_atoms_with_ce_calc(ceBulk, kwargs, eci, size=[4, 4, 4], db_name="sc4x4x.db") calc_sc = atoms_sc.get_calculator() corr_func = CorrFunction(template_supercell_bc) for i in range(10): calc_sc.calculate(atoms_sc, ["energy"], [(i, "Al", "Mg")]) updated_cf = calc_sc.get_cf() brute_force = corr_func.get_cf_by_cluster_names( atoms_sc, list(updated_cf.keys())) for key, value in brute_force.items(): self.assertAlmostEqual(value, updated_cf[key]) os.remove("sc4x4x.db")
def sa(au_comp, kwargs, eci, db_name, size): bc = CEBulk(**kwargs) atoms = get_atoms_with_ce_calc(bc, kwargs, eci, size) temperatures = [800, 700, 600, 500, 400, 300, 200, 100, 50, 25, 10] N = len(bc.atoms) # Define parameters for equillibration equil_params = { "maxiter": 10 * N, "mode": "fixed" } comps = [0.05, 0.1, 0.15, 0.2, 0.25, 0.30, 0.35, 0.40, 0.45, 0.50, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95] nsteps = 100 * N calc = atoms.get_calculator() for au_comp in comps: comp = { "Au": au_comp, "Cu": 1.0-au_comp } calc.set_composition(comp) for T in temperatures: mc = Montecarlo(atoms, T) mc.runMC(mode="fixed", steps=nsteps, equil_params=equil_params) thermo = mc.get_thermodynamic() thermo["converged"] = True thermo["au_conc"] = au_comp 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()) write(fname, atoms)
} # 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 unittest 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_atoms_with_ce_calc atoms = get_atoms_with_ce_calc(ceBulk, kwargs, eci=eci, size=mc_cell_size, db_name="sgc_large.db") # In the SGC ensemble the simulation is run at fixed chemical potential # The chemical potentials are subtracted from the singlet terms # Those are ECIs starting with c1. # In a binary system there is only one singlet term, so there is only one # chemical potential to specify chem_pot = {"c1_0": -1.04} # Speciy the temperature T = 400 from cemc.mcmc import SGCMonteCarlo
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)