コード例 #1
0
    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)
コード例 #2
0
def find_gs(formula="MgSi"):
    ceBulk = get_ce_with_calc()
    symbs = ["Mg" for _ in range(len(ceBulk.atoms))]

    if formula == "MgSi":
        for i in range(int(len(symbs) / 2), len(symbs)):
            symbs[i] = "Si"
    elif formula == "Mg3Si":
        for i in range(int(3 * len(symbs) / 4), len(symbs)):
            symbs[i] = "Si"
    ceBulk.atoms.get_calculator().set_symbols(symbs)
    gs = GSFinder()
    temps = np.linspace(1.0, 1500, 30)[::-1]
    result = gs.get_gs(ceBulk, temps=temps, n_steps_per_temp=10000)
    fname = "data/ground_state{}.xyz".format(formula)

    from ase.io import write
    write(fname, result["atoms"])
    print("Atoms written to {}".format(fname))
コード例 #3
0
def gs_struct(bc):
    from cemc.tools import GSFinder
    from ase.visualize import view
    with open("data/eci_aucu.json", 'r') as infile:
        eci = json.load(infile)
    struct_gen = GenerateStructures(bc, struct_per_gen=20)
    conc = np.arange(0.25, 0.75)
    conc = [0.25, 0.75]
    for au_conc in conc:
        comp = {"Au": au_conc, "Cu": 1.0 - au_conc}
        T = [800, 700, 600, 500, 400, 300, 200, 100, 50, 20, 10]
        nsteps_per_temp = 100 * len(bc.atoms)
        finder = GSFinder()
        gs = finder.get_gs(bc, eci, composition=comp, n_steps_per_temp=nsteps_per_temp, temps=T)
        try:
            # view(gs["atoms"])
            # struct_gen.insert_structure(init_struct=gs["atoms"])
            fname = "Emin_structure_{}_{}.xyz".format(int(au_conc*100), time.time())
            write(fname, gs["atoms"])
        except Exception as exc:
            print(exc)
コード例 #4
0
ファイル: pre_beta.py プロジェクト: davidkleiven/GPAWTutorial
def insert_gs_struct(bs,struct_gen,n_structs=20):
    n_X = 16
    N = float(len(bs.atoms))
    assert len(bs.atoms) == 40
    gs_searcher = GSFinder()
    # fixed_vac = FixedElement(element="X")
    # gs_searcher.add_constraint(fixed_vac)
    counter = 0
    with open(eci_fname,'r') as infile:
        ecis = json.load(infile)

    for _ in range(n_structs):
        natoms = len(bs.atoms)-n_X
        max_Si = 0.5

        n_si = 0
        for atom in bs.atoms:
            if atom.symbol == "X":
                continue
            val = rand()
            if val < 0.05:
                atom.symbol = "Al"
            elif val < 0.7:
                atom.symbol = "Mg"
            else:
                atom.symbol = "Si"
                n_si += 1
            if ( n_si/N > 0.5 ):
                continue
        T = np.linspace(50,2000,20)[::-1]
        result = gs_searcher.get_gs(bs, ecis, temps=T)
        fname = "data/gs_serach.xyz"
        write(fname, result["atoms"])
        print ("Lowest energy: {} eV".format(result["energy"]/natoms))
        try:
            struct_gen.insert_structure( init_struct=fname )
            counter += 1
        except Exception as exc:
            print (str(exc))
    print ("Insert {} ground state strutures".format(counter))
コード例 #5
0
def main():
    folder = "/home/gudrun/davidkl/Documents/GPAWTutorial/AlMgSiMC/data"
    fname = folder + "/MgSi_mgsi_free_eng.xyz"
    atoms_read = wrap_and_sort_by_position(read(fname))
    db_energy = -218.272/64

    symbols = [atom.symbol for atom in atoms_read]


    T = np.linspace(100.0, 1300.0, 20)[::-1].tolist()
    #T = [300]
    atoms = get_atoms()
    symbols = ["Mg"]*1024 + ["Si"]*1024
    atoms.get_calculator().set_symbols(symbols)
    print("Init energy: {}".format(atoms.get_calculator().get_energy()))
    print(db_energy, atoms.get_calculator().get_energy()/len(atoms))
    #assert abs(db_energy - atoms.get_calculator().get_energy()/len(atoms)) < 1E-3

    gs = GSFinder()
    bc = atoms.get_calculator().BC
    res = gs.get_gs(bc, temps=T, n_steps_per_temp=1000000, atoms=atoms)
    print(res["energy"])
    write("data/mgsi_gs_bcs.xyz", res["atoms"])
コード例 #6
0
def find_gs( BC, mg_conc, vac_conc ):
    composition = {
        "Mg":mg_conc,
        "X":vac_conc,
        "Al":1.0-mg_conc-vac_conc
    }

    print ("Reading ECIs from {}".format(eci_fname))
    with open( eci_fname, 'r') as infile:
        ecis = json.load( infile )

    T = [1000,800,600,400,200,100,50,20,10,5,1]
    n_steps_per = 5000
    gsfinder = GSFinder()
    result = gsfinder.get_gs( BC, ecis, composition=composition, temps=T, n_steps_per_temp=n_steps_per )
    atoms = result["atoms"]
    formula = atoms.get_chemical_formula()
    outfname = "data/gs_fcc_vac_{}_{}mev.xyz".format( formula, int(result["energy"]*1000) )
    write( outfname, atoms )
    print ("GS energy: {} eV".format(result["energy"]) )
    print ("Structure written to {}".format(outfname) )
    print (result["cf"])
    return outfname
コード例 #7
0
# Loop over temperatures
for T in temps:
    mc_obj = Montecarlo(atoms, T)

    # Give the Lowest Energy Structure a reference to the monte carlo object
    obs.mc_obj = mc_obj

    # Attach the observer to the monte carlo object
    mc_obj.attach(obs)

# The Ground State Atoms object can now be obtained
gs_atoms = obs.lowest_energy_atoms

# A simpler approach that essentially follow exactly the same procedure
# as above is to use the GSFinder class
from cemc.tools import GSFinder
gs_search = GSFinder()
gs = gs_search.get_gs(bc,
                      eci,
                      temps=temps,
                      n_steps_per_temp=100,
                      composition=composition)
"""
gs is now a dictionary with the following form
{
    "atoms": the structure having the lowest energy
    "energy": Energy of that structure
    "cf": The correlation functions of the structure with the lowest energy
}
"""
コード例 #8
0
ファイル: ex_ground_state.py プロジェクト: phymalidoust/CEMC
# Now we import the Monte Carlo class
from cemc.mcmc.montecarlo import Montecarlo

# Loop over temperatures
for T in temps:
    mc_obj = Montecarlo(bc.atoms, T)

    # Give the Lowest Energy Structure a reference to the monte carlo object
    obs.mc_obj = mc_obj

    # Attach the observer to the monte carlo object
    mc_obj.attach(obs)

# The Ground State Atoms object can now be obtained
gs_atoms = obs.lowest_energy_atoms

# A simpler approach that essentially follow exactly the same procedure
# as above is to use the GSFinder class
from cemc.tools import GSFinder
gs_search = GSFinder()
gs = gs_search.get_gs(bc, eci, temps=temps, n_steps_per_temp=100)
"""
gs is now a dictionary with the following form
{
    "atoms": the structure having the lowest energy
    "energy": Energy of that structure
    "cf": The correlation functions of the structure with the lowest energy
}
"""