Exemplo n.º 1
0
def sa(al_comp, kwargs, eci, db_name, size, lattice):
    comp = {"Al": al_comp, "Zn": 1.0 - al_comp}

    bc = BulkCrystal(**kwargs)
    calc = get_ce_calc(bc, kwargs, eci, size)
    bc = calc.BC
    bc.atoms.set_calculator(calc)
    temperatures = [800, 700, 600, 500, 400, 300, 200, 100]
    N = len(bc.atoms)

    if rank == 0:
        print("Supercell has {} atoms".format(N))

    # Define parameters for equillibration
    equil_params = {"maxiter": 10 * N, "mode": "fixed"}

    nsteps = 100 * N
    calc.set_composition(comp)
    for T in temperatures:
        mc = Montecarlo(bc.atoms, T, mpicomm=comm)
        mc.runMC(mode="fixed", steps=nsteps, equil_params=equil_params)
        thermo = mc.get_thermodynamic()
        thermo["converged"] = True
        thermo["al_conc"] = al_comp
        thermo["temperature"] = T
        if rank == 0:
            db = dataset.connect("sqlite:///{}".format(db_name))
            tbl = db["results"]
            tbl.insert(thermo)

    if rank == 0:
        fname = "data/atoms_{}_{}.xyz".format(lattice,
                                              bc.atoms.get_chemical_formula())
        write(fname, bc.atoms)
    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 run(T, mg_conc, si_conc, precs):
    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]]
    }
    orig_spin_dict = {
        "Mg": 1.0,
        "Si": -1.0,
        "Al": 0.0
    }

    kwargs = {
        "crystalstructure": "fcc",
        "a": 4.05,
        "size": [4, 4, 4],
        "basis_elements": [["Mg", "Si", "Al"]],
        "conc_args": conc_args,
        "db_name": "data/almgsi.db",
        "max_cluster_size": 4
    }
    ceBulk = BulkCrystal(**kwargs)
    ceBulk.spin_dict = orig_spin_dict
    ceBulk.basis_functions = ceBulk._get_basis_functions()
    ceBulk._get_cluster_information()
    eci_file = "data/almgsi_fcc_eci.json"
    with open(eci_file, 'r') as infile:
        ecis = json.load(infile)
    print(ecis)
    #calc = CE( ceBulk, ecis, size=(3,3,3) )
    calc = get_ce_calc(ceBulk, kwargs, ecis, size=[10, 10, 10])
    ceBulk = calc.BC
    ceBulk.atoms.set_calculator(calc)

    comp = {
        "Mg": mg_conc,
        "Si": si_conc,
        "Al": 1.0 - mg_conc - si_conc
    }
    calc.set_composition(comp)
    for temp, prec in zip(T, precs):
        print("Current temperature {}K".format(temp))
        mc_obj = Montecarlo(ceBulk.atoms, temp, mpicomm=comm)
        mode = "prec"
        mc_obj.runMC(mode=mode, prec=prec)
        thermo = mc_obj.get_thermodynamic()
        thermo["temperature"] = temp
        thermo["prec"] = prec
        thermo["internal_energy"] = thermo.pop("energy")
        thermo["converged"] = True
        thermo["prec"] = prec

        if (rank == 0):
            db = dataset.connect("sqlite:///{}".format(mc_db_name))
            tbl = db["results"]
            thermo["sysID"] = sysID
            tbl.insert(thermo)
def main():
    energies = []
    sizes = list(range(1, 6))
    atoms = get_atoms()
    two_atoms(atoms)
    exit()
    insert_np(6, atoms)

    mc = Montecarlo(atoms, 0.1)
    camera = Snapshot(atoms=mc.atoms, trajfile="/work/sophus/nuc_cluster.traj")
    db = dataset.connect("sqlite:////work/sophus/mgsi_nuc_barrier_kamijo.db")
    tbl = db["systems"]
    mc.attach(camera, interval=100 * len(atoms))
    num_mg = sum(1 for atom in atoms if atom.symbol == "Mg")
    while num_mg > 2:

        print(atoms.get_chemical_formula())
        mc.runMC(mode="fixed", equil=False, steps=100 * len(atoms))
        thermo = mc.get_thermodynamic()
        tbl.insert(thermo)

        # Remove one Mg atom and one Si atom
        symbols = [a.symbol for a in atoms]
        for i in range(20):
            i = symbols.index("Si")
            symbols[i] = "Al"
            i = symbols.index("Mg")
            symbols[i] = "Al"
        mc.set_symbols(symbols)
        num_mg = sum(1 for atom in atoms if atom.symbol == "Mg")
Exemplo n.º 5
0
def pure_phase_entropy(small_bc):
    from cemc.mcmc import Montecarlo
    from ase.clease.tools import wrap_and_sort_by_position
    from ase.io import read
    from cemc.mcmc import SiteOrderParameter, Snapshot
    import dataset
    T = [1, 5, 10, 20, 30, 40, 50, 75, 100, 150, 200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 
         320, 330, 340, 350, 360, 370, 380, 390, 400, 420, 440, 460, 480, 500]
    calc = get_ce_calc(small_bc, kwargs, ecis, size=[10, 10, 10], db_name="data/db10x10x10Al3Mg.db")
    bc = calc.BC
    bc.atoms.set_calculator(calc)
    atoms = read("data/al3mg_template.xyz")
    atoms = wrap_and_sort_by_position(atoms)
    symbs = [atom.symbol for atom in atoms]
    calc.set_symbols(symbs)
    
    site_order = SiteOrderParameter(bc.atoms)
    db = dataset.connect("sqlite:///data/pure_al3mg3.db")
    syst = db["thermodynamic"]
    camera = Snapshot(trajfile="data/pure_phase_entropy.traj", atoms=bc.atoms)
    for temp in T:
        print("Current temperature: {}K".format(temp))
        site_order.reset()
        mc = Montecarlo(bc.atoms, temp)
        mc.attach(site_order)
        mc.attach(camera, interval=50000)
        equil_param = {"window_length": 100000, "mode": "fixed"}
        mc.runMC(mode="fixed", steps=500000, equil=True, equil_params=equil_param)
        mean, stddev = site_order.get_average()
        thermo = mc.get_thermodynamic()
        thermo["site_order"] = mean
        thermo["site_order_std"] = stddev
        syst.insert(thermo)
Exemplo n.º 6
0
 def _estimate_internal_energy(self, conc, sweeps=2):
     """
     Estimates the internal energy of one structure
     """
     try:
         self.atoms._calc.set_composition(conc)
         mc = Montecarlo(self.atoms, self.temperature)
         mc.runMC(mode="fixed", steps=sweeps * len(self.atoms), equil=False)
         energy = mc.get_thermodynamic()["energy"]
     except TooFewElementsError as exc:
         energy = 1.0
     return energy
Exemplo n.º 7
0
    def test_no_throw(self):
        if not available:
            self.skipTest(import_msg)

        ceBulk, atoms = self.init_bulk_crystal()
        mc = Montecarlo(atoms, 100.0)
        mc.insert_symbol_random_places("Mg", num=5, swap_symbs=["Al"])
        mc.insert_symbol_random_places("Si", num=5, swap_symbs=["Al"])
        par_temp = ParallelTempering(mc_obj=mc, Tmax=100.0, Tmin=0.001)
        mc_args = {"steps": 100, "equil": False}
        par_temp.run(mc_args=mc_args, num_exchange_cycles=3)
        os.remove("temp_scheme.csv")
    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)
Exemplo n.º 9
0
def main(size, T):
    atoms = create_surface(size)
    atoms = wrap_and_sort_by_position(atoms)
    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 = BulkCrystal(**kwargs)
    eci_file = "data/almgsi_fcc_eci_newconfig.json"
    with open(eci_file, 'r') as infile:
        ecis = json.load(infile)
    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)
    ceBulk = calc.BC
    ceBulk.atoms.set_calculator(calc)

    mc = Montecarlo(ceBulk.atoms, T)
    symbs = [atom.symbol for atom in atoms]
    mc.set_symbols(symbs)

    # Write a copy of the current atoms object
    from ase.io import write
    shape_str = "-".join((str(item) for item in size))
    uid_str = "{}K_{}".format(T, shape_str)
    write(WORKDIR + "initial_config{}.xyz".format(uid_str), mc.atoms)

    backup = MCBackup(mc,
                      backup_file=WORKDIR + "backup{}.xyz".format(uid_str),
                      db_name=WORKDIR + "mc_surface.db")
    camera = Snapshot(atoms=mc.atoms,
                      trajfile=WORKDIR + "surface{}.traj".format(uid_str))
    evol = EnergyEvolution(mc)
    nsteps = int(10E6)
    mc.attach(backup, interval=100000)
    mc.attach(camera, interval=int(nsteps / 20))
    mc.attach(evol, interval=10 * len(mc.atoms))
    mc.runMC(mode="fixed", steps=nsteps, equil=False)
    write(WORKDIR + "final_config{}.xyz".format(uid_str), mc.atoms)
Exemplo n.º 10
0
def run(maxT, minT, n_temp, mg_conc):
    T = np.linspace(minT, maxT, n_temp)[::-1]
    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_bcdb.db",
        "max_cluster_size": 4
    }
    ceBulk = BulkCrystal(**kwargs)
    print(ceBulk.basis_functions)

    eci_file = "data/ce_hydrostatic.json"
    with open(eci_file, 'r') as infile:
        ecis = json.load(infile)
    print(ecis)
    #calc = CE( ceBulk, ecis, size=(3,3,3) )
    calc = get_ce_calc(ceBulk, kwargs, ecis, size=[10, 10, 10])
    ceBulk = calc.BC
    ceBulk.atoms.set_calculator(calc)
    comp = {"Al": 1.0 - mg_conc, "Mg": mg_conc}
    calc.set_composition(comp)
    print("Number of atoms: {}".format(len(ceBulk.atoms)))
    for temp in T:
        print("Current temperature {}K".format(temp))
        mc_obj = Montecarlo(ceBulk.atoms, temp, mpicomm=comm)
        mode = "prec"
        prec = 1E-5
        mc_obj.runMC(mode=mode, prec=prec)
        thermo = mc_obj.get_thermodynamic()
        thermo["temperature"] = temp
        thermo["prec"] = prec
        thermo["internal_energy"] = thermo.pop("energy")
        thermo["converged"] = True

        if (rank == 0):
            db = connect(mc_db_name)
            db.write(ceBulk.atoms, key_value_pairs=thermo)
Exemplo n.º 11
0
    def test_no_throw(self):
        if not available:
            self.skipTest(import_msg)

        msg = ""
        no_throw = True
        try:
            ceBulk = self.init_bulk_crystal()
            mc = Montecarlo(ceBulk.atoms, 100.0)
            mc.insert_symbol_random_places("Mg", num=5, swap_symbs=["Al"])
            mc.insert_symbol_random_places("Si", num=5, swap_symbs=["Al"])
            par_temp = ParallelTempering(mc_obj=mc, Tmax=100.0, Tmin=0.001)
            mc_args = {"steps": 100, "equil": False}
            par_temp.run(mc_args=mc_args, num_exchange_cycles=3)
            os.remove("temp_scheme.csv")
        except Exception as exc:
            msg = "{}: {}".format(type(exc).__name__, str(exc))
            no_throw = False
        self.assertTrue(no_throw, msg=msg)
Exemplo n.º 12
0
def perform_mc(uid):
    from ase.io import read
    from cemc.mcmc import Montecarlo
    db = dataset.connect(PHASE_DIAG_DB)
    tbl = db["simulation_plan"]
    row = tbl.find_one(id=uid)
    print(row)
    temperatures = list(np.arange(1, 600, 50))

    ceBulk = get_ce_with_calc()
    swap_symbs = row["swap_new"].split("-")
    current = 0
    if row["phase"] == "mgsi":
        atoms = read("data/ground_stateMgSi.xyz")
        symbols = [atom.symbol for atom in atoms]
    else:
        symbols = ["Al" for _ in range(len(ceBulk.atoms))]

    num_inserted = np.zeros(len(swap_symbs))

    for i in range(len(symbols)):
        if symbols[i] == row["swap_old"]:
            symbols[i] = swap_symbs[current]
            num_inserted[current] += 1
        if num_inserted[-1] >= row["num_insert"]:
            break
        elif num_inserted[current] >= row["num_insert"]:
            current += 1
        elif num_inserted[current] >= row["num_insert"]:
            current += 1

    ceBulk.atoms.get_calculator().set_symbols(symbols)
    result_tab = db["simulations"]
    for T in temperatures:
        print("Current temperature: {}".format(T))
        mc = Montecarlo(ceBulk.atoms, T)
        equil_params = {"mode": "fixed", "maxiter": 10000}
        mc.runMC(steps=1000 * len(symbols), equil_params=equil_params)
        thermo = mc.get_thermodynamic()
        thermo["runID"] = uid
        result_tab.insert(thermo)
Exemplo n.º 13
0
    def get_thermodynamic(self):
        """
        Override the thermodynamics function.

        Normalization of the averagers:
        The values in average track should represent the ratio
        between partition functions when one have one extra of the
        inserted atom and one less of the removed atom.
        In the high temperature limit this is given by

        Z_{n+1} = N!/((n+1)!(N-n-1)!)

        and

        Z_n = N!/(n!(N-n)!)

        where N is the overall number of atoms of the two atoms being swapped.
        Hence, the ratio becomes

        Z_{n+1}/Z_n = (N-n)/(n+1),

        the sums are normalized such that they results in this value
        at high temperatures.

        :return: dict with the thermodynamical properties
        """
        self.collect_results()
        res = {}
        res = Montecarlo.get_thermodynamic(self)
        at_count = self.count_atoms()

        # Inser the insertion enegies
        for move in self.insertion_moves:
            key = self.get_key(move[0], move[1])
            name = "insert_energy_{}".format(key)
            N = self.averager_track[key].num_samples
            inf_temp = float(at_count[move[0]]) / (at_count[move[1]] + 1)
            E0 = self.averager_track[key].ref_value

            res[name] = E0 - kB * self.T * \
                np.log(self.averager_track[key].average * inf_temp)

            name = "raw_insert_energy_{}".format(key)
            res[name] = self.raw_insertion_energy[key] / N

            name = "boltzmann_avg_insert_energy_{}".format(key)
            res[name] = self.boltzmann_weight_ins_energy[key].average / \
                self.averager_track[key].average

            name = "boltzmann_avg_insert_energy_sq_{}".format(key)
            res[name] = self.boltzmann_weight_ins_eng_sq[key].average / \
                self.averager_track[key].average
        return res
    def _accept(self, system_changes):
        """Accept trial move.

        :param list system_changes: Proposed changes

        :return: True/False, if True the move is accepted
        :rtype: bool
        """
        move_accepted = Montecarlo._accept(self, system_changes)

        if not self.move_ok():
            return False
        return move_accepted
Exemplo n.º 15
0
 def _get_trial_move(self):
     """Perform a trial move."""
     if not self.nuc_sampler.is_in_window(self.network):
         self.network(None)
         msg = "System is outside the window before the trial move "
         msg += "is performed!\n"
         raise RuntimeError(msg)
         #stat = self.network.get_statistics()
         #num_clusters = stat["number_of_clusters"]
         #max_size = stat["max_size"]
         #lower,upper = self.nuc_sampler.get_window_boundaries(self.nuc_sampler.current_window)
         #msg += "Num. clusters: {}. Max size: {}. Window limits: [{},{})".format(num_clusters,max_size,lower,upper)
     return Montecarlo._get_trial_move(self)
Exemplo n.º 16
0
    def get_gs(self,
               BC,
               ecis=None,
               composition=None,
               temps=None,
               n_steps_per_temp=1000,
               atoms=None):
        """
        Computes the ground states

        :param BC: Instance of *CEBulk* or *CECrystal* from ASE
        :param ecis: Dictionary with the Effecitve Cluster Interactions
        :param composition: Dictionary with compositions (i.e. {"Mg":0.2,"Al":0.8})
        :param temps: List of cooling temperatures
        :param n_steps_per_temp: Number of MC steps per temperature
        """
        if atoms is None:
            atoms = BC.atoms.copy()

        if atoms.get_calculator() is None:
            if ecis is None:
                raise ValueError("When a calculator is not attached "
                                 "the ECIs has to be given!")
            calc = CE(atoms, BC, ecis)
        else:
            calc = atoms.get_calculator()
        #print (calc.get_cf())
        if (temps is None):
            temps = np.linspace(1, 1500, 30)[::-1]
        if (composition is not None):
            calc.set_composition(composition)

        minimum_energy = LowestEnergyStructure(calc, None)
        for T in temps:
            print("Temperature {}".format(T))
            mc_obj = Montecarlo(atoms, T)
            mc_obj.constraints = self.constraints
            minimum_energy.mc_obj = mc_obj
            mc_obj.attach(minimum_energy)
            mc_obj.runMC(steps=n_steps_per_temp, verbose=False, equil=False)
            thermo = mc_obj.get_thermodynamic()

        result = {
            "atoms": minimum_energy.atoms,
            "energy": minimum_energy.lowest_energy,
            "cf": minimum_energy.lowest_energy_cf
        }
        return result
Exemplo n.º 17
0
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)
Exemplo n.º 18
0
    def runMC(self, steps=100000, init_cluster=True, elements={}, equil=False):
        """
        Run Monte Carlo for fixed nucleus size

        :param int steps: Number of Monte Carlo steps
        :param bool init_cluster: If True initialize a cluster, If False it is
            assumed that a cluster of the correct size already exists in the
            system
        :param dict elements: Elements in the cluster
        """
        if init_cluster:
            self._check_nucleation_site_exists()
            self.grow_cluster(elements)
        self.network.collect_statistics = False

        # Call one time
        self.network([])

        if self.network.num_root_nodes() > 1:
            raise ValueError("Something went wrong during construction! "
                             "the system has more than one cluster!")
        self.update_current_energy()
        Montecarlo.runMC(self, steps=steps, equil=equil)
Exemplo n.º 19
0
def run(N, T):
    bc = init_bc(N)
    mc = Montecarlo(bc.atoms, T)
    nanop = get_nanoparticle()
    symbs = insert_nano_particle(bc.atoms.copy(), nanop)
    mc.set_symbols(symbs)
    order_param = SiteOrderParameter(mc.atoms)
    nsteps = int(1E6)
    equil_params = {"mode": "fixed", "window_length": int(1E5)}
    mc.attach(order_param)
    mc.runMC(steps=nsteps, equil=True, equil_params=equil_params)
    thermo = mc.get_thermodynamic()
    mean, std = order_param.get_average()
    thermo["order_param_mean"] = mean
    thermo["order_param_std"] = std
    thermo.update(equil_params)
    db = dataset.connect("sqlite:///{}".format(mc_db_name))
    tbl = db["cluster_stability"]
    tbl.insert(thermo)
    fname = workdir + "/final_structure{}K.xyz".format(T)
    write(fname, mc.atoms)
Exemplo n.º 20
0
    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 plot_evolution(fname):
    mc = Montecarlo.load(fname)
    atoms_fname = fname.rpartition(".")[0]+"_final_atoms.xyz"
    write(atoms_fname, mc.atoms)
    energy_obs = None
    for obs in mc.observers:
        if obs[1].name == "EnergyEvolution":
            energy_obs = obs[1]

    if energy_obs is None:
        raise RuntimeError("Did not find an energy evolution observer!")

    energy = energy_obs.energies
    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    ax.plot(energy)
    plt.show()
Exemplo n.º 22
0
    def _accept(self, system_changes):
        """Accept trial move.

        :param list system_changes: Proposed changes

        :return: True/False, if True the move is accepted
        :rtype: bool
        """
        # Note that we have to call the parent's accept first,
        # as the _mc_step function assumes that an energy
        # evaluation have been performed, prior to accepting
        # or rejecting the move
        move_accepted = Montecarlo._accept(self, system_changes)
        if self.network.move_creates_new_cluster(system_changes):
            return False

        # if not self.move_ok():
        #     return False
        return move_accepted
Exemplo n.º 23
0
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=",")
Exemplo n.º 24
0
def gs_mgsi():
    atoms = get_atoms(cubic=True)

    symbs = ["Mg" for _ in range(len(atoms))]
    for i in range(int(len(symbs) / 2)):
        symbs[i] = "Si"
    atoms.get_calculator().set_symbols(symbs)

    T = [
        1500, 1400, 1300, 1200, 1100, 1000, 900, 800, 600, 500, 400, 300, 200,
        100, 50
    ]
    snap = Snapshot(trajfile="mgsi_gs_search.traj", atoms=atoms)
    for temp in T:
        print("Temperature {}K".format(temp))
        mc = Montecarlo(atoms, temp)
        mc.attach(snap, interval=10 * len(atoms))
        mc.runMC(mode="fixed", steps=100 * len(atoms), equil=False)
Exemplo n.º 25
0
def run_huge():
    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",
        "size":[4,4,4],
        "basis_elements":[["Al","Mg","Si"]],
        "conc_args":conc_args,
        "db_name":"some_db.db",
        "max_cluster_size":4,
        "a":4.05,
        "ce_init_alg":"fast"
    }
    ceBulk = BulkCrystal( **kwargs )

    with open(eci_file, 'r') as infile:
        eci = json.load(infile)
    calc = get_ce_calc(ceBulk, kwargs, eci=eci, size=[50,50,50])
    calc.BC.atoms.set_calculator(calc)
    print(calc.BC.basis_functions)

    comp = {
        "Al":0.9,
        "Mg":0.05,
        "Si":0.05
    }
    calc.set_composition(comp)

    T = 150
    T = [2000, 1500, 1200, 1000, 800, 600, 400, 293]
    camera = Snapshot(trajfile=traj_file, atoms=calc.BC.atoms)
    for temp in T:
        print("Current temperature {}K".format(temp))
        mc = Montecarlo(calc.BC.atoms, temp)
        mc.attach(camera, interval=125000*20)
        mc.runMC(mode="fixed", steps=125000*100, equil=False)
Exemplo n.º 26
0
def run(T,mg_conc):
    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_bcdb.db",
        "max_cluster_size":4
    }
    ceBulk = BulkCrystal( **kwargs )
    print (ceBulk.basis_functions)

    eci_file = "data/ce_hydrostatic.json"
    with open( eci_file, 'r' ) as infile:
        ecis = json.load( infile )
    print (ecis)
    #calc = CE( ceBulk, ecis, size=(3,3,3) )
    calc = get_ce_calc( ceBulk, kwargs, ecis, size=[10,10,10], free_unused_arrays_BC=True )
    ceBulk = calc.BC
    ceBulk.atoms.set_calculator( calc )
    comp = {
        "Al":1.0-mg_conc,
        "Mg":mg_conc
    }
    calc.set_composition(comp)
    mc_obj = Montecarlo( ceBulk.atoms, T, mpicomm=comm )
    pairs = PairCorrelationObserver( calc )
    network = NetworkObserver( calc=calc, cluster_name="c2_1414_1", element="Mg", nbins=100 )
    mode = "fixed"
    camera = Snapshot( "data/precipitation.traj", atoms=ceBulk.atoms )
    mc_obj.attach( camera, interval=10000 )
    mc_obj.attach( pairs, interval=1 )
    mc_obj.attach( network, interval=500 )
    mc_obj.runMC( mode=mode, steps=10000, equil=True )

    pair_mean = pairs.get_average()
    pair_std = pairs.get_std()

    if ( rank == 0 ):
        data = {
            "pairs":pair_mean,
            "pairs_std":pair_std,
            "mg_conc":mg_conc,
            "temperature":T
        }
        pairfname = "data/precipitation_pairs/precipitation_pairs_{}_{}K.json".format(int(1000*mg_conc),int(T))
        with open(pairfname,'w') as outfile:
            json.dump(data,outfile,indent=2, separators=(",",":"))
        print ( "Thermal averaged pair correlation functions written to {}".format(pairfname) )
        atoms = network.get_atoms_with_largest_cluster()

    data = network.get_statistics() # This collects the histogram data from all processors
    size,occurence = network.get_size_histogram()
    data["histogram"] = {}
    data["histogram"]["size"] = size.tolist()
    data["histogram"]["occurence"] = occurence.tolist()
    data["temperature"] = T
    data["mg_conc"] = mg_conc

    cluster_fname = "data/cluster_statistics_{}_{}K.json".format(int(1000*mg_conc),int(T))
    atoms_fname = "data/largest_cluster_{}_{}K.cif".format( int(1000*mg_conc), int(T) )

    if ( rank == 0 ):
        print (occurence)

    if ( rank == 0 ):
        try:
            with open( cluster_fname,'r') as infile:
                data = json.load(infile)
            old_size = np.array(data["histogram"]["size"])
            old_hist = np.array(data["histogram"]["occurence"])
            if ( np.allclose(old_size,size) ):
                occurence += old_hist
                data["histogram"]["occurence"] = occurence.tolist()
        except Exception as exc:
            print (str(exc))

        with open( cluster_fname, 'w' ) as outfile:
            json.dump( data, outfile, indent=2, separators=(",",":") )
        print ("Cluster statistics written to {}".format(cluster_fname) )
        write( atoms_fname, atoms )
        print ("Atoms with largest cluster written to {}".format(atoms_fname))
    #view(atoms)
    #plt.plot( network.size_histogram, ls="steps")
    #plt.show()
    print ("Proc: {} reached final barrier".format(rank))
    comm.barrier()
Exemplo n.º 27
0
def thermodynamic_integration(phase):
    alat = 3.8
    conc_args = {}
    conc_args['conc_ratio_min_1'] = [[1, 0]]
    conc_args['conc_ratio_max_1'] = [[0, 1]]
    kwargs = {
        "crystalstructure": 'fcc',
        "a": 3.8,
        "size": [10, 10, 10],
        "basis_elements": [['Cu', 'Au']],
        "conc_args": conc_args,
        "db_name": 'temp_sgc.db',
        "max_cluster_size": 3,
        "max_cluster_dist": 1.5 * alat
    }
    bc1 = BulkCrystal(**kwargs)
    bf = bc1._get_basis_functions()[0]

    with open("data/eci_aucu.json", 'r') as infile:
        eci = json.load(infile)

    db = dataset.connect("sqlite:///{}".format(canonical_db))
    tbl = db["corrfunc"]
    if phase == "Au" or phase == "Cu":
        atoms1 = bc1.atoms
        for atom in atoms1:
            atom.symbol = phase
        cf1 = get_pure_cf(eci, bf[phase])
    else:
        atoms = read(phase)
        row = tbl.find_one(runID=gs[phase])
        row.pop("id")
        row.pop("runID")
        cf1 = row
    # TODO: Fix this when running with a pure phase
    symbs = [atom.symbol for atom in atoms]

    cf1 = get_pure_cf(eci, bf[bc1.atoms[0].symbol])
    atoms = bc1.atoms
    calc = CE(bc1, eci=eci, initial_cf=cf1)
    calc.set_symbols(symbs)
    atoms.set_calculator(calc)

    sgc_db = dataset.connect("sqlite:///{}".format(sgc_db_name))
    tbl = sgc_db["results"]
    tbl_cf = sgc_db["corr_func"]
    mu = 0.223
    nsteps = 100 * len(atoms)
    equil_param = {"mode": "fixed", "maxiter": 10 * len(atoms)}
    order_param = SiteOrderParameter(atoms)
    T = np.linspace(100, 600, 40)
    # mu = np.linspace(0.223, 0.19, 20).tolist()
    mu = [0.223]
    for temp in T:
        for m in mu:
            chemical_potential = {"c1_0": m}
            # mc = SGCMonteCarlo(atoms, temp, mpicomm=comm, symbols=["Au", "Cu"])
            mc = Montecarlo(atoms, temp)
            mc.attach(order_param)
            init_formula = atoms.get_chemical_formula()
            # mc.runMC(steps=nsteps, equil_params=equil_param,
            #          chem_potential=chemical_potential)
            mc.runMC(steps=nsteps, equil_params=equil_param)
            # thermo = mc.get_thermodynamic(reset_ecis=True)
            thermo = mc.get_thermodynamic()
            thermo["init_formula"] = init_formula
            thermo["final_formula"] = atoms.get_chemical_formula()
            avg, std = order_param.get_average()
            thermo["order_avg"] = avg
            thermo["order_std"] = std
            thermo["valid"] = True
            thermo["integration_path"] = "NN"
            if rank == 0:
                uid = tbl.insert(thermo)
                cf = calc.get_cf()
                cf["runID"] = uid
                tbl_cf.insert(cf)
Exemplo n.º 28
0
def run(mg_conc):
    bs_kwargs = {
        "conc_args": {
            "conc_ratio_min_1": [[1, 0]],
            "conc_ratio_max_1": [[0, 1]]
        },
        "basis_elements": [["Al", "Mg"], ["Al", "Mg"], ["Al", "Mg"],
                           ["Al", "Mg"]],
        "cellpar": [10.553, 10.553, 10.553, 90, 90, 90],
        "basis": [(0, 0, 0), (0.324, 0.324, 0.324), (0.3582, 0.3582, 0.0393),
                  (0.0954, 0.0954, 0.2725)],
        "spacegroup":
        217,
        "max_cluster_size":
        4,
        "db_name":
        "trial_217.db",
        "size": [1, 1, 1],
        "grouped_basis": [[0, 1, 2, 3]]
    }
    bs = BulkSpacegroup(**bs_kwargs)
    eci_file = "data/almg_217_eci.json"
    with open(eci_file, 'r') as infile:
        ecis = json.load(infile)
    calc = get_ce_calc(bs, bs_kwargs, ecis, size=[3, 3, 3])
    bs = calc.BC
    bs.atoms.set_calculator(calc)
    comp = {"Al": 1.0 - mg_conc, "Mg": mg_conc}

    calc.set_composition(comp)
    print("Number of atoms: {}".format(len(bs.atoms)))
    high_temps = [10000, 9000, 8000, 7000, 6000, 5000, 4000, 3000, 2000, 1000]
    low_temps = range(200, 1000, 50)[::-1]
    T = np.array(high_temps + low_temps)
    #T = np.array([10000,9000,8000,7000,6000,5000,4000,3000,2000,1000,800,700,600,500,400,375,350,325,300,275,250,225,200,175,150])
    #T = np.array([1E6,100000])
    precs = np.zeros(len(T)) + 1E-4
    #precs[T<=500] = 1E-5
    print(bs.atoms.get_chemical_formula())
    mc_obj = Montecarlo(bs.atoms, T[0], mpicomm=comm)
    mc_obj.accept_first_trial_move_after_reset = False
    for prec, temp in zip(precs, T):
        mc_obj.T = temp
        mc_obj.reset()
        #if ( temp==T[0] ):
        #    mc_obj.is_first = False # Do not accept the first move

        print("Current temperature {}K".format(temp))
        mode = "fixed"
        mc_obj.runMC(mode=mode, prec=prec, steps=1000000)
        thermo = mc_obj.get_thermodynamic()
        thermo["temperature"] = temp
        thermo["prec"] = prec
        thermo["internal_energy"] = thermo.pop("energy")
        thermo["converged"] = True

        if (rank == 0):
            cf = calc.get_cf()
            db = connect(mc_db_name)
            thermo.update(cf)
            db.write(bs.atoms, key_value_pairs=thermo)

    if (rank == 0 and run_mfa):
        # At this point a ground state should have been reached
        mfa = CanonicalMeanField(atoms=bs.atoms, T=T)
        mfa.relax()
        res = mfa.calculate()
        formula = bs.atoms.get_chemical_formula()
        fname = "data/mfa217/{}mfa.json".format(formula)
        with open(fname, 'w') as outfile:
            json.dump(res, outfile, indent=2, separators=(",", ":"))
Exemplo n.º 29
0
 def _accept(self, system_changes):
     move_accepted = Montecarlo._accept(self, system_changes)
     in_window = self.nuc_sampler.is_in_window(self.network)
     return move_accepted and in_window
Exemplo n.º 30
0
def free_energy_vs_layered(T, mod):
    from cemc.mcmc import AdaptiveBiasReactionPathSampler
    from cemc.mcmc import ReactionCrdRangeConstraint
    from cemc.mcmc import DiffractionObserver
    from cemc.mcmc import MinimalEnergyPath
    from ase.geometry import get_layers
    atoms = get_atoms(cubic=True)

    atoms_cpy = atoms.copy()
    layers, dist = get_layers(atoms, (0, 1, 0))
    for atom in atoms_cpy:
        if layers[atom.index] % 2 == 0:
            atom.symbol = "Mg"
        else:
            atom.symbol = "Si"
    symbols = [atom.symbol for atom in atoms_cpy]
    atoms.get_calculator().set_symbols(symbols)

    lamb = 4.05
    k = 2.0 * np.pi / lamb
    workdir = "data/diffraction"

    # Have to perform only insert moves
    mc = Montecarlo(atoms, T)
    k_vec = [k, 0, 0]
    observer = DiffractionObserver(atoms=atoms,
                                   active_symbols=["Si"],
                                   all_symbols=["Mg", "Si"],
                                   k_vector=k_vec,
                                   name="reflection")
    if T < 250:
        mc.max_attempts = 5
        nsteps = 100 * len(atoms)
        mep = MinimalEnergyPath(mc_obj=mc,
                                observer=observer,
                                value_name="reflection",
                                relax_steps=nsteps,
                                search_steps=nsteps,
                                traj_file="{}/mep_diffract{}K.traj".format(
                                    workdir, T),
                                max_reac_crd=1999.0)
        mep.run()
        mep.save(fname="{}/mep_mep_diffract_path{}.csv".format(workdir, T))
    else:
        conc_cnst = ReactionCrdRangeConstraint(observer,
                                               value_name="reflection")
        conc_cnst.update_range([0, 0.5])
        mc.add_constraint(conc_cnst)

        reac_path = AdaptiveBiasReactionPathSampler(
            mc_obj=mc,
            react_crd=[0.0, 0.5],
            observer=observer,
            n_bins=500,
            data_file="{}/layered_bias{}K.h5".format(workdir, T),
            mod_factor=mod,
            delete_db_if_exists=True,
            mpicomm=None,
            db_struct="{}/layered_bias_struct{}K.db".format(workdir, T),
            react_crd_name="reflection",
            ignore_equil_steps=False,
            smear=2000)
        reac_path.run()
        reac_path.save()