Ejemplo n.º 1
0
  def solve(self):

    #Create the initial particle from the defining string/number atoms
    self.particle = NanoClass.genParticle(self.definingString, int(self.numberOfAtoms))
    self.reCenter()
    self.bestEnergy = self.particle.get_potential_energy()
    self.bestParticle = deepcopy(self.particle)
#    berendsen = NVTBerendsen(self.particle, 2.5 * units.fs, 2000, taut=0.5*100*units.fs)
    berendsen = Langevin(self.particle, 5 * units.fs, units.kB * 2000, 0.005)
    dyn = FIRE(atoms=self.particle)
    MaxwellBoltzmannDistribution(self.particle,2000*units.kB)
    CALCULATIONS=100
    for i in range(CALCULATIONS):
      if i%1==0:
        pDone=float(i)/CALCULATIONS
        self.setStatusDone(str(math.floor(pDone*100))+"% | "+self.remainingTime(pDone))
        self.checkTimeout()
        self.setSolution(self.getAnswer())
      MaxwellBoltzmannDistribution(self.particle,2000*units.kB)
      self.particle.get_potential_energy()
      berendsen.run(500)
      dyn.run()
      self.reCenter()
      testEnergy = self.particle.get_potential_energy()
      if (testEnergy < self.bestEnergy):
        self.bestEnergy = testEnergy
        self.bestParticle = deepcopy(self.particle)
      elif ((testEnergy + .5) > self.bestEnergy):
        self.particle = NanoClass.genParticle(self.definingString, int(self.numberOfAtoms))
        MaxwellBoltzmannDistribution(self.particle,2000*units.kB)
        self.particle.get_potential_energy()
        if (testEnergy < self.bestEnergy):
          self.bestEnergy = testEnergy
          self.bestParticle = deepcopy(self.particle)
    return self.getAnswer()
Ejemplo n.º 2
0
def get_dynamics(atoms, mcfm_pot, T=300):
    # ------ Set up logfiles
    traj_interval = 10
    thermoPrintstatus_log = open("log_thermoPrintstatus.log", "w")
    outputTrajectory = open("log_trajectory.xyz", "w")
    mcfmError_log = open("log_mcfmError.log", "w")

    # ------ Let optimiser use the base potential and relax the per atom energies
    mcfm_pot.qm_cluster.flagging_module.ema_parameter = 0.1
    mcfm_pot.qm_cluster.flagging_module.qm_flag_potential_energies =\
        np.ones((len(atoms), 2), dtype=float) * 1001

    # ------ Minimize positions
    opt = FIRE(atoms)
    optimTrajectory = open("log_optimizationTrajectory.xyz", "w")
    opt.attach(trajectory_writer, 1, atoms, optimTrajectory, writeResults=True)
    opt.run(fmax=0.05, steps=1000)

    # ------ Define ASE dyamics
    sim_T = T * units.kB
    MaxwellBoltzmannDistribution(atoms, 2 * sim_T)

    timestep = 5e-1 * units.fs
    friction = 1e-2
    dynamics = Langevin(atoms, timestep, sim_T, friction, fixcm=False)
    dynamics.attach(mcfm_thermo_printstatus, 100, 100, dynamics,
                    atoms, mcfm_pot, logfile=thermoPrintstatus_log)
    dynamics.attach(trajectory_writer, traj_interval, atoms, outputTrajectory, writeResults=False)
    dynamics.attach(mcfm_error_logger, 100, 100, dynamics, atoms, mcfm_pot, logfile=mcfmError_log)
    return dynamics
Ejemplo n.º 3
0
    def init_dynamics(self, Nm, Nembed, V, L, dt, T):
        self.L = L

        # Generate the box of junk
        self.__generategarbagebox__(Nm, Nembed, L, T)

        # Make mol
        self.mol = Atoms(symbols=self.S, positions=self.X)

        # Set box and PBC
        self.mol.set_cell(([[L, 0, 0], [0, L, 0], [0, 0, L]]))

        self.mol.set_pbc((True, True, True))

        # Set ANI calculator
        self.mol.set_calculator(ANIENS(self.aens))

        # Open MD output
        #self.mdcrd = open(xyzfile, 'w')

        # Open MD output
        #self.traj = open(trjfile, 'w')

        # Set the velocities corresponding to a boltzmann dist @ T/4.0
        MaxwellBoltzmannDistribution(self.mol, 300.0 * units.kB)

        # Declare Dyn
        self.dyn = Langevin(self.mol, dt * units.fs, T * units.kB, 0.1)
Ejemplo n.º 4
0
def md(molecule, model, device, output, nsteps, temperature, step, friction):
    start = time.time()
    mm = Mol2(molecule)
    pos = mm.get_coordinates()
    labels = ''.join(mm.get_symbols())
    device = torch.device(device)
    if model.lower() == 'ani1x':
        model = torchani.models.ANI1x()
    elif model.lower() == 'ani1ccx':
        model = torchani.models.ANI1ccx()
    else:
        print("unknwon model {:s}".format(model))
        sys.exit(1)
    assert isinstance(model, torchani.models.ANI1x) or isinstance(model, torchani.models.ANI1ccx)
    atom_group = Atoms(symbols=labels, positions=pos, calculator=model.ase())
    print("step {:12d}\tenergy {:12.4f}".format(0, atom_group.get_total_energy()))
    dyn = Langevin(atom_group, 1*units.fs, temperature*units.kB, friction)

    for i in range(nsteps):
        dyn.run(step)
        print("step {:12d}\tenergy {:12.4f}".format((i + 1)*step, atom_group.get_total_energy()))
        mm.coordinates = atom_group.get_positions()
        if output is not None:
            mm.write(output + '_{:06d}.mol2'.format(i))
    print("time {:12.4f}".format(time.time() - start))
    sys.exit(0)
Ejemplo n.º 5
0
    def init_dynamics(self, Nm, V, L, dt, T):
        self.L = L

        # Generate the box of junk
        self.__generategarbagebox__(Nm, L, T)

        # Make mol
        self.mol = Atoms(symbols=self.S, positions=self.X)

        # Set box and PBC
        self.mol.set_cell(([[L, 0, 0], [0, L, 0], [0, 0, L]]))

        self.mol.set_pbc((True, True, True))

        # Set ANI calculator
        # Set ANI calculator
        self.mol.set_calculator(ANIENS(self.aens))
        #self.mol.set_calculator(ANI(False))
        #self.mol.calc.setnc(self.ncl[0])

        # Give molecules random velocity
        acc_idx = 0
        vel = np.empty_like(self.X)
        for n in self.Na:
            rv = np.random.uniform(-V, V, size=(3))
            for k in range(n):
                vel[acc_idx + k, :] = rv
            acc_idx += n
        #print(vel)

        self.mol.set_velocities(vel)

        # Declare Dyn
        self.dyn = Langevin(self.mol, dt * units.fs, T * units.kB, 0.1)
Ejemplo n.º 6
0
    def __init__(self, atoms, timestep=None, temperature=None, friction=None, 
                 trajectory=None, **kwargs):

        Langevin.__init__(self, atoms, timestep, temperature, friction)

        OTF.__init__(self, **kwargs)
        
        self.md_engine = 'Langevin'
Ejemplo n.º 7
0
 def testWithNumericalForceWithPBCEnabled(self):
     # Run a Langevin thermostat dynamic for 100 steps and after the dynamic
     # check once that the numerical and analytical force agree to a given
     # relative tolerance
     atoms = Diamond(symbol="C", pbc=True)
     calculator = self.model.ase()
     atoms.set_calculator(calculator)
     dyn = Langevin(atoms, 5 * units.fs, 30000000 * units.kB, 0.002)
     dyn.run(100)
     f = atoms.get_forces()
     fn = get_numeric_force(atoms, 0.001)
     self.assertEqual(f, fn, rtol=0.1, atol=0.1)
Ejemplo n.º 8
0
 def testWithNumericalForceWithPBCEnabled(self):
     atoms = Diamond(symbol="C", pbc=True)
     calculator = torchani.models.ANI1x().ase()
     atoms.set_calculator(calculator)
     dyn = Langevin(atoms, 5 * units.fs, 30000000 * units.kB, 0.002)
     dyn.run(100)
     f = torch.from_numpy(atoms.get_forces())
     fn = get_numeric_force(atoms, 0.001)
     df = (f - fn).abs().max()
     avgf = f.abs().mean()
     if avgf > 0:
         self.assertLess(df / avgf, 0.1)
Ejemplo n.º 9
0
def hyster_study(edge, folder=None):

    if folder == None: folder = os.getcwd()

    print folder
    for fileC in os.listdir(folder):
        if fileC[-6:] == '.simul':
            fileC = folder + fileC
            _, length, _, _, v, T, dt, fric, dtheta, \
            thresZ, interval, deltaY, theta, M, edge   =   read_simul_params_file(fileC)
            mdfile = fileC[:-6] + '.traj'
            traj = PickleTrajectory(mdfile, 'r')
            atoms_init = traj[0]


            constraints, _, twist, rend_b, rend_t  =   get_constraints(atoms_init, edge, \
                                                                   bond, None, key = 'twist_p')

            #constraints, _, rend_b, rend_t     =   get_constraints(atoms_init, edge, \
            #                                                       bond, None, key = 'twist_p')
            atoms = traj[-1]
            atoms.set_constraint(constraints)

            vels = (traj[-2].positions - traj[-1].positions) / (interval * dt)
            atoms.set_velocities(vels)

            calc = LAMMPS(parameters=get_lammps_params())
            atoms.set_calculator(calc)

            view(atoms)
            dyn = Langevin(atoms, dt * units.fs, T * units.kB, fric)
            twist.set_angle(theta)
            dyn.run(10 * interval)
            view(atoms)

            traj_new = PickleTrajectory(fileC[:-6] + '_hyst.traj', 'w', atoms)
            mdlogf = fileC[:-6] + '_hyst.log'



            do_dynamics(mdlogf, atoms, dyn, rend_b, rend_t, v, dt, deltaY, \
                        theta, dtheta, length, thresZ, \
                        interval, traj_new, M, twist)

            mdhystf = fileC[:-6] + '_hyst.traj'
            logfile = fileC[:-6] + '.log'

            append_files(logfile, mdlogf, logfile[:-4] + '_comp.log')
            call([
                'ase-gui', mdfile, mdhystf, '-o', logfile[:-4] + '_comp.traj'
            ])
Ejemplo n.º 10
0
def hyster_study(edge, folder = None):

    if folder == None:  folder  =   os.getcwd()
        
    print folder
    for fileC in os.listdir(folder):
        if fileC[-6:] == '.simul':
            fileC       =   folder + fileC
            _, length, _, _, v, T, dt, fric, dtheta, \
            thresZ, interval, deltaY, theta, M, edge   =   read_simul_params_file(fileC)
            mdfile      =   fileC[:-6] + '.traj'
            traj        =   PickleTrajectory(mdfile, 'r')
            atoms_init  =   traj[0]
            
            
            constraints, _, twist, rend_b, rend_t  =   get_constraints(atoms_init, edge, \
                                                                   bond, None, key = 'twist_p')
            
            #constraints, _, rend_b, rend_t     =   get_constraints(atoms_init, edge, \
            #                                                       bond, None, key = 'twist_p')
            atoms       =   traj[-1]
            atoms.set_constraint(constraints)
            
            
            
            vels        =   (traj[-2].positions - traj[-1].positions) / (interval * dt)
            atoms.set_velocities(vels)
            
            calc        =   LAMMPS(parameters=get_lammps_params()) 
            atoms.set_calculator(calc)
            
            view(atoms)
            dyn         =   Langevin(atoms, dt*units.fs, T*units.kB, fric)
            twist.set_angle(theta)
            dyn.run(10 * interval)
            view(atoms)
            
            traj_new=   PickleTrajectory(fileC[:-6] + '_hyst.traj', 'w', atoms)
            mdlogf  =   fileC[:-6] + '_hyst.log'
            
            
            
            do_dynamics(mdlogf, atoms, dyn, rend_b, rend_t, v, dt, deltaY, \
                        theta, dtheta, length, thresZ, \
                        interval, traj_new, M, twist)
            
            mdhystf =   fileC[:-6] + '_hyst.traj'
            logfile =   fileC[:-6] + '.log'
            
            append_files(logfile, mdlogf, logfile[:-4] + '_comp.log')
            call(['ase-gui', mdfile, mdhystf, '-o', logfile[:-4] + '_comp.traj'])            
Ejemplo n.º 11
0
 def _testForce(self, pbc):
     atoms = Diamond(symbol="C", pbc=pbc)
     builtin = torchani.neurochem.Builtins()
     calculator = torchani.ase.Calculator(
         builtin.species, builtin.aev_computer,
         builtin.models, builtin.energy_shifter)
     atoms.set_calculator(calculator)
     dyn = Langevin(atoms, 5 * units.fs, 30000000 * units.kB, 0.002)
     dyn.run(100)
     f = torch.from_numpy(atoms.get_forces())
     fn = get_numeric_force(atoms, 0.001)
     df = (f - fn).abs().max()
     avgf = f.abs().mean()
     if avgf > 0:
         self.assertLess(df / avgf, 0.1)
Ejemplo n.º 12
0
 def run_static(self):
     """
     Static run function, which uses the ASEAdapter to connect the pyiron interactive reference job with the
     Langevin thermostat implemented in ASE, by setting the ASEAdapter as a replacement of the ASE atoms object.
     """
     self.status.running = True
     self.ref_job_initialize()
     aseadapter = AseAdapter(self.ref_job, self._fast_mode)
     langevin = Langevin(atoms=aseadapter,
                         timestep=self.input['time_step'] * units.fs,
                         temperature=self.input['temperature'] * units.kB,
                         friction=self.input['friction'],
                         fixcm=True)
     langevin.run(self.input['ionic_steps'])
     self.status.collect = True
     aseadapter.interactive_close()
     self._finish_job()
    def solve(self):
    #Create the initial particle from the defining string/number atoms

        temp = 1750
        mintemp = 150
        self.particle = genParticle(self.definingString,int(self.numberOfAtoms))
        if (len(self.particle) < 16):
          temp = 1250
        maxtemp = temp
        berendsen = Langevin(self.particle, 2.5 * units.fs, units.kB * temp, 0.02)
        # the 5.0 * units.fs is used instead of 0.1 * units.fs b/c it makes the program run faster
        MaxwellBoltzmannDistribution(self.particle,units.kB * temp)
        self.bestEnergy = self.particle.get_potential_energy()
        self.bestParticle = deepcopy(self.particle)
        self.reCenter()
        self.getAnswer()

        while (temp > mintemp):
            berendsen = Langevin(self.particle, 2.5 * units.fs, units.kB * temp, 0.02)
            berendsen.run(100)
            testEnergy = self.particle.get_potential_energy()
            self.bestEnergy = self.particle.get_potential_energy()
            self.bestParticle = deepcopy(self.particle)
            self.reCenter()
            self.getAnswer()
            temp -= 10
            if (temp % 50 == 0):
              self.bestEnergy = self.particle.get_potential_energy()
              self.bestParticle = deepcopy(self.particle)
              self.reCenter()
              self.checkTimeout()
              self.setSolution(self.getAnswer())
              pDone=float(maxtemp - temp)/(maxtemp-mintemp)
              self.setStatusDone(str(math.floor(pDone*100))+"% | "+self.remainingTime(pDone))
            elif (temp <= mintemp):
              dyn = FIRE(atoms=self.particle)
              dyn.run(fmax=0.01)
              self.bestEnergy = self.particle.get_potential_energy()
              self.bestParticle = deepcopy(self.particle)
              self.reCenter()
              self.setSolution(self.getAnswer())
              pDone=float(temp)/(maxtemp-mintemp)
              self.setStatusDone(str(math.floor(pDone*100))+"% | "+self.remainingTime(pDone))

        return self.getAnswer()
Ejemplo n.º 14
0
 def updatevars(self):
     Langevin_ASE.updatevars(self)
     if len(self.atoms.constraints) == 1:
         # Process the FixAtoms constraint
         constr = self.atoms.constraints[0].index
         self.sdpos[constr] = 0.0
         self.sdmom[constr] = 0.0
         self.c1[constr] = 0.0
         self.c2[constr] = 0.0
         self.c3[constr] = 0.0
         self.c4[constr] = 0.0
         self.act0[constr] = 0.0
     if self._localfrict:
         self.asap_md.set_vector_constants(self.prefix+"act0", self.prefix+"c3", 
                                           self.prefix+"c4", self.prefix+"pmcor", 
                                           self.prefix+"cnst")
     else:
         self.asap_md.set_scalar_constants(self.act0, self.c3, self.c4,
                                           self.pmcor, self.cnst)
Ejemplo n.º 15
0
def langevin_dynamics(atoms, dt, tem, friction, trajectory, loginterval,
                      append):
    dyn = Langevin(atoms,
                   dt * units.fs,
                   temperature_K=tem,
                   friction=friction,
                   rng=np.random,
                   trajectory=trajectory,
                   append_trajectory=append,
                   loginterval=loginterval)
    return dyn
Ejemplo n.º 16
0
 def __init__(self, atoms, timestep, temperature, friction, fixcm=True,
              trajectory=None, logfile=None, loginterval=1):
     assert(getattr(Langevin_ASE, "_lgv_version", 1) >= 2)
     ParallelMolDynMixin.__init__(self, "Langevin", atoms)
     self._uselocaldata = False # Need to store on atoms for serial simul too.
     self.calculator = atoms.get_calculator()            
     self.asap_md = asap3._asap.Langevin(atoms, self.calculator, timestep,
                                         self.prefix+"sdpos", self.prefix+"sdmom",
                                         self.prefix+"c1", self.prefix+"c2",
                                         fixcm, randint(1 << 30))
     if not atoms.has('momenta'):
         atoms.set_momenta(np.zeros((len(atoms), 3), float))
     if atoms.constraints:
         assert len(atoms.constraints) == 1
         constraint = atoms.constraints[0]
         assert isinstance(constraint, asap3.constraints.FixAtoms)
         constraint.prepare_for_asap(atoms)            
         # Make all constants arrays by making friction an array
         friction = friction * np.zeros(len(atoms))
     Langevin_ASE.__init__(self, atoms, timestep, temperature, friction, fixcm,
                           trajectory, logfile, loginterval, communicator=None)
Ejemplo n.º 17
0
    def testForceAgainstDefaultNeighborList(self):
        atoms = Diamond(symbol="C", pbc=False)
        builtin = torchani.neurochem.Builtins()

        calculator = torchani.ase.Calculator(builtin.species,
                                             builtin.aev_computer,
                                             builtin.models,
                                             builtin.energy_shifter)
        default_neighborlist_calculator = torchani.ase.Calculator(
            builtin.species, builtin.aev_computer, builtin.models,
            builtin.energy_shifter, True)

        atoms.set_calculator(calculator)
        dyn = Langevin(atoms, 5 * units.fs, 50 * units.kB, 0.002)

        def test_energy(a=atoms):
            a = a.copy()
            a.set_calculator(calculator)
            e1 = a.get_potential_energy()
            a.set_calculator(default_neighborlist_calculator)
            e2 = a.get_potential_energy()
            self.assertLess(abs(e1 - e2), tol)

        dyn.attach(test_energy, interval=1)
        dyn.run(500)
Ejemplo n.º 18
0
def smash_it(system):
    """Run a simple NVT molecular dynamics simulation for 0.1 ps at 200 k using
    the effective medium theory on a supplied system.

    Parameters
    ----------
    system : `ase.Atoms`
        The system that is to be simulated.

    Returns
    -------
    traj : `list` [`ase.Atoms`]
        A list of `ase.Atoms` objects comprising the system's trajectory.
    """
    # Tell the system to use the EMT calculator
    system.set_calculator(EMT())
    # Set up the NVT simulation using the Langevin thermostat
    dyn = Langevin(system, 0.01 * units.fs, 200 * units.kB, 0.002)
    # Create a list to hold the trajectory & a function to populate it
    traj = []
    def update_traj(a=system):
        traj.append(a.copy())
    # Attach the trajectory populator
    dyn.attach(update_traj, interval=10)
    # Run the molecular dynamics simulation from 10000 steps
    dyn.run(10000)
    # Return the trajectory
    return traj
Ejemplo n.º 19
0
    def __run_rand_dyn__(self, mid, T1, T2, dt, Nc, Ns, dS):
        # Setup calculator
        mol = self.mols[0].copy()

        # Setup PBC if active
        if self.pbc:
            mol.set_cell(([[self.pbl, 0, 0],
                           [0, self.pbl, 0],
                           [0, 0, self.pbl]]))

            mol.set_pbc((self.pbc, self.pbc, self.pbc))

        # Setup calculator
        mol.set_calculator(ANIENS(self.aens))

        #mol.set_calculator(ANI(False))
        #mol.calc.setnc(self.ncl[0])

        # Set chemical symbols
        spc = mol.get_chemical_symbols()

        # Set the velocities corresponding to a boltzmann dist @ T/4.0
        MaxwellBoltzmannDistribution(mol, T1 * units.kB)

        # Set the thermostat
        dyn = Langevin(mol, dt * units.fs, T1 * units.kB, 0.02)
        dT = (T2 - T1)/Nc
        #print('Running...')
        for i in range(Nc):
            # Set steps temperature
            dyn.set_temperature((T1 + dT*i) * units.kB)

            # Do Ns steps of dynamics
            dyn.run(Ns)

            # Return sigma
            sigma = hdt.evtokcal * mol.calc.stddev

            ekin = mol.get_kinetic_energy() / len(mol)

            # Check for dynamics failure
            if sigma > dS:
                self.Nbad += 1
                self.X.append(mol.get_positions())
                #print('Step:', dyn.get_number_of_steps(), 'Sig:', sigma, 'Temp:',
                #      str(ekin / (1.5 * units.kB)) + '(' + str(T1 + dT * i) + ')')

                return True,dyn.get_number_of_steps()
        return False,dyn.get_number_of_steps()
Ejemplo n.º 20
0
    def run_md(self, f, Tmax, steps, n_steps, nmfile=None, displacement=0, min_steps=0, sig=0.34, t=0.1, nm=0, record=False):
        X, S, Na, cm = hdt.readxyz2(f)
        
        if nmfile != None:
            mode=self.get_mode(nmfile, Na, mn=nm)
            X=X+mode*np.random.uniform(-displacement,displacement)
        X=X[0]
        mol=Atoms(symbols=S, positions=X)
        mol.set_calculator(ANIENS(self.net,sdmx=20000000.0))
        f=os.path.basename(f)
        T_eff = float(random.randrange(5, Tmax, 1)) # random T (random velocities) from 0K to TK
        minstep_eff = float(random.randrange(1, min_steps, 1)) # random T (random velocities) from 0K to TK
        dyn = Langevin(mol, t * units.fs, T_eff * units.kB, 0.01)
        MaxwellBoltzmannDistribution(mol, T_eff * units.kB)
#        steps=10000    #10000=1picosecond                             #Max number of steps to run
#        n_steps = 1                                                #Number of steps to run for before checking the standard deviation
        hsdt_Na=[]
        evkcal=hdt.evtokcal

        if record==True:                                           #Records the coordinates at every step of the dynamics
            fname = f + '_record_' + str(T_eff) + 'K' + '.xyz'     #name of file to store coodinated in
            def printenergy(name=fname, a=mol):
                """Function to print the potential, kinetic and total energy."""
                fil= open(name,'a')
                Na=a.get_number_of_atoms()
                c = a.get_positions(wrap=True)
                fil.write('%s \n comment \n' %Na)
                for j, i in zip(a, c):
                    fil.write(str(j.symbol) + ' ' + str(i[0]) + ' ' + str(i[1]) + ' ' + str(i[2]) + '\n')
                fil.close()
            dyn.attach(printenergy, interval=1)

        e=mol.get_potential_energy()                             #Calculate the energy of the molecule. Must be done to get the standard deviation
        s=mol.calc.stddev
        stddev =  0
        tot_steps = 0
        failed = False
        while (tot_steps <= steps):
            if stddev > sig and tot_steps > minstep_eff:                                #Check the standard deviation
                self.hstd.append(stddev)
                c = mol.get_positions()
                s = mol.get_chemical_symbols()
                Na=mol.get_number_of_atoms()
                self.Na_train.append(Na)
                self.coor_train.append(c)
                self.S_train.append(s)
                failed=True
                break
            else:                                           #if the standard deviation is low, run dynamics, then check it again
                tot_steps = tot_steps + n_steps
                dyn.run(n_steps)
                stddev =  evkcal*mol.calc.stddev
                c = mol.get_positions()
                s = mol.get_chemical_symbols()
                e=mol.get_potential_energy()
                #print("{0:.2f}".format(tot_steps*t),':',"{0:.2f}".format(stddev),':',"{0:.2f}".format(evkcal*e))
        return c, s, tot_steps*t, stddev, failed, T_eff
Ejemplo n.º 21
0
 def set_lattice_params(self, md='NVE', **kwargs):
     #self.lattice_model.set(**kwargs)
     self.lattice_temperature = kwargs['lattice_temperature']
     self.lattice_time_step = kwargs['lattice_time_step']
     self.lattice_friction = kwargs['lattice_friction']
     if md == 'Langevin':
         self._lattice_dyn = Langevin(self.atoms,
                                      self.lattice_time_step,
                                      self.lattice_temperature,
                                      self.lattice_friction,
                                      trajectory='LattHist.traj')
     elif md == 'NVE':
         self._lattice_dyn = VelocityVerlet(self.atoms,
                                            dt=self.lattice_time_step,
                                            trajectory='LattHist.traj')
Ejemplo n.º 22
0
def get_dynamics(atoms, mcfm_pot, T=300):
    # ------ Set up logfiles
    traj_interval = 10
    thermoPrintstatus_log = open("log_thermoPrintstatus.log", "w")
    outputTrajectory = open("log_trajectory.xyz", "w")
    mcfmError_log = open("log_mcfmError.log", "w")

    # ------ Let optimiser use the base potential and relax the per atom energies
    mcfm_pot.qm_cluster.flagging_module.ema_parameter = 0.1
    mcfm_pot.qm_cluster.flagging_module.qm_flag_potential_energies =\
        np.ones((len(atoms), 2), dtype=float) * 1001

    # ------ Minimize positions
    opt = FIRE(atoms)
    optimTrajectory = open("log_optimizationTrajectory.xyz", "w")
    opt.attach(trajectory_writer, 1, atoms, optimTrajectory, writeResults=True)
    opt.run(fmax=0.05, steps=1000)

    # ------ Define ASE dyamics
    sim_T = T * units.kB
    MaxwellBoltzmannDistribution(atoms, 2 * sim_T)

    timestep = 5e-1 * units.fs
    friction = 1e-2
    dynamics = Langevin(atoms, timestep, sim_T, friction, fixcm=False)
    dynamics.attach(mcfm_thermo_printstatus,
                    100,
                    100,
                    dynamics,
                    atoms,
                    mcfm_pot,
                    logfile=thermoPrintstatus_log)
    dynamics.attach(trajectory_writer,
                    traj_interval,
                    atoms,
                    outputTrajectory,
                    writeResults=False)
    dynamics.attach(mcfm_error_logger,
                    100,
                    100,
                    dynamics,
                    atoms,
                    mcfm_pot,
                    logfile=mcfmError_log)
    return dynamics
Ejemplo n.º 23
0
    def MD(self):
        """Molecular Dynamic"""
        from ase.md.velocitydistribution import MaxwellBoltzmannDistribution
        from ase import units
        from ase.md import MDLogger
        from ase.io.trajectory import PickleTrajectory
        from ase.md.langevin import Langevin
        from ase.md.verlet import VelocityVerlet

        dyndrivers = {
            'Langevin': Langevin,
            'None': VelocityVerlet,
        }

        useAsap = False

        mol = self.mol
        temperature = self.definedParams['temperature']
        init_temperature = self.definedParams['init_temperature']
        time_step = self.definedParams['time_step']
        nstep = self.definedParams['nstep']
        nprint = self.definedParams['nprint']
        thermostat = self.definedParams['thermostat']
        prop_file = os.path.join(self.definedParams['workdir'],
                                 self.definedParams['output_prefix'] + '.out')
        traj_file = os.path.join(self.definedParams['workdir'],
                                 self.definedParams['output_prefix'] + '.traj')

        MaxwellBoltzmannDistribution(mol, init_temperature * units.kB)

        if thermostat == 'None':
            dyn = VelocityVerlet(mol, time_step * units.fs)
        elif thermostat == 'Langevin':
            dyn = Langevin(mol, time_step * units.fs, temperature * units.kB,
                           0.01)
        else:
            raise ImplementationError(
                method, 'Thermostat is not implemented in the MD function')

        #Function to print the potential, kinetic and total energy
        traj = PickleTrajectory(traj_file, "a", mol)
        dyn.attach(MDLogger(dyn, mol, prop_file), interval=nprint)
        dyn.attach(traj.write, interval=nprint)

        dyn.run(nstep)
        traj.close()
Ejemplo n.º 24
0
def run_md(atoms, md_temperature = 1000*kB, md_step_size = 1*fs, md_steps=100, md_interval=100, friction=0.02):
    natoms=atoms.get_number_of_atoms()
    #atoms.set_calculator(self.opt_calculator)
    atoms_md = []
    e_log = []
    atoms_md.append(atoms.copy())
    MaxwellBoltzmannDistribution(atoms=atoms, temp=md_temperature)
    dyn = Langevin(atoms, md_step_size, md_temperature, friction)
    def md_log(atoms=atoms):
        atoms_md.append(atoms.copy())
        epot=atoms.get_potential_energy()
        ekin=atoms.get_kinetic_energy()
        temp = ekin / (1.5 * kB * natoms)
        e_log.append([epot, ekin, temp])
    traj = Trajectory('Au_md.traj', 'w', atoms)      # Output MD trajectory before it is treatment
    dyn.attach(traj.write, interval=10)
    dyn.attach(md_log, interval=md_interval)
    dyn.run(md_steps)
    return atoms_md, e_log
Ejemplo n.º 25
0
def md_calculation(fcp_file):
    from ase import units
    from ase.io.trajectory import Trajectory
    from ase.md.velocitydistribution import MaxwellBoltzmannDistribution
    from ase.md.langevin import Langevin
    from ase.md import MDLogger

    if 'fcc' in fcp_file:
        ref_cell = read(ref_fcc)
        P = np.array([[-1, 1, 1], [1, -1, 1], [1, 1, -1]])
        P *= 3
        atoms = make_supercell(ref_cell, P)
    else:
        raise ValueError("Unknown phase")

    fcp = ForceConstantPotential.read(fcp_file)
    fcs = fcp.get_force_constants(atoms)
    calc = ForceConstantCalculator(fcs)
    atoms.set_calculator(calc)

    temperature = 200
    number_of_MD_steps = 100
    time_step = 5  # in fs
    dump_interval = 10
    traj_file = "data/md_" + fcp_file.split('.')[0] + '{}.traj'.format(
        temperature)
    log_file = "data/md_log_{}.log".format(temperature)

    dyn = Langevin(atoms, time_step * units.fs, temperature * units.kB, 0.02)
    logger = MDLogger(dyn,
                      atoms,
                      log_file,
                      header=True,
                      stress=False,
                      peratom=True,
                      mode='w')
    traj_writer = Trajectory(traj_file, 'w', atoms)
    dyn.attach(logger, interval=dump_interval)
    dyn.attach(traj_writer.write, interval=dump_interval)

    # run MD
    MaxwellBoltzmannDistribution(atoms, temperature * units.kB)
    dyn.run(number_of_MD_steps)
Ejemplo n.º 26
0
 def test_usage(self):
     atoms = fcc111('Al', size=(4, 4, 9), orthogonal=True)
     atoms.set_pbc(True)
     atoms.center(axis=2, vacuum=10.0)
     z = atoms.positions[:, 2]
     top_mask = z > z[115] - 0.1
     bottom_mask = z < z[19] + 0.1
     calc = EMT()
     atoms.calc = calc
     damping = pc.AutoDamping(C11=500 * GPa, p_c=0.2)
     Pdir = 2
     vdir = 0
     P = 5 * GPa
     v = 100.0 * m / s
     dt = 1.0 * fs
     T = 400.0
     t_langevin = 75 * fs
     gamma_langevin = 1. / t_langevin
     slider = pc.SlideWithNormalPressureCuboidCell(top_mask, bottom_mask,
                                                   Pdir, P, vdir, v,
                                                   damping)
     atoms.set_constraint(slider)
     MaxwellBoltzmannDistribution(atoms, 2 * kB * T)
     atoms.arrays['momenta'][top_mask, :] = 0
     atoms.arrays['momenta'][bottom_mask, :] = 0
     handle = StringIO()
     beginning = handle.tell()
     temps = np.zeros((len(atoms), 3))
     temps[slider.middle_mask, slider.Tdir] = kB * T
     gammas = np.zeros((len(atoms), 3))
     gammas[slider.middle_mask, slider.Tdir] = gamma_langevin
     integrator = Langevin(atoms, dt, temps, gammas, fixcm=False)
     logger = pc.SlideLogger(handle, atoms, slider, integrator)
     logger.write_header()
     logger()
     images = []
     integrator.attach(logger)
     integrator.attach(lambda: images.append(atoms.copy()))
     integrator.run(50)
     handle.seek(beginning)
     pc.SlideLog(handle)
     handle.close()
Ejemplo n.º 27
0
Archivo: test.py Proyecto: casv2/TF
def MD():
    old_stdout = sys.stdout
    sys.stdout = mystdout = StringIO()

    orig_stdout = sys.stdout
    f = open('out.txt', 'w')
    sys.stdout = f

    #f = open('out_' + str(temp) + '.txt', 'w')
    #sys.stdout = f
    Tmin = 1000
    Tmax = 15000

    a0 = 5.43
    N = 1
    atoms = Diamond(symbol='Si', latticeconstant=a0)
    atoms *= (N, N, N)
    atoms.set_calculator(model.calculator)
    MaxwellBoltzmannDistribution(atoms, Tmin * units.kB)  ###is this allowed?
    Stationary(atoms)  # zero linear momentum
    ZeroRotation(atoms)

    def printenergy(a=atoms):
        epot = a.get_potential_energy() / len(a)
        ekin = a.get_kinetic_energy() / len(a)
        print(ekin)

    traj = Trajectory('Si.traj', 'w', atoms)

    for temp in np.linspace(Tmin, Tmax, 5):
        dyn = Langevin(atoms, 5 * units.fs, units.kB * temp, 0.002)
        dyn.attach(traj.write, interval=1)
        dyn.attach(printenergy, interval=1)
        dyn.run(100)

    sys.stdout = orig_stdout
    f.close()
Ejemplo n.º 28
0
def md_run(origin_poscar_path, index):
    print('%d' % index + ' In directory : %s' % origin_poscar_path)
    atoms = read(origin_poscar_path)

    calc = ANNCalculator(potentials={
        "Ga": "Ga.10t-10t.nn",
        "N": "N.10t-10t.nn"
    })
    atoms.set_calculator(calc)

    MaxwellBoltzmannDistribution(atoms, 1200 * kB)
    Stationary(atoms)

    md = NVT(atoms, timestep=2 * fs, temperature=1000 * kB, friction=0.05)
    logger = MDLogger(md, atoms, '-', stress=True)
    md.attach(logger, interval=1)
    traj = Trajectory(
        "nvt_%s.traj" % (origin_poscar_path.split('/')[-1].split('.xsf')[0]),
        "w", atoms)
    md.attach(traj.write, interval=200)

    md.run(40000)
Ejemplo n.º 29
0
def cylinderDynamics(R, T, params):
    
    nk      =   params['nk']        #20
    fmax    =   params['fmax']      #1E-2
    fric    =   params['fric']      #0.002         
    dt      =   params['dt']        #5.0
    mdsteps =   params['mdsteps']   #int(10/fric/dt)
    path    =   params['path']      #'/space/tohekorh/Au_bend/files/'
    
    print 'radius',R, '\n'
    name    =   '%.1f' %R
    
    # Get the optimal flat atoms , unit-cell config for this temperature:
    atoms       =   get_opmAtomsFlat(T, params)

    # Take the diagonal of the cell:
    L           =   atoms.get_cell().diagonal()

     
    atoms.set_cell(L) 
    
    # The wedge angle is:
    angle       =   L[1]/R
    
    # fiddle with atoms:
    atoms.rotate('y', np.pi/2)
    atoms.translate((-atoms[0].x, 0, 0) )
    
    #view(atoms)
    
    # Initial map for atoms, to get the on surface of cylinder:
    phi_max     =   angle
    for a in atoms:
        r0      =   a.position
        phi     =   r0[1]/L[1]*phi_max
        a.position[0]   =   R*np.cos(phi)
        a.position[1]   =   R*np.sin(phi)

    #view(atoms)
    
    # proper number of kappa points in angle direction, if angle >= 2*pi/3 the use genuine 
    # physical boundary conditions and proper kappa-points. With 64 atoms in unit cell souhld not 
    # happen as the radius -> very small if angle = 2*pi/3 or larger.
    
    # Check that the unit-cell angle is 2*pi/integer. This can be removed! 
    if (2*np.pi/angle)%1 > 0:
        raise 
    
    # This does not have any effect unless angle >= 2*pi/3:
    m           =   int(round(2*np.pi/angle))
    physical    =   False
    if m <= 3:
        nk1 =   m
        physical = True
    else:
        nk1     =   nk
    
    # Set up the wedge container:
    atoms       =   Atoms(atoms = atoms, container = 'Wedge')
    atoms.set_container(angle = angle, height = L[0], physical = physical, pbcz = True)
    
    # Check that everything looks good:
    #view(atoms.extended_copy((2,1,2)))
    
    
    # FOLDERS
    path_opm    =   path + 'cylinder/opm/T=%.0f/' %T
    path_md     =   path + 'cylinder/md_data/T=%.0f/' %T
    
    checkAndCreateFolder(path_opm)
    checkAndCreateFolder(path_md)
    
    
    # CALCULATOR
    calc        =   Hotbit(SCC=False, kpts=(nk1, 1, nk), physical_k = physical, \
                    txt= path_opm + 'optimization_%s.cal' %name)
    atoms.set_calculator(calc)
    
    # RELAX
    opt         =   BFGS(atoms, trajectory= path_opm + 'optimization_%s.traj' %name)
    opt.run(fmax=fmax, steps=1000)
    
    
    # DYNAMICS
    traj        =   PickleTrajectory(path_md + 'md_R%.3f.traj' %R,'w',atoms)   
    
    # Perform dynamics
    dyn         =   Langevin(atoms, dt*units.fs, units.kB*T, fric)
    dyn.attach(MDLogger(dyn, atoms, path_md + 'md_R%.3f.log' %R, header=True, stress=False,
           peratom=True, mode="w"), interval = 1)
    
    dyn.attach(traj.write)
    dyn.run(mdsteps)
    traj.close()
    
    # load the dynamics back, to make exteded trajectory:
    traj        =   PickleTrajectory(path_md + 'md_R%.3f.traj' %R)
    trajToExtTraj(traj, (2, 1, 2), R, T, angle, L[0], path)
    
    
    
    
    
    
Ejemplo n.º 30
0
bottom_mask = np.loadtxt("bottom_mask.txt").astype(bool)
top_mask = np.loadtxt("top_mask.txt").astype(bool)

damp = pc.AutoDamping(C11, p_c)
slider = pc.SlideWithNormalPressureCuboidCell(top_mask, bottom_mask, Pdir, P,
                                              vdir, v, damp)
atoms.set_constraint(slider)

calc = ASE_CALCULATOR_OBJECT  # put a specific calculator here

atoms.set_calculator(calc)
temps = np.zeros((len(atoms), 3))
temps[slider.middle_mask, slider.Tdir] = kB * T
gammas = np.zeros((len(atoms), 3))
gammas[slider.middle_mask, slider.Tdir] = gamma_langevin
integrator = Langevin(atoms, dt, temps, gammas, fixcm=False)
trajectory = Trajectory('slide.traj', 'a', atoms)  # append

with open('log_slide.txt', 'r', encoding='utf-8') as log_handle:
    step_offset = pc.SlideLog(log_handle).step[-1]
log_handle = open('log_slide.txt', 'a', 1,
                  encoding='utf-8')  # line buffered append
logger = pc.SlideLogger(log_handle, atoms, slider, integrator, step_offset)

integrator.attach(logger)
integrator.attach(trajectory)
integrator.run(steps_integrate)
log_handle.close()
trajectory.close()
Ejemplo n.º 31
0
def test(temp, frict):
    output = file('Langevin.dat', 'w')
    
    # Make a small perturbation of the momenta
    atoms.set_momenta(1e-6 * np.random.random([len(atoms), 3]))
    print 'Initializing ...'
    predyn = VelocityVerlet(atoms, 0.5)
    predyn.run(2500)

    dyn = Langevin(atoms, timestep, temp, frict)
    print ''
    print ('Testing Langevin dynamics with T = %f eV and lambda = %f' %
           (temp, frict))
    ekin = atoms.get_kinetic_energy()/len(atoms)
    print ekin
    output.write('%.8f\n' % ekin)

    print 'Equilibrating ...'

    # Initial guesses for least-squares fit
    a = 0.04
    b = 2*frict
    c = temp
    params = (a,b,c)
    fitdata = [(0, 2.0 / 3.0 * ekin)]

    tstart = time.time()
    for i in xrange(1,nequil+1):
        dyn.run(nminor)
        ekin = atoms.get_kinetic_energy() / len(atoms)
        fitdata.append((i*nminor*timestep, 2.0/3.0 * ekin))
        if usescipy and i % nequilprint == 0:
            (params, chisq) = leastSquaresFit(targetfunc, params, fitdata)
            print '%.6f  T_inf = %.6f (goal: %f), tau = %.2f,  k = %.6f' % \
                  (ekin, params[2], temp, 1.0/params[1], params[0])
        output.write('%.8f\n' % ekin)
    tequil = time.time() - tstart
    print 'This took %s minutes.' % (tequil / 60)
    output.write('&\n')
    assert abs(temp-params[2]) < 0.25*temp, 'Least-squares fit is way off'
    assert nequil*nminor*timestep > 3.0/params[1], 'Equiliberation was too short'
    fitdata = np.array(fitdata)

    print 'Recording statistical data - this takes ten times longer!'
    temperatures = []
    tstart = time.time()
    for i in xrange(1,nsteps+1):
        dyn.run(nminor)
        ekin = atoms.get_kinetic_energy() / len(atoms)
        temperatures.append(2.0/3.0 * ekin)
        if i % nprint == 0:
            tnow = time.time() - tstart
            tleft = (nsteps-i) * tnow / i
            print '%.6f    (time left: %.1f minutes)' % (ekin, tleft/60)
        output.write('%.8f\n' % ekin)
    output.write('&\n')
    output.close()

    temperatures = np.array(temperatures)
    mean = sum(temperatures) / len(temperatures)
    print 'Mean temperature:', mean, 'eV'
    print
    print 'This test is statistical, and may in rare cases fail due to a'
    print 'statistical fluctuation.'
    print
    assert abs(mean - temp) <= reltol*temp, 'Deviation is too large.'
    print 'Mean temperature:', mean, ' in ', temp, ' +/- ', reltol*temp

    return fitdata, params, temperatures
Ejemplo n.º 32
0
def run_moldy():
    
    KC = False
    
    # DEFINE FILES
    mdfile, mdlogfile   =   'md.traj', 'md.log'   
    
    atoms               =   make_graphene_slab(a,h,width,4,2, passivate = True)[3]
    
   
    params              =   {'bond':bond, 'a':a, 'h':h}
    params['positions'] =   atoms.positions.copy() 
    params['pbc']       =   atoms.get_pbc()
    params['cell']      =   atoms.get_cell().diagonal()
    params['ia_dist']   =   14
    params['chemical_symbols']  =   atoms.get_chemical_symbols()
    
    constraints =   []
    add_kc      =   KC_potential(params)
    left        =   get_ind(atoms.positions.copy(), 'left', 1, bond)
    rend        =   get_ind(atoms.positions.copy(), 'rend', atoms.get_chemical_symbols(), 0)
    
    
    '''
    # FIX
    
    #zset, layer_inds     =   find_layers(atoms.positions.copy())
    
    
    add_adh     =   add_adhesion(params)
    add_kc      =   KC_potential(params)

    
    #constraints.append(add_adh)
    
    # END FIX
    '''
    
    fix_left    =   FixAtoms(indices = left)
    
    for ind in rend:
        fix_deform  =   FixedPlane(ind, (0., 0., 1.))
        constraints.append(fix_deform)
    
    
    constraints.append(fix_left)
    if KC: constraints.append(add_kc)
    
    # CALCULATOR LAMMPS 
    parameters = {'pair_style':'rebo',
                  'pair_coeff':['* * CH.airebo C H'],
                  'mass'      :['1 12.0', '2 1.0'],
                  'units'     :'metal', 
                  'boundary'  :'f p f'}
    
    calc = LAMMPS(parameters=parameters) 
    atoms.set_calculator(calc)
    # END CALCULATOR
    
    
    
    atoms.set_constraint(constraints)
    
    #view(atoms)
    
    
    # TRAJECTORY
    traj    =   PickleTrajectory(mdfile, 'w', atoms)
    
    data    =   np.zeros((M, 6))
    
    # DYNAMICS
    dyn     =   Langevin(atoms, dt*units.fs, T*units.kB, 0.002)
    n       =   0
    header  =   '#t [fs], d [Angstrom], epot_tot [eV], ekin_tot [eV], etot_tot [eV] \n'
    log_f   =   open(mdlogfile, 'w')
    log_f.write(header)            
    log_f.close()

    
    for i in range(0, M):
        #for ind in rend:
        atoms[3].position[2] -= dz 
        dyn.run(1)

        va      =   atoms.get_velocities()
        vamax   =   np.linalg.norm(va[3]*0.0982269353)
        #print vamax
        epot, ekin  =   saveAndPrint(atoms, traj, False)[:2]
        data[n]     =   [i*dt, i*dz, epot, ekin, epot + ekin, vamax]
        
         
        log_f   =   open(mdlogfile, 'a')
        stringi =   ''
        for k,d in enumerate(data[n]):
            if k == 0:           
                stringi += '%.2f ' %d
            elif k == 1:
                stringi += '%.6f ' %d
            else:
                stringi += '%.12f ' %d
        log_f.write(stringi +  '\n')
        log_f.close()
        np.savetxt(mdlogfile, data, header = header)  

        n += 1
            
        if i%(int(M/100)) == 0: print 'ready = %.1f' %(i/(int(M/100))) + '%' 
Ejemplo n.º 33
0
def runAndStudy(params_set, pot_key, save = False):
    
    bond    =   params_set['bond']
    T       =   params_set['T']
    taito   =   params_set['taito']
    dt, fric=   params_set['dt'], params_set['fric']
    tau     =   params_set['tau']
    width   =   params_set['width']
    ratio   =   params_set['ratio']
    edge    =   params_set['edge']
    ncores  =   params_set['ncores']
    Ld_i    =   params_set['Ldilde_i']
    
    bend, straight, [matchL_idx, matchR_idx, vec], [L_bend, L_straight], [left_idxs, right_idxs]\
            =   create_bend_stucture(width, ratio, Ld_i, edge, bond)
    
    mdfile, mdlogfile, mdrelax, simulfile, folder, relaxed \
            =   get_fileName(pot_key, edge + '_corrStick', width, \
                             L_bend, L_straight, int(T), taito, key = 'corrStick')
            
    if relaxed:
        bend    =   PickleTrajectory(mdrelax, 'r')[-1]
    else:
        relaxBend(bend, left_idxs, right_idxs, edge, bond, mdrelax)
        bend.set_constraint([])
        
    shift_v =   -straight.positions[matchR_idx] + (bend.positions[matchL_idx] + vec) 
    straight.translate(shift_v)
    
    atoms   =   bend + straight
    cell    =   [1.5*(L_bend + L_straight), L_bend + L_straight, 20]   
    atoms.set_cell(cell)
    atoms.positions[:,2]    =   3.4
    
    trans_vec   =   trans_atomsKC(straight.positions[matchR_idx], edge, bond)
    atoms.translate(trans_vec)
    
    #plot_posits(atoms, edge, bond)
    
    if edge == 'ac':
        nx  =   int((cell[0]/5 - np.min(atoms.positions[:,0]))/(3*bond))  
        ny  =   int((cell[1]/5 - np.min(atoms.positions[:,1]))/(np.sqrt(3)*bond))  
        atoms.translate([nx*3.*bond, ny*np.sqrt(3)*bond, 0])
        width_f =   np.sqrt(3)/2.*bond*(width - 1)
    elif edge == 'zz':
        nx  =   int((cell[0]/5 - np.min(atoms.positions[:,0]))/(np.sqrt(3)*bond))  
        ny  =   int((cell[1]/5 - np.min(atoms.positions[:,1]))/(3*bond))  
        atoms.translate([nx*np.sqrt(3)*bond, ny*3*bond, 0])
        width_f =   (3./2.*width - 1)*bond
    
    cminx, cmaxx    =   strip_Hend(atoms, 'right')
    left_b          =   get_idxOfEnds(atoms, cminx, cmaxx)[0]
    
    # CONSTRAINTS
    constraints =   []
    constraints.append(FixAtoms(indices = left_b))
    
    params      =   {}
    params['positions']         =   atoms.positions
    params['chemical_symbols']  =   atoms.get_chemical_symbols()   
    params['ia_dist']           =   10
    params['edge']              =   edge
    params['bond']              =   bond    
    params['ncores']            =   ncores
    add_pot     =   KC_potential_p(params)
    constraints.append(add_pot)
    atoms.set_constraint(constraints)
    ##
    
    # CALCULATOR
    calc    =   LAMMPS(parameters=get_lammps_params()) 
    atoms.set_calculator(calc)
    ##
    
    # DYNAMICS
    dyn     =   Langevin(atoms, dt*units.fs, T*units.kB, fric)
    header  =   '#t [fs], shift y [Angstrom], Rad, theta [rad], hmax [A], epot_tot [eV], ekin_tot [eV], etot_tot [eV], F [eV/angst] \n'
    write_line_own(mdlogfile, header, 'w')
    traj    =   PickleTrajectory(mdfile, 'w', atoms)
    
    if T != 0:
        # put initial MaxwellBoltzmann velocity distribution
        mbd(atoms, T*units.kB)
    ####
    
    # SIMULATION PARAMS 
    nframes     =   1000
    M           =   int(20*tau/dt)
    interval    =   int(M/nframes)
    thres_cancel=   2*bond
    stick       =   'True'
    xmax_idx    =   np.where(atoms.positions[:,0] == np.max(atoms.positions[:,0]))[0][0]
    r_init      =   atoms.positions[xmax_idx].copy()  
    
    R   =   L_bend/np.pi*3.
    print '# data_line: width, length bend, length tail, tail/bend, theta'
    print width_f, L_bend, L_straight, L_straight/L_bend, width_f/(2*R)
    # SIMULATION LOOP
    for i in range(nframes):
        
        print float(i)/nframes*100.
        dyn.run(interval)
        
        epot, ekin  =   saveAndPrint(atoms, traj, False)[:2]
        data        =   [i*interval*dt, epot, ekin, epot + ekin]
        
        if save:
            stringi =   ''
            for k,d in enumerate(data):
                if k == 0:           
                    stringi += '%.2f ' %d
                elif k == 1 or k == 2:
                    stringi += '%.4f ' %d
                else:
                    stringi += '%.12f ' %d
            write_line_own(mdlogfile, stringi +  '\n', 'a')
        
        #print np.linalg.norm(atoms.positions[xmax_idx] - r_init)
        if thres_cancel <   np.linalg.norm(atoms.positions[xmax_idx] - r_init):
            stick   =   'false'
            break 
    
    make_stick_simul_param_file(simulfile, width, L_bend, L_straight, T, \
                                dt, fric, interval, M, edge, stick)
    
    return stick == 'True'
        
    #plot_posits(atoms, edge, bond)
    #view(atoms)
Ejemplo n.º 34
0

def printenergy(a, it, t0):
    """Function to print the potential, kinetic and total energy"""
    epot = a.get_potential_energy() / len(a)
    ekin = a.get_kinetic_energy() / len(a)
    t_now = time()
    print('Step: %4d [%6.2f]: Epot = %.3feV  Ekin = %.3feV (T=%3.0fK)  '
          'Etot = %.3feV ' % (\
          it, t_now-t0, epot, ekin, ekin / (1.5 * units.kB), epot + ekin))
    return t_now


ff = PyXtal_FF(model={'system': ["Si"]}, logo=False)
ff.run(mode='predict', mliap=options.file)
calc = PyXtalFFCalculator(ff=ff)

si = bulk('Si', 'diamond', a=5.659, cubic=True)
si = si * 5
print("MD simulation for ", len(si), " atoms")
si.set_calculator(calc)

MaxwellBoltzmannDistribution(si, 1000 * units.kB)
dyn = Langevin(si, timestep=5 * units.fs, temperature_K=1000, friction=0.02)
#dyn = VelocityVerlet(si, 5*units.fs)  # 2 fs time step.
t0 = time()
for i in range(10):
    dyn.run(steps=1)
    t_now = printenergy(si, i, t0)
    t0 = t_now
# Now let's set the calculator for ``atoms``:
atoms.set_calculator(calculator)

# Now let's minimize the structure:
print("Begin minimizing...")
opt = BFGS(atoms)
opt.run(fmax=0.001)
print()


# Now create a callback function that print interesting physical quantities:
def printenergy(a=atoms):
    """Function to print the potential, kinetic and total energy."""
    epot = a.get_potential_energy() / len(a)
    ekin = a.get_kinetic_energy() / len(a)
    print('Energy per atom: Epot = %.3feV  Ekin = %.3feV (T=%3.0fK)  '
          'Etot = %.3feV' % (epot, ekin, ekin / (1.5 * units.kB), epot + ekin))


# We want to run MD with constant energy using the Langevin algorithm
# with a time step of 1 fs, the temperature 300K and the friction
# coefficient to 0.02 atomic units.
dyn = Langevin(atoms, 1 * units.fs, 300 * units.kB, 0.2)
dyn.attach(printenergy, interval=50)

# Now run the dynamics:
print("Beginning dynamics...")
printenergy()
dyn.run(500)
Ejemplo n.º 36
0
def main():
    
    T = 300.0 # Simulation temperature
    dt = 1 * units.fs # MD timestep
    nsteps = 100000 # MD number of steps
    mixing = [1,-1,0] # [1.0, -1.0, 0.3] # mixing weights for "real" and ML forces
    lengthscale = 0.5 # KRR Gaussian width.
    gamma = 1 / (2 * lengthscale**2)
    grid_spacing = 0.05
    #     mlmodel = GaussianProcess(corr='squared_exponential', 
    #         # theta0=1e-1, thetaL=1e-4, thetaU=1e+2,
    #         theta0=1., 
    #         random_start=100, normalize=False, nugget=1.0e-2)
    mlmodel = KernelRidge(kernel='rbf', 
                          gamma=gamma, gammaL = gamma/4, gammaU=2*gamma,
                           alpha=1.0e-2, variable_noise=False, max_lhood=False)
    anglerange = sp.arange(0, 2*sp.pi + grid_spacing, grid_spacing)
    X_grid = sp.array([[sp.array([x,y]) for x in anglerange]
                       for y in anglerange]).reshape((len(anglerange)**2, 2))
    ext_field = None # IgnoranceField(X_grid, y_threshold=-0.075, cutoff = 3.)
                           
    # Bootstrap from initial database? uncomment
    # data = sp.loadtxt('phi_psi_F.csv')
    # # data[:,:2] -= 0.025 # fix because of old round_vector routine
    # mlmodel.fit(data[:,:2], data[:,2])
    # ext_field.update_cost(mlmodel.X_fit_, mlmodel.y)

    # mlmodel.fit(X_grid, sp.zeros(len(X_grid)))
    # mlmodel.fit(sp.load('X_fitD.npy'), sp.load('y_fitD.npy'))
    
    # Prepare diagnostic visual effects.
    plt.close('all')
    plt.ion()
    fig, ax = plt.subplots(1, 2, figsize=(24, 13))
    
    atoms = ase.io.read('myplum.xyz')
    with open('data.input', 'r') as file:
        lammpsdata = file.readlines()

    # Set temperature
    MaxwellBoltzmannDistribution(atoms, 0.5 * units.kB * T, force_temp=True)
    # Set total momentum to zero
    p = atoms.get_momenta()
    p -= p.sum(axis=0) / len(atoms)
    atoms.set_momenta(p)
    atoms.rescale_velocities(T)
    
    # Select MD propagator
    mdpropagator = Langevin(atoms, dt, T*units.kB, 1.0e-2, fixcm=True)
    # mdpropagator = MLVerlet(atoms, dt, T)

    # Zero-timestep evaluation and data files setup.
    print("START")
    pot_energy, f = calc_lammps(atoms, preloaded_data=lammpsdata)
    mlmodel.accumulate_data(round_vector(atoms.colvars(), precision=grid_spacing), 0.)
    # mlmodel.accumulate_data(round_vector(atoms.colvars(), precision=grid_spacing), pot_energy)
    printenergy(atoms, pot_energy)
    try:
        os.remove('atomstraj.xyz')
    except:
        pass
    traj = open("atomstraj.xyz", 'a')
    atoms.write(traj, format='extxyz')
    results, traj_buffer = [], []

    # When in the simulation to update the ML fit -- optional.
    teaching_points = sp.unique((sp.linspace(0, nsteps**(1/3), nsteps/20)**3).astype('int') + 1)

    # MD Loop
    for istep in range(nsteps):
        # Flush Cholesky decomposition of K
        if istep % 1000 == 0:
            mlmodel.Cho_L = None
            mlmodel.max_lhood = False
        print("Dihedral angles | phi = %.3f, psi = %.3f " % (atoms.phi(), atoms.psi()))
        do_update = (istep % 60 == 59)
        t = get_time()
        mdpropagator.halfstep_1of2(f)
        print("TIMER 001 | %.3f" % (get_time() - t))
        t = get_time()
        f, pot_energy, _ = get_all_forces(atoms, mlmodel, grid_spacing, T, extfield=ext_field, mixing=mixing, lammpsdata=lammpsdata, do_update=do_update)
        if do_update and mlmodel.max_lhood:
            mlmodel.max_lhood = False
        mdpropagator.halfstep_2of2(f)
        print("TIMER 002 | %.3f" % (get_time() - t))


        # manual cooldown!!!
        if sp.absolute(atoms.get_kinetic_energy() / (1.5 * units.kB * atoms.get_number_of_atoms()) - T) > 100:
            atoms.rescale_velocities(T)

        printenergy(atoms, pot_energy/atoms.get_number_of_atoms(), step=istep)
        # if do_update:
        #     try:
        #         print("Lengthscale = %.3e, Noise = %.3e" % (1/(2 * mlmodel.gamma)**0.5, mlmodel.noise.mean()))
        #     except:
        #         print("")
        if istep % 60 == 59:
            t = get_time()
            if 'datasetplot' not in locals():
                datasetplot = pl.Plot_datapts(ax[0], mlmodel)
            else:
                datasetplot.update()
            if hasattr(mlmodel, 'dual_coef_'):
                if 'my2dplot' not in locals():
                    my2dplot = pl.Plot_energy_n_point(ax[1], mlmodel, atoms.colvars().ravel())
                else:
                    my2dplot.update_prediction()
                    my2dplot.update_current_point(atoms.colvars().ravel())
            print("TIMER 003 | %.03f" % (get_time() - t))
            t = get_time()
            fig.canvas.draw()
            print("TIMER 004 | %.03f" % (get_time() - t))
            # fig.canvas.print_figure('current.png')
        t = get_time()
        # traj_buffer.append(atoms.copy())
        # if istep % 100 == 0:
        #     for at in traj_buffer:
        #         atoms.write(traj, format='extxyz')
        #     traj_buffer = []
        results.append(sp.array([atoms.phi(), atoms.psi(), pot_energy]))
        print("TIMER 005 | %.03f" % (get_time() - t))        
    traj.close()
    print("FINISHED")
    sp.savetxt('results.csv', sp.array(results))
    sp.savetxt('mlmodel.dual_coef_.csv', mlmodel.dual_coef_)
    sp.savetxt('mlmodel.X_fit_.csv', mlmodel.X_fit_)
    sp.savetxt('mlmodel.y.csv', mlmodel.y)
    calc = None
    
    return mlmodel
Ejemplo n.º 37
0
    mixer_forces = [forces_full_system]
    mixer_energies = [energy_full_system]
elif calc_style == "quantum":
    mixer_forces = [forces_qbox_gpaw]
    mixer_energies = [energy_qbox_gpaw]

mixer = Mixer(name="mixer_box",
              forces=mixer_forces,
              energies=mixer_energies,
              debug=debug)
atoms.set_calculator(mixer)

dyn = None

if md_style == "Langevin":
    dyn = Langevin(atoms, timestep, 1.5*T*units.kB, 0.002)
elif md_style == "Verlet":
    dyn = VelocityVerlet(atoms, timestep)
elif md_style == "TESTING":
    dyn = DynTesting(atoms, timestep=0.1*units.fs, offset=(0.1, 0., 0.))

energy_file = None

def printenergy(a=atoms):
    epot = a.get_potential_energy() / len(a)
    ekin = a.get_kinetic_energy() / len(a)
    energy_file.write("%.5e,%.5e,%.5e,%.5e" %
        (epot + ekin, epot, ekin, ekin/(1.5*units.kB)) + "\n")

# only enable logging for master node where rank == 0
if rank == 0:
Ejemplo n.º 38
0
def sphereDynamics(R, T, params):
    
    d       =   params['d']         #2.934
    nk      =   params['nk']        #20
    fmax    =   params['fmax']      #1E-2
    fric    =   params['fric']      #0.002        # equilibration time tau = 10 fs/fric (= mdsteps*dt) 
    dt      =   params['dt']        #5.0
    mdsteps =   params['mdsteps']   #int(10/fric/dt)
    path    =   params['path']      #'/space/tohekorh/Au_bend/files/'
    uzsize  =   params['uz_size']
    
    print 'radius',R
    name    =   '%.1f' %R
    
    # ATOMS
    #atoms   =   fcc111('Au',size=uzsize,a=np.sqrt(2)*d)
    atoms       =   get_opmAtomsFlat(T, params)
    
    atoms.rotate((0,0,1), -np.pi/6, rotate_cell = True)
    
    length1 =   np.linalg.norm( atoms.get_cell()[0] )
    length2 =   np.linalg.norm( atoms.get_cell()[1] )
    
    n1      =   ( np.cos(np.pi/3),  np.sin(np.pi/3), 0)
    n2      =   (-np.cos(np.pi/3),  np.sin(np.pi/3), 0)
    angle1  =   length1/R
    angle2  =   length2/R
    
    #view(atoms)    
    # Scale the atoms close to ball
    Lx = np.linalg.norm(atoms.get_cell()[0] + atoms.get_cell()[1])
    Ly = np.linalg.norm(atoms.get_cell()[0] - atoms.get_cell()[1])
     
    phi_max     =   Ly/R
    theta_max   =   Lx/R
    for a in atoms:
        r0      =   a.position
        phi     =   r0[1]/Ly*phi_max
        theta   =   r0[0]/Lx*theta_max
        a.position[0]   =   R*np.sin(theta) #*np.sin(theta)
        a.position[1]   =   R*np.sin(phi) #a.position[1] #R*np.sin(phi) #*np.sin(theta)
        a.position[2]   =   R*np.cos(theta)
    #atoms.translate((0,0,R))
    # End scaling
    
    atoms   =   Atoms(atoms=atoms,container='Sphere')
    atoms.set_container(angle1=angle1,angle2=angle2,n1=n1,n2=n2,mode=4)
    
    #view(atoms.extended_copy((2,2,1)))
    
    # FOLDERS
    path_md =   path + 'sphere/md_data/T=%.0f/' %T
    path_opm=   path + 'sphere/opm/T=%.0f/' %T

    checkAndCreateFolder(path_md)
    checkAndCreateFolder(path_opm)
    
    # CALCULATOR
    calc    =   Hotbit(SCC=False, kpts=(nk,nk,1),txt= path_opm + 'optimization_%s.cal' %name,)
    atoms.set_calculator(calc)
    
    # RELAX
    opt     =   BFGS(atoms, trajectory= path_opm + 'optimization_%s.traj' %name)
    opt.run(fmax=fmax,steps=1000)
    
    #write(path_opm + 'opm_structure_R%.3f' %R, atoms, format='traj')
    
    # DYNAMICS
    traj        =   PickleTrajectory(path_md + 'md_R%.3f.traj' %R, 'w', atoms)   
    dyn         =   Langevin(atoms, dt*units.fs, units.kB*T,fric)
    
    dyn.attach(MDLogger(dyn, atoms, path_md + 'md_R%.3f.log' %R, header=True, stress=False,
           peratom=True, mode="w"), interval = 1)
    dyn.attach(traj.write)
    dyn.run(mdsteps)
    traj.close()
    
    # load the dynamics back.. To write the extended trajectory
    traj        =   PickleTrajectory(path_md + 'md_R%.3f.traj' %R)
    trajToExtTraj(traj, (2, 2, 1), R, T, angle1, angle2, n1, n2, path)
    

    
    
    
    
    
Ejemplo n.º 39
0
class clustergenerator():
    def __init__(self,
                 cnstfile,
                 saefile,
                 nnfprefix,
                 Nnet,
                 solv_list,
                 solu_list,
                 gpuid=0,
                 sinet=False):
        # Molecules list
        self.solv_list = solv_list
        self.solu_list = solu_list

        # Number of networks
        self.Nn = Nnet

        # Build ANI ensemble
        self.aens = ensemblemolecule(cnstfile, saefile, nnfprefix, Nnet, gpuid)

        self.edgepad = 1.0
        self.mindist = 2.0

    #def closeoutputs(self):
    #    self.mdcrd.close()
    #    self.traj.close()

    def __generategarbagebox__(self, Nm, Nembed, L, T):
        self.X = np.empty((0, 3), dtype=np.float32)
        self.S = []
        self.C = np.zeros((Nm, 3), dtype=np.float32)

        rint = np.random.randint(len(self.solv_list), size=Nm)
        self.Na = np.zeros(Nm, dtype=np.int32)
        self.ctd = []

        pos = 0
        plc = 0
        for idx, j in enumerate(rint):
            if idx < Nembed:
                ri = np.random.randint(len(self.solu_list), size=1)
                s = self.solu_list[ri[0]]['species']
                xyz = self.solu_list[ri[0]]['coordinates']
                nmc = self.solu_list[ri[0]]['nmdisplacements']
                frc = self.solu_list[ri[0]]['forceconstant']

                nms = nmt.nmsgenerator(xyz, nmc, frc, s, T, minfc=5.0E-2)
                x = nms.get_Nrandom_structures(1)[0]

            else:
                s = self.solv_list[j]['species']
                xyz = self.solv_list[j]['coordinates']
                nmc = self.solv_list[j]['nmdisplacements']
                frc = self.solv_list[j]['forceconstant']

                nms = nmt.nmsgenerator(xyz, nmc, frc, s, T, minfc=5.0E-2)
                x = nms.get_Nrandom_structures(1)[0]

            # Apply a random rotation
            M = rand_rotation_matrix()
            x = np.dot(x, M.T)

            maxd = hdn.generatedmatsd3(x).flatten().max() / 2.0

            Nf = 0
            fail = True
            while fail:
                ctr = np.random.uniform(2.0 * maxd + self.edgepad,
                                        L - 2.0 * maxd - self.edgepad, (3))
                fail = False
                for cid, c in enumerate(self.ctd):
                    if np.linalg.norm(c[0] - ctr) < maxd + c[1] + 10.0:
                        # search for atoms within r angstroms
                        minv = 1000.0
                        for xi in self.X[c[2]:c[2] + self.Na[cid], :]:
                            for xj in x + ctr:
                                dij = np.linalg.norm(xi - xj)
                                if dij < minv:
                                    minv = dij
                        if minv < self.mindist:
                            fail = True
                            Nf += 1

                if not fail:
                    plc += 1
                    #print('Added:',plc)
                    self.ctd.append((ctr, maxd, pos))
                    self.X = np.vstack([self.X, x + ctr])
                    self.Na[idx] = len(s)
                    pos += len(s)
                    #print('Placement Complete...',plc,'-',Nf)
                    self.S.extend(s)

    def init_dynamics(self, Nm, Nembed, V, L, dt, T):
        self.L = L

        # Generate the box of junk
        self.__generategarbagebox__(Nm, Nembed, L, T)

        # Make mol
        self.mol = Atoms(symbols=self.S, positions=self.X)

        # Set box and PBC
        self.mol.set_cell(([[L, 0, 0], [0, L, 0], [0, 0, L]]))

        self.mol.set_pbc((True, True, True))

        # Set ANI calculator
        self.mol.set_calculator(ANIENS(self.aens))

        # Open MD output
        #self.mdcrd = open(xyzfile, 'w')

        # Open MD output
        #self.traj = open(trjfile, 'w')

        # Set the velocities corresponding to a boltzmann dist @ T/4.0
        MaxwellBoltzmannDistribution(self.mol, 300.0 * units.kB)

        # Declare Dyn
        self.dyn = Langevin(self.mol, dt * units.fs, T * units.kB, 0.1)

        # Define the printer
        #def printenergy(a=self.mol, d=self.dyn, b=self.mdcrd, t=self.traj):  # store a reference to atoms in the definition.
        #    """Function to print the potential, kinetic and total energy."""
        #    epot = a.get_potential_energy() / len(a)
        #    ekin = a.get_kinetic_energy() / len(a)
        #
        #    stddev = hdn.evtokcal * a.calc.stddev
        #
        #    t.write(str(d.get_number_of_steps()) + ' ' + str(ekin / (1.5 * units.kB)) + ' ' + str(epot) + ' ' + str(
        #        ekin) + ' ' + str(epot + ekin) + '\n')
        #    b.write(str(len(a)) + '\n' + str(ekin / (1.5 * units.kB)) + ' Step: ' + str(d.get_number_of_steps()) + '\n')
        #    c = a.get_positions(wrap=True)
        #    for j, i in zip(a, c):
        #        b.write(str(j.symbol) + ' ' + str(i[0]) + ' ' + str(i[1]) + ' ' + str(i[2]) + '\n')
        #
        #    print('Step: %d Energy per atom: Epot = %.3feV  Ekin = %.3feV (T=%3.0fK)  '
        #          'Etot = %.3feV' ' StdDev = %.3fkcal/mol/sqrt(Na)' % (
        #          d.get_number_of_steps(), epot, ekin, ekin / (1.5 * units.kB), epot + ekin, stddev))

        # Attach the printer
        #self.dyn.attach(printenergy, interval=1)

    def run_dynamics(self, Ni):
        for id, nc in enumerate(self.aens.ncl):
            nc.setMolecule(coords=np.array(self.mol.get_positions(),
                                           dtype=np.float32),
                           types=self.mol.get_chemical_symbols())

        self.dyn.run(Ni)  # Do Ni steps

    def __fragmentbox__(self, file, sighat):
        self.X = self.mol.get_positions()

        self.frag_list = []

        self.Nd = 0
        self.Nt = 0

        self.maxsig = 0

        for i in range(len(self.Na)):
            si = self.ctd[i][2]
            di = self.ctd[i][1]
            Nai = self.Na[i]
            Xci = np.sum(self.X[si:si + Nai, :], axis=0) / Nai
            Xi = self.X[si:si + Nai, :]

            if np.all(Xci > 4.5) and np.all(Xci <= self.L - 4.5):

                if np.all(Xci > di) and np.all(Xci < self.L - di):
                    Xf = Xi
                    Sf = self.S[si:si + Nai]

                    Nmax = random.randint(2, 14)
                    Nmol = 0
                    for j in range(len(self.Na)):
                        if i != j:
                            sj = self.ctd[j][2]
                            dj = self.ctd[j][1]
                            Naj = self.Na[j]
                            Xcj = np.sum(self.X[sj:sj + Naj, :], axis=0) / Naj
                            Xj = self.X[sj:sj + Naj, :]

                            if np.all(Xcj > dj) and np.all(Xcj < self.L - dj):
                                dc = np.linalg.norm(Xci - Xcj)
                                if dc < di + dj + 5.0:
                                    min = 10.0
                                    for ii in range(Nai):
                                        Xiii = Xi[ii]
                                        for jj in range(Naj):
                                            Xjjj = Xj[jj]
                                            v = np.linalg.norm(Xiii - Xjjj)
                                            if v < min:
                                                min = v

                                    if min < 4.5 and min > 0.70:
                                        Xf = np.vstack([Xf, Xj])
                                        Sf.extend(self.S[sj:sj + Naj])
                                        Nmol += 1
                            if Nmol >= Nmax:
                                break

                    Xcf = np.sum(Xf, axis=0) / float(len(Sf))
                    Xf = Xf - Xcf

                    E = np.empty(5, dtype=np.float64)
                    for id, nc in enumerate(self.aens.ncl):
                        nc.setMolecule(coords=np.array(Xf, dtype=np.float32),
                                       types=Sf)
                        E[id] = nc.energy()[0]

                    sig = np.std(hdn.hatokcal * E) / np.sqrt(Nai + Naj)
                    #print('Mol(',i,'): sig=',sig)

                    self.Nt += 1
                    if sig > sighat:
                        if sig > self.maxsig:
                            self.maxsig = sig
                        self.Nd += 1
                        hdn.writexyzfile(file + str(i).zfill(4) + '.xyz',
                                         Xf.reshape(1, Xf.shape[0], 3), Sf)
                        self.frag_list.append(dict({'coords': Xf, 'spec': Sf}))
                        #print(dc, Sf, sig)

    def generate_clusters(self, gcmddict, mol_sizes, id):

        self.edgepad = gcmddict['edgepad']
        self.mindist = gcmddict['mindist']

        dstore = gcmddict['dstore']

        difo = open(
            dstore + 'info_data_mdcluster-' + str(id).zfill(2) + '.nfo', 'w')
        difo.write('Beginning dimer generation...\n')

        Nt = 0
        Nd = 0
        for i in range(gcmddict['Nr']):
            self.init_dynamics(
                mol_sizes[i],
                gcmddict['Nembed'],
                gcmddict['V'],
                gcmddict['L'],
                gcmddict['dt'],
                gcmddict['T'],
            )

            for j in range(gcmddict['Ns']):
                if j is 0:
                    Ni = 0
                else:
                    Ni = gcmddict['Ni']
                self.run_dynamics(Ni)
                self.__fragmentbox__(
                    gcmddict['molfile'] + '-' + str(id).zfill(2) + '-' +
                    str(i).zfill(2) + '-' + str(j).zfill(4) + '_',
                    gcmddict['sig'])
                #print('Step (',i,',',j,') [', str(self.Nd), '/', str(self.Nt),'] generated ',len(self.frag_list),' maxsig: ', self.maxsig,' dimers...')
                difo.write('Step (' + str(i) + ',' + str(i) + ') [' +
                           str(self.Nd) + '/' + str(self.Nt) + '] generated ' +
                           str(len(self.frag_list)) + ' clusters. ' +
                           ' maxsig: ' + "{:.2f}".format(self.maxsig) + '\n')
                Nt += self.Nt
                Nd += self.Nd
                if self.maxsig > gcmddict['maxsig']:
                    difo.write("Terminated after: " +
                               "{:.2f}".format(Ni * gcmddict['Ns'] *
                                               gcmddict['dt']) +
                               'fs for maxsig\n')
                    break
                difo.flush()

            #self.closeoutputs()

        difo.write('Generated ' + str(Nd) + ' of ' + str(Nt) +
                   ' tested dimers. Percent: ' +
                   "{:.2f}".format(100.0 * Nd / float(Nt)))
        difo.close()
Ejemplo n.º 40
0
class dimergenerator():
    def __init__(self,
                 cnstfile,
                 saefile,
                 nnfprefix,
                 Nnet,
                 molecule_list,
                 gpuid=0,
                 sinet=False):
        # Molecules list
        self.mols = molecule_list

        # Number of networks
        self.Nn = Nnet

        # Build ANI ensemble
        self.aens = ensemblemolecule(cnstfile, saefile, nnfprefix, Nnet, gpuid)

        # Construct pyNeuroChem class
        #self.ncl = [pync.molecule(cnstfile, saefile, nnfprefix+str(i)+'/networks/', gpuid, sinet) for i in range(self.Nn)]

    def __generategarbagebox__(self, Nm, L, T):
        self.X = np.empty((0, 3), dtype=np.float32)
        self.S = []
        self.C = np.zeros((Nm, 3), dtype=np.float32)

        rint = np.random.randint(len(self.mols), size=Nm)
        self.Na = np.zeros(Nm, dtype=np.int32)
        self.ctd = []

        pos = 0
        plc = 0
        attempts = 0
        for idx, j in enumerate(rint):
            if attempts >= 10000:
                break
            #x = self.mols[j]['coordinates']
            #s = self.mols[j]['species']

            s = self.mols[j]['species']
            xyz = self.mols[j]['coordinates']
            nmc = self.mols[j]['nmdisplacements']
            frc = self.mols[j]['forceconstant']

            nms = nmt.nmsgenerator(xyz, nmc, frc, s, T, minfc=5.0E-2)
            x = nms.get_Nrandom_structures(1)[0]

            # Apply a random rotation
            M = rand_rotation_matrix()
            x = np.dot(x, M.T)

            maxd = hdn.generatedmatsd3(x).flatten().max() / 2.0
            #print('after:', maxd)

            fail = True
            while fail and attempts < 10000:
                ctr = np.random.uniform(2.0 * maxd + 1.0, L - 2.0 * maxd - 1.0,
                                        (3))
                fail = False
                for cid, c in enumerate(self.ctd):
                    if np.linalg.norm(c[0] - ctr) < maxd + c[1] + 10.0:
                        # search for atoms within r angstroms
                        minv = 1000.0
                        for xi in self.X[c[2]:c[2] + self.Na[cid], :]:
                            for xj in x + ctr:
                                dij = np.linalg.norm(xi - xj)
                                if dij < minv:
                                    minv = dij
                        if minv < 1.5:
                            fail = True
                            attempts += 1

                if not fail:
                    plc += 1
                    attempts = 0
                    #print('Added:',plc)
                    self.ctd.append((ctr, maxd, pos))
                    self.X = np.vstack([self.X, x + ctr])
                    self.Na[idx] = len(s)
                    pos += len(s)
                    self.S.extend(s)

        self.Na = self.Na[0:plc]

    def init_dynamics(self, Nm, V, L, dt, T):
        self.L = L

        # Generate the box of junk
        self.__generategarbagebox__(Nm, L, T)

        # Make mol
        self.mol = Atoms(symbols=self.S, positions=self.X)

        # Set box and PBC
        self.mol.set_cell(([[L, 0, 0], [0, L, 0], [0, 0, L]]))

        self.mol.set_pbc((True, True, True))

        # Set ANI calculator
        # Set ANI calculator
        self.mol.set_calculator(ANIENS(self.aens))
        #self.mol.set_calculator(ANI(False))
        #self.mol.calc.setnc(self.ncl[0])

        # Give molecules random velocity
        acc_idx = 0
        vel = np.empty_like(self.X)
        for n in self.Na:
            rv = np.random.uniform(-V, V, size=(3))
            for k in range(n):
                vel[acc_idx + k, :] = rv
            acc_idx += n
        #print(vel)

        self.mol.set_velocities(vel)

        # Declare Dyn
        self.dyn = Langevin(self.mol, dt * units.fs, T * units.kB, 0.1)

    def run_dynamics(self, Ni):
        # Open MD output
        #mdcrd = open(xyzfile, 'w')

        # Open MD output
        #traj = open(trajfile, 'w')

        # Define the printer
        #def printenergy(a=self.mol, d=self.dyn):  # store a reference to atoms in the definition.
        #    """Function to print the potential, kinetic and total energy."""
        #    epot = a.get_potential_energy() / len(a)
        #    ekin = a.get_kinetic_energy() / len(a)

        #    print('Step: %d Size: %d Energy per atom: Epot = %.3feV  Ekin = %.3feV (T=%3.0fK)  '
        #          'Etot = %.3feV' % (d.get_number_of_steps(), len(a), epot, ekin, ekin / (1.5 * units.kB), epot + ekin))

        # Attach the printer
        #self.dyn.attach(printenergy, interval=4)

        self.dyn.run(Ni)  # Do Ni steps

        # Open MD output
        #mdcrd.close()

        # Open MD output
        #traj.close()

    def __fragmentbox__(self, file, sig_cut):
        self.X = self.mol.get_positions()

        self.frag_list = []

        self.Nd = 0
        self.Nt = 0

        for i in range(len(self.Na)):
            si = self.ctd[i][2]
            di = self.ctd[i][1]
            Nai = self.Na[i]
            Xci = np.sum(self.X[si:si + Nai, :], axis=0) / Nai
            Xi = self.X[si:si + Nai, :]

            if np.all(Xci > di) and np.all(Xci < self.L - di):

                for j in range(i + 1, len(self.Na)):
                    sj = self.ctd[j][2]
                    dj = self.ctd[j][1]
                    Naj = self.Na[j]
                    Xcj = np.sum(self.X[sj:sj + Naj, :], axis=0) / Naj
                    Xj = self.X[sj:sj + Naj, :]

                    if np.all(Xcj > dj) and np.all(Xcj < self.L - dj):
                        dc = np.linalg.norm(Xci - Xcj)
                        if dc < di + dj + 6.0:
                            min = 10.0
                            for ii in range(Nai):
                                Xiii = Xi[ii]
                                for jj in range(Naj):
                                    Xjjj = Xj[jj]
                                    v = np.linalg.norm(Xiii - Xjjj)
                                    if v < min:
                                        min = v

                            if min < 4.2 and min > 1.1:
                                Xf = np.vstack([Xi, Xj])
                                Sf = self.S[si:si + Nai]
                                Sf.extend(self.S[sj:sj + Naj])

                                Xcf = np.sum(Xf, axis=0) / (Nai + Naj)
                                Xf = Xf - Xcf

                                E = np.empty(5, dtype=np.float64)
                                for id, nc in enumerate(self.aens.ncl):
                                    nc.setMolecule(coords=np.array(
                                        Xf, dtype=np.float32),
                                                   types=Sf)
                                    E[id] = nc.energy()[0]

                                sig = np.std(
                                    hdn.hatokcal * E) / np.sqrt(Nai + Naj)

                                self.Nt += 1
                                if sig > sig_cut:
                                    self.Nd += 1
                                    hdn.writexyzfile(
                                        file + str(i).zfill(4) + '-' +
                                        str(j).zfill(4) + '.xyz',
                                        Xf.reshape(1, Xf.shape[0], 3), Sf)
                                    self.frag_list.append(
                                        dict({
                                            'coords': Xf,
                                            'spec': Sf
                                        }))
Ejemplo n.º 41
0
from asap3 import EMT   # Way too slow with ase.EMT !
size = 10

T = 1500 # Kelvin

# Set up a crystal
atoms = FaceCenteredCubic(directions=[[1,0,0],[0,1,0],[0,0,1]], symbol="Cu",
                          size=(size,size,size), pbc=False)

# Describe the interatomic interactions with the Effective Medium Theory
atoms.set_calculator(EMT())

# We want to run MD with constant energy using the Langevin algorithm
# with a time step of 5 fs, the temperature T and the friction
# coefficient to 0.02 atomic units.
dyn = Langevin(atoms, 5*units.fs, T*units.kB, 0.002)

#Function to print the potential, kinetic and total energy.
def printenergy(a=atoms):    #store a reference to atoms in the definition.
    epot = a.get_potential_energy() / len(a)
    ekin = a.get_kinetic_energy() / len(a)
    print ("Energy per atom: Epot = %.3feV  Ekin = %.3feV (T=%3.0fK)  Etot = %.3feV" %
           (epot, ekin, ekin/(1.5*units.kB), epot+ekin))
dyn.attach(printenergy, interval=50)

#We also want to save the positions of all atoms after every 100th time step.
traj = PickleTrajectory("moldyn3.traj", 'w', atoms)
dyn.attach(traj.write, interval=50)

# Now run the dynamics
printenergy()
Ejemplo n.º 42
0
 def __init__(self, atoms, timestep, temperature, friction, fixcm=True,
              trajectory=None, logfile=None, loginterval=1):
     assert(getattr(Langevin_ASE, "_lgv_version", 1) >= 2)
     ParallelMolDynMixin.__init__(self, "Langevin", atoms)
     Langevin_ASE.__init__(self, atoms, timestep, temperature, friction, fixcm,
                           trajectory, logfile, loginterval, communicator=None)
Ejemplo n.º 43
0
atoms = FaceCenteredCubic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
                          symbol='Fe',
                          size=(size, size, size),
                          pbc=True,
                          latticeconstant=3.5646)

view(atoms)

atoms.set_calculator(calc)

# MaxwellBoltzmannDistribution(atoms, 300 * units.kB)

# dyn = VelocityVerlet(atoms, 5 * units.fs)
T = 10
dyn = Langevin(atoms, 5 * units.fs, T * units.kB, 0.002)

traj = Trajectory('md.traj', 'w', atoms)
dyn.attach(traj.write, interval=50)


def printenergy(a):
    """Function to print the potential, kinetic and total energy"""
    epot = a.get_potential_energy() / len(a)
    ekin = a.get_kinetic_energy() / len(a)
    print('Energy per atom: Epot = %.3feV  Ekin = %.3feV (T=%3.0fK)  '
          'Etot = %.3feV' % (epot, ekin, ekin / (1.5 * units.kB), epot + ekin))


printenergy(atoms)
Ejemplo n.º 44
0
d = 2.934
for R in r0list:
    print 'radius',R
    name=(folder,'%.1f' %R)

    atoms = fcc111('Au',size=(2,2,1),a=sqrt(2)*d)
    L = atoms.get_cell().diagonal()
    atoms. set_cell(L) 
    
    angle = L[1]/R
    atoms.rotate('y',pi/2)
    atoms.translate( (-atoms[0].x,0,0) )
    atoms.translate((R,0,0))
    atoms = Atoms(atoms=atoms,container='Wedge')
    atoms.set_container(angle=angle,height=L[0],physical=False,pbcz=True)
    
    calc = Hotbit(SCC=False,txt='%s/optimization_%s.cal' %name,kpts=(nk,1,nk),physical_k=False)
    atoms.set_calculator(calc)

    traj    =   PickleTrajectory( 'md_R%.3f-T%.0f.traj' %(R,T),'w',atoms)   
    dyn     =   Langevin(atoms,dt*units.fs,units.kB*T,fric)
    dyn.attach(MDLogger(dyn, atoms, path + 'md_R%.3f-T%.0f.log' %(R,T), header=False, stress=False,
           peratom=True, mode="w"), interval = 1)
    dyn.run(mdsteps)
    
   
    cohesion = mean([atoms.get_potential_energy() for a in traj]) /len(atoms)
    
    savez('%s/data_%s.npz' %name,cohesion=cohesion)
    io.write('%s/extended_%s.traj' %name,atoms2)