def setUp(self): super(TestCaseExchangeReaction, self).setUp() import logging # 0-1-2-3-2-1-2-3-2-1-0 particle_list = [ (3, 0, espressopp.Real3D(3.0, 2.0, 2.0), 2, 1), (4, 1, espressopp.Real3D(3.2, 2.0, 2.0), 2, 0), (5, 2, espressopp.Real3D(3.4, 2.0, 2.0), 2, 2), (6, 3, espressopp.Real3D(3.6, 2.0, 2.0), 3, 3), (7, 2, espressopp.Real3D(3.8, 2.0, 2.0), 4, 2), (8, 1, espressopp.Real3D(4.0, 2.0, 2.0), 4, 0), (9, 2, espressopp.Real3D(4.2, 2.0, 2.0), 4, 2), (10, 3, espressopp.Real3D(4.4, 2.0, 2.0), 5, 3), (11, 2, espressopp.Real3D(4.6, 2.0, 2.0), 6, 2), (12, 1, espressopp.Real3D(4.8, 2.0, 2.0), 6, 0), (13, 0, espressopp.Real3D(5.0, 2.0, 2.0), 6, 2), (14, 4, espressopp.Real3D(4.2, 1.8, 2.0), 7, 4), ] self.system.storage.addParticles(particle_list, *self.part_prop) self.system.storage.decompose() # ('id', 'type', 'pos', 'res_id', 'state') self.fpl_static = espressopp.FixedPairList(self.system.storage) self.ftl_static = espressopp.FixedTripleList(self.system.storage) self.ftl123 = espressopp.FixedTripleList(self.system.storage) self.ftl232 = espressopp.FixedTripleList(self.system.storage) self.fpl_chem = espressopp.FixedPairList(self.system.storage) self.dynamic_exclude = espressopp.DynamicExcludeList(self.integrator) self.dynamic_exclude.observe_tuple(self.fpl_static) self.dynamic_exclude.observe_tuple(self.fpl_chem) self.dynamic_exclude.observe_triple(self.ftl_static) self.dynamic_exclude.observe_triple(self.ftl123) self.dynamic_exclude.observe_triple(self.ftl232) self.dynamic_exclude.observe_tuple(self.fpl_chem) self.fpl_static.addBonds([(3, 4), (4, 5), (7, 8), (8, 9), (11, 12), (12, 13)]) self.topology_manager.observe_tuple(self.fpl_static) self.ftl_static.addTriples([(3, 4, 5), (7, 8, 9), (11, 12, 13)]) self.ftl123.addTriples([(4, 5, 6), (6, 7, 8), (8, 9, 10), (10, 11, 12)]) self.topology_manager.register_triplet(self.ftl123, 1, 2, 3) self.ftl232.addTriples([(5, 6, 7), (9, 10, 11)]) self.topology_manager.register_triplet(self.ftl232, 2, 3, 2) self.fpl_chem.addBonds([(5, 6), (6, 7), (9, 10), (10, 11)]) self.topology_manager.register_tuple(self.fpl_chem, 2, 3) self.topology_manager.initialize_topology() self.dynamic_exclude.update()
def setUp(self): super(TestCaseRemoveNeighbourBond, self).setUp() particle_list = [ (3, 3, espressopp.Real3D(3.0, 2.0, 2.0), 2, 1), (4, 4, espressopp.Real3D(3.5, 2.0, 2.0), 2, 1), (5, 4, espressopp.Real3D(3.5, 2.0, 2.0), 2, 1), (6, 3, espressopp.Real3D(3.5, 2.0, 2.0), 2, 1), (7, 4, espressopp.Real3D(3.5, 2.0, 2.0), 2, 1), ] self.system.storage.addParticles(particle_list, *self.part_prop) self.system.storage.decompose() self.fpl23 = espressopp.FixedPairList(self.system.storage) self.fpl24 = espressopp.FixedPairList(self.system.storage) self.fpl34 = espressopp.FixedPairList(self.system.storage) self.ftl234 = espressopp.FixedTripleList(self.system.storage) self.ftl234.addTriples([(2, 3, 4)]) self.fpl23.addBonds([(2, 3)]) self.fpl24.addBonds([(2, 7)]) self.fpl34.addBonds([(3, 4), (3, 5), (4, 6)]) self.topology_manager.register_tuple(self.fpl24, 2, 4) self.topology_manager.register_tuple(self.fpl34, 3, 4) self.topology_manager.register_tuple(self.fpl23, 2, 3) self.topology_manager.register_triplet(self.ftl234, 2, 3, 4) self.topology_manager.initialize_topology()
def test_angular_harmonic(self): ftl_lambda = espressopp.FixedTripleListLambda(self.system.storage) ftl_lambda.addTriples([(1, 2, 3)]) ftl = espressopp.FixedTripleList(self.system.storage) ftl.addTriples([(1, 2, 3)]) harmonic = espressopp.interaction.AngularHarmonic() interactionLambda = espressopp.interaction.FixedTripleListLambdaAngularHarmonic( self.system, ftl_lambda, harmonic) interaction = espressopp.interaction.FixedTripleListAngularHarmonic( self.system, ftl, harmonic) self.assertAlmostEqual(interaction.computeEnergy(), interactionLambda.computeEnergy())
def setUp(self): # Initialize the espressopp system box = (10, 10, 10) system = espressopp.System() self.system = system system.kb = 1.0 system.rng = espressopp.esutil.RNG() system.bc = espressopp.bc.OrthorhombicBC(system.rng, box) system.skin = 0.3 nodeGrid = espressopp.tools.decomp.nodeGrid(MPI.COMM_WORLD.size) cellGrid = espressopp.tools.decomp.cellGrid(box, nodeGrid, 2.5, system.skin) system.storage = espressopp.storage.DomainDecomposition( system, nodeGrid, cellGrid) # Adding ten nodes self.N = 8 particle_list = [] for pid in range(1, self.N + 1): pos = system.bc.getRandomPos() particle_list.append((pid, pos, 1 if pid < 5 else 2)) system.storage.addParticles(particle_list, 'id', 'pos', 'res_id') system.storage.decompose() self.integrator = espressopp.integrator.VelocityVerlet(system) self.integrator.dt = 0.0025 self.fpl1 = espressopp.FixedPairList(system.storage) self.fpl1.addBonds([(1, 2), (2, 3), (2, 4)]) self.fpl2 = espressopp.FixedPairList(system.storage) self.fpl2.addBonds([(5, 6), (6, 7), (6, 8)]) self.fpl3 = espressopp.FixedPairList(system.storage) self.ftl = espressopp.FixedTripleList(system.storage) self.ftl.addTriples([(1, 2, 3), (1, 2, 4), (5, 6, 7), (5, 6, 8)]) self.fql = espressopp.FixedQuadrupleList(system.storage) self.fql2 = espressopp.FixedQuadrupleList(system.storage) topology_manager = espressopp.integrator.TopologyManager(system) self.topology_manager = topology_manager topology_manager.observe_tuple(self.fpl1) topology_manager.observe_tuple(self.fpl2) topology_manager.observe_tuple(self.fpl3) topology_manager.register_triplet(self.ftl, 0) topology_manager.register_quadruplet(self.fql, 0) topology_manager.register_quadruplet(self.fql2, 0, 0, 0, 1) topology_manager.register_tuple(self.fpl3, 0, 0) topology_manager.initialize_topology() self.integrator.addExtension(topology_manager)
def setUp(self): super(TestFixedTripleListTypesTabulated, self).setUp() # Test the energy computation. Distance between particles 1.0 particle_list = [(1, 1, espressopp.Real3D(1.0, 1.0, 2.0)), (2, 2, espressopp.Real3D(0.0, 0.0, 2.0)), (3, 1, espressopp.Real3D(1.0, 0.0, 2.0)), (4, 3, espressopp.Real3D(1.0, 0.0, 2.0)), (5, 3, espressopp.Real3D(1.0, 1.0, 2.0))] self.system.storage.addParticles(particle_list, *self.part_prop) self.system.storage.decompose() self.ftl1 = espressopp.FixedTripleList(self.system.storage) self.ftl1.addTriples([(1, 2, 3), (4, 2, 5)]) self.interaction = espressopp.interaction.FixedTripleListTypesTabulatedAngular( self.system, self.ftl1)
def test_angular_harmonic_lambda(self): ftl_lambda = espressopp.FixedTripleListLambda(self.system.storage) ftl_lambda.addTriples([(1, 2, 3)]) ftl = espressopp.FixedTripleList(self.system.storage) ftl.addTriples([(1, 2, 3)]) harmonic = espressopp.interaction.AngularHarmonic() interactionLambda = espressopp.interaction.FixedTripleListLambdaAngularHarmonic( self.system, ftl_lambda, harmonic) interaction = espressopp.interaction.FixedTripleListAngularHarmonic( self.system, ftl, harmonic) self.fixed_dynamic_resolution.register_triple_list(ftl_lambda, -0.5) self.integrator.run(1) self.assertAlmostEqual(0.5 * interaction.computeEnergy(), interactionLambda.computeEnergy())
def test_angular_harmonic_types_lambda(self): ftl_lambda = espressopp.FixedTripleListLambda(self.system.storage) ftl_lambda.addTriples([(1, 2, 3)]) ftl = espressopp.FixedTripleList(self.system.storage) ftl.addTriples([(1, 2, 3)]) harmonic = espressopp.interaction.AngularHarmonic() interactionLambda = espressopp.interaction.FixedTripleListTypesLambdaAngularHarmonic( self.system, ftl_lambda) interactionLambda.setPotential(0, 0, 1, harmonic) interaction = espressopp.interaction.FixedTripleListTypesAngularHarmonic( self.system, ftl) interaction.setPotential(0, 0, 1, harmonic) ftl_lambda.setAllLambda(0.5) self.assertAlmostEqual(0.5 * interaction.computeEnergy(), interactionLambda.computeEnergy())
def setAngleInteractions(system, input_conf, ftpl): ret_list = {} angletypeparams = input_conf.angletypeparams angles = input_conf.angletypes for (aid, cross_angles), anglelist in angles.iteritems(): if ftpl: ftl = espressopp.FixedTripleListAdress(system.storage, ftpl) else: ftl = espressopp.FixedTripleList(system.storage) ftl.addTriples(anglelist) angleinteraction = angletypeparams[aid].createEspressoInteraction(system, ftl) if angleinteraction: system.addInteraction(angleinteraction, 'angle_{}{}'.format( aid, '_cross' if cross_angles else '')) ret_list.update({(aid, cross_angles): angleinteraction}) return ret_list
def setUp(self): self.h5md_file = 'topo_output.h5' remove_file(self.h5md_file) self.system, self.integrator = espressopp.standard_system.Default( (10., 10., 10.), dt=0.1) self.particles = [(1, espressopp.Real3D(1, 2, 3), 1), (2, espressopp.Real3D(2, 3, 4), 2), (3, espressopp.Real3D(3, 4, 5), 3), (4, espressopp.Real3D(4, 5, 6), 4)] self.system.storage.addParticles(self.particles, 'id', 'pos', 'type') self.fpl = espressopp.FixedPairList(self.system.storage) self.fpl.addBonds([(1, 2), (2, 3)]) self.ftl = espressopp.FixedTripleList(self.system.storage) self.ftl.addTriples([(1, 2, 3)]) self.fql = espressopp.FixedQuadrupleList(self.system.storage) self.fql.addQuadruples([(1, 2, 3, 4)]) self.dump_h5md = espressopp.io.DumpH5MD(self.system, self.integrator, self.h5md_file, store_species=True, store_velocity=True, store_state=True) self.dump_topology = espressopp.io.DumpTopology( self.system, self.integrator, self.dump_h5md) self.dump_topology.observe_tuple(self.fpl, 'bonds_0') self.dump_topology.observe_triple(self.ftl, 'angles_0') self.dump_topology.observe_quadruple(self.fql, 'dihs_0') self.dump_topology.dump() ext_dump = espressopp.integrator.ExtAnalyze(self.dump_topology, 1) self.integrator.addExtension(ext_dump)
sigma=1.0, cutoff=rc, shift=0) interLJ = espressopp.interaction.VerletListLennardJones(vl) interLJ.setPotential(type1=0, type2=0, potential=potLJ) system.addInteraction(interLJ) # FENE bonds fpl = espressopp.FixedPairList(system.storage) fpl.addBonds(bonds) potFENE = espressopp.interaction.FENE(K=30.0, r0=0.0, rMax=1.5) interFENE = espressopp.interaction.FixedPairListFENE(system, fpl, potFENE) system.addInteraction(interFENE) # Cosine with FixedTriple list ftl = espressopp.FixedTripleList(system.storage) ftl.addTriples(angles) potCosine = espressopp.interaction.Cosine(K=1.5, theta0=3.1415926) interCosine = espressopp.interaction.FixedTripleListCosine( system, ftl, potCosine) system.addInteraction(interCosine) # print simulation parameters print '' print 'number of particles = ', num_particles print 'density = ', density print 'rc = ', rc print 'dt = ', integrator.dt print 'skin = ', system.skin print 'temperature = ', temperature print 'nsteps = ', nsteps
def setUp(self): # set up system system = espressopp.System() system.rng = espressopp.esutil.RNG() system.bc = espressopp.bc.OrthorhombicBC(system.rng, size) system.skin = skin comm = MPI.COMM_WORLD nodeGrid = Int3D(1, 1, comm.size) cellGrid = Int3D(calcNumberCells(size[0], nodeGrid[0], cutoff), calcNumberCells(size[1], nodeGrid[1], cutoff), calcNumberCells(size[2], nodeGrid[2], cutoff)) system.storage = espressopp.storage.DomainDecomposition( system, nodeGrid, cellGrid) pid = 0 system.storage.addParticle(0, Real3D(0.15, 0.1, 0)) system.storage.addParticle(1, Real3D(0.4, 0.1, 0)) system.storage.decompose() # integrator integrator = espressopp.integrator.VelocityVerlet(system) integrator.dt = 0.001 # now build Verlet List # ATTENTION: you must not add the skin explicitly here logging.getLogger("Interpolation").setLevel(logging.INFO) vl = espressopp.VerletList(system, cutoff=cutoff) scaling_cv = 1.5 alpha = 0.1 # ATTENTION: auto shift was enabled # bonds writeTabFile(tabBonds[0], k=100000, x0=0.26, N=500, low=0.01, high=0.6) writeTabFile(tabBonds[1], k=50000, x0=0.24, N=500, low=0.01, high=0.6) fpl = espressopp.FixedPairList(system.storage) fpl.addBonds([(0, 1)]) potBond = espressopp.interaction.TabulatedSubEns() potBond.addInteraction( 1, tabBonds[0], espressopp.RealND([0.262, 0., 0., scaling_cv * 0.424, 0., 0.])) potBond.addInteraction(1, tabBonds[1], espressopp.RealND([0., 0., 0., 0., 0., 0.])) potBond.alpha_set(alpha) cv_bl = espressopp.FixedPairList(system.storage) cv_bl.addBonds([]) potBond.colVarBondList = cv_bl cv_al = espressopp.FixedTripleList(system.storage) cv_al.addTriples([]) potBond.colVarAngleList = cv_al # Renormalize the CVs potBond.colVarSd_set(0, 0.0119) # Target probabilities potBond.targetProb_set(0, tgt_probs[0]) potBond.targetProb_set(1, tgt_probs[1]) interBond = espressopp.interaction.FixedPairListTabulatedSubEns( system, fpl, potBond) system.addInteraction(interBond) temp = espressopp.analysis.Temperature(system) temperature = temp.compute() Ek = 0.5 * temperature * (2 * numParticles) Ep = interBond.computeEnergy() # langevin thermostat langevin = espressopp.integrator.LangevinThermostat(system) integrator.addExtension(langevin) langevin.gamma = 1.0 langevin.temperature = 2.479 # in kJ/mol # sock = espressopp.tools.vmd.connect(system) configurations = espressopp.analysis.Configurations(system) self.configuration = configurations self.system = system self.temp = temp self.integrator = integrator self.interBond = interBond self.potBond = potBond
def applyBoreschRestraints(system, restraintAtoms, restraintK, restraintR0): restraintinteraction = {} restraintBond = espressopp.FixedPairList(system.storage) restraintBond.addBonds([(restraintAtoms['a'], restraintAtoms['A'])]) potint = espressopp.interaction.FixedPairListHarmonic( system, restraintBond, potential=espressopp.interaction.Harmonic(K=0.5 * restraintK['aA'], r0=restraintR0['aA'], cutoff=5.0, shift=0.0)) system.addInteraction(potint) restraintinteraction.update({0: potint}) restraintAngle = espressopp.FixedTripleList(system.storage) restraintAngle.addTriples([(restraintAtoms['a'], restraintAtoms['A'], restraintAtoms['B'])]) potint = espressopp.interaction.FixedTripleListAngularHarmonic( system, restraintAngle, potential=espressopp.interaction.AngularHarmonic( K=0.5 * restraintK['aAB'], theta0=restraintR0['aAB'] * math.pi / 180.0)) system.addInteraction(potint) restraintinteraction.update({1: potint}) restraintAngle = espressopp.FixedTripleList(system.storage) restraintAngle.addTriples([(restraintAtoms['b'], restraintAtoms['a'], restraintAtoms['A'])]) potint = espressopp.interaction.FixedTripleListAngularHarmonic( system, restraintAngle, potential=espressopp.interaction.AngularHarmonic( K=0.5 * restraintK['baA'], theta0=restraintR0['baA'] * math.pi / 180.0)) system.addInteraction(potint) restraintinteraction.update({2: potint}) restraintDih = espressopp.FixedQuadrupleList(system.storage) restraintDih.addQuadruples([(restraintAtoms['c'], restraintAtoms['b'], restraintAtoms['a'], restraintAtoms['A'])]) potint = espressopp.interaction.FixedQuadrupleListDihedralHarmonic( system, restraintDih, potential=espressopp.interaction.DihedralHarmonic( K=restraintK['cbaA'], phi0=restraintR0['cbaA'] * math.pi / 180.0)) system.addInteraction(potint) restraintinteraction.update({3: potint}) restraintDih = espressopp.FixedQuadrupleList(system.storage) restraintDih.addQuadruples([(restraintAtoms['b'], restraintAtoms['a'], restraintAtoms['A'], restraintAtoms['B'])]) potint = espressopp.interaction.FixedQuadrupleListDihedralHarmonic( system, restraintDih, potential=espressopp.interaction.DihedralHarmonic( K=restraintK['baAB'], phi0=restraintR0['baAB'] * math.pi / 180.0)) system.addInteraction(potint) restraintinteraction.update({4: potint}) restraintDih = espressopp.FixedQuadrupleList(system.storage) restraintDih.addQuadruples([(restraintAtoms['a'], restraintAtoms['A'], restraintAtoms['B'], restraintAtoms['C'])]) potint = espressopp.interaction.FixedQuadrupleListDihedralHarmonic( system, restraintDih, potential=espressopp.interaction.DihedralHarmonic( K=restraintK['aABC'], phi0=restraintR0['aABC'] * math.pi / 180.0)) system.addInteraction(potint) restraintinteraction.update({5: potint}) return restraintinteraction
(float(parameters[7 - i_diff]) + 2.*L)%L, (float(parameters[8 - i_diff]) + 2.*L)%L) print i*monomers_per_chain + j, " ", res_positions radius = float(parameters[10 - i_diff]) part = [res_positions, radius] cg_chain.append(part) j +=1 # Init fine-grained polymer configuration N_blob = N_blob/2 monomers_per_chain *= 2 props = ['id', 'type', 'mass', 'pos', 'v', 'radius', 'vradius'] bondlist = espressopp.FixedPairList(system.storage) anglelist = espressopp.FixedTripleList(system.storage) tuplelist = espressopp.FixedLocalTupleList(system.storage) pid = 1 type = 0 mass = 1.0*N_blob integrator.dt = timestep*(mass*B_cg**2/temperature)**0.5 #0.005*sqrt(Nb*m*l^2/kbT)=unit_time/200 #integrator.dt = timestep*(mass/temperature)**0.5 #0.005*sqrt(Nb*m*l^2/kbT)=unit_time/200/B_cg chain = [] for i in range(num_chains): startpos = system.bc.getRandomPos() positions, bonds, angles = espressopp.tools.topology.polymerRW(pid, startpos, monomers_per_chain, bondlen, True) for j in range(monomers_per_chain/2): id = i*(monomers_per_chain/2) + j vector = []
def init_polymer_melt_simulation(use_replicate_parallel): start_time = time.process_time() bonds, angles, x, y, z, Lx, Ly, Lz = espressopp.tools.lammps.read('polymer_melt.lammps') if use_replicate_parallel: # rp stores bonds, angles, and positions rp = espressopp.tools.ReplicateParallel() num_particles, Lx, Ly, Lz = rp.replicate(bonds, angles, x, y, z, Lx, Ly, Lz, *repl) else: bonds, angles, x, y, z, Lx, Ly, Lz = espressopp.tools.replicate(bonds, angles, x, y, z, Lx, Ly, Lz, *repl) num_particles = len(x) density = num_particles / (Lx * Ly * Lz) box = (Lx, Ly, Lz) system, integrator = espressopp.standard_system.Default(box=box, rc=rc, skin=skin, dt=timestep, temperature=temperature) if use_replicate_parallel: props = ['type', 'mass'] num_particles_seed = len(x) seed_particles = [] for i in range(num_particles_seed): part = [0, 1.0] seed_particles.append(part) # rp workers add replicated particles in parallel rp.addParticles(system.storage, 1, seed_particles, *props) else: # add particles to the system and then decompose # do this in chunks of 1000 particles to speed it up props = ['id', 'type', 'mass', 'pos'] new_particles = [] for i in range(num_particles): part = [i + 1, 0, 1.0, espressopp.Real3D(x[i], y[i], z[i])] new_particles.append(part) if i % 1000 == 0: system.storage.addParticles(new_particles, *props) system.storage.decompose() new_particles = [] system.storage.addParticles(new_particles, *props) system.storage.decompose() # Lennard-Jones with Verlet list vl = espressopp.VerletList(system, cutoff = rc) potLJ = espressopp.interaction.LennardJones(epsilon=1.0, sigma=1.0, cutoff=rc, shift=0) interLJ = espressopp.interaction.VerletListLennardJones(vl) interLJ.setPotential(type1=0, type2=0, potential=potLJ) system.addInteraction(interLJ) # FENE bonds fpl = espressopp.FixedPairList(system.storage) if use_replicate_parallel: # rp workers add replicated bonds in parallel rp.addBonds(fpl) else: fpl.addBonds(bonds) potFENE = espressopp.interaction.FENE(K=30.0, r0=0.0, rMax=1.5) interFENE = espressopp.interaction.FixedPairListFENE(system, fpl, potFENE) system.addInteraction(interFENE) # Cosine with FixedTriple list ftl = espressopp.FixedTripleList(system.storage) if use_replicate_parallel: # rp workers add replicated triples in parallel rp.addTriples(ftl) else: ftl.addTriples(angles) potCosine = espressopp.interaction.Cosine(K=1.5, theta0=3.1415926) interCosine = espressopp.interaction.FixedTripleListCosine(system, ftl, potCosine) system.addInteraction(interCosine) end_time = time.process_time() # get positions, bonds and angles configurations = espressopp.analysis.Configurations(system, pos=True, vel=False, force=False) configurations.gather() pos = [configurations[0][i] for i in range(num_particles)] bonds = np.array(fpl.getBonds()) angles = np.array(ftl.getTriples()) return end_time - start_time, pos, bonds, angles
def test_PIAdResS(self): print 'param =', self.param constkinmass = self.param['constkinmass'] PILE = self.param['PILE'] realkinmass = self.param['realkinmass'] centroidthermostat = self.param['centroidthermostat'] KTI = self.param['KTI'] speedupInterAtom = self.param['speedupInterAtom'] speedupFreezeRings = self.param['speedupFreezeRings'] spherical_adress = self.param['spherical_adress'] nb_forcefield_setup = self.param['nb_forcefield_setup'] energy_before = self.param['energy_before'] energy_after = self.param['energy_after'] steps = 10 timestep_short = 0.001 / 16.0 multiplier_short_to_medium = 4 multiplier_medium_to_long = 4 interaction_cutoff = 0.84 potential_cutoff = 0.78 skin = 0.1 gamma = 0.0 temp = 2.50266751 if KTI: ex_size = 100.0 else: ex_size = 1.0 hy_size = 1.5 nTrotter = 4 clmassmultiplier = 100.0 PILElambda = 0.0 CMDparameter = 1.0 tabFEC_H = "FEC_H.dat" tabFEC_O = "FEC_O.dat" tabTHDF_H = "ThdForce_H.dat" tabTHDF_O = "ThdForce_O.dat" tabAngle = "tableESP_angle.dat" tabBondHH = "tableESP_bondHH.dat" tabBondOH = "tableESP_bondOH.dat" tabHW_HW = "tableESP_HW_HW.dat" tabHW_OW = "tableESP_HW_OW.dat" tabOW_OW = "tableESP_OW_OW.dat" pid, types, x, y, z, vx, vy, vz, Lx, Ly, Lz = espressopp.tools.readxyz( "input_test.xyz") masses = [] for item in types: if item == 1: masses.append(15.9994) else: masses.append(1.008) num_Trotter_beads = len(x) num_atoms = len(x) / nTrotter size = (Lx, Ly, Lz) system = espressopp.System() system.bc = espressopp.bc.OrthorhombicBC(system.rng, size) system.skin = skin comm = MPI.COMM_WORLD nodeGrid = decomp.nodeGrid(comm.size) cellGrid = decomp.cellGrid(size, nodeGrid, interaction_cutoff, skin) system.rng = espressopp.esutil.RNG() system.storage = espressopp.storage.DomainDecompositionAdress( system, nodeGrid, cellGrid) props = ['id', 'pos', 'v', 'f', 'pib', 'type', 'mass', 'adrat'] allParticlesAT = [] allParticles = [] tuples = [] for pid_trotter in range(num_Trotter_beads): allParticlesAT.append([ pid_trotter + 1, Real3D(x[pid_trotter], y[pid_trotter], z[pid_trotter]), Real3D(vx[pid_trotter], vy[pid_trotter], vz[pid_trotter]), Real3D(0, 0, 0), pid_trotter % nTrotter + 1, types[pid_trotter], masses[pid_trotter], 1 ]) for pid_atom in range(num_atoms): tmptuple = [pid_atom + num_Trotter_beads + 1] for pid_trotter in range(nTrotter): pid = pid_atom * nTrotter + pid_trotter tmptuple.append((allParticlesAT[pid])[0]) firstParticleId = tmptuple[1] cmp = allParticlesAT[firstParticleId - 1][1] cmv = allParticlesAT[firstParticleId - 1][2] allParticles.append([ pid_atom + num_Trotter_beads + 1, Real3D(cmp[0], cmp[1], cmp[2]), Real3D(cmv[0], cmv[1], cmv[2]), Real3D(0, 0, 0), 0, types[pid_atom * nTrotter], masses[pid_atom * nTrotter], 0 ]) for pid_trotter in range(nTrotter): pid = pid_atom * nTrotter + pid_trotter allParticles.append([(allParticlesAT[pid])[0], (allParticlesAT[pid])[1], (allParticlesAT[pid])[2], (allParticlesAT[pid])[3], (allParticlesAT[pid])[4], (allParticlesAT[pid])[5], (allParticlesAT[pid])[6], (allParticlesAT[pid])[7]]) tuples.append(tmptuple) system.storage.addParticles(allParticles, *props) ftpl = espressopp.FixedTupleListAdress(system.storage) ftpl.addTuples(tuples) system.storage.setFixedTuplesAdress(ftpl) system.storage.decompose() bondsOH = [] bondsHH = [] for part in range(num_atoms / 3): bondsOH.append((num_Trotter_beads + 1 + 3 * part, num_Trotter_beads + 1 + 3 * part + 1)) bondsOH.append((num_Trotter_beads + 1 + 3 * part, num_Trotter_beads + 1 + 3 * part + 2)) bondsHH.append((num_Trotter_beads + 1 + 3 * part + 1, num_Trotter_beads + 1 + 3 * part + 2)) fplOH = espressopp.FixedPairList(system.storage) fplHH = espressopp.FixedPairList(system.storage) fplOH.addBonds(bondsOH) fplHH.addBonds(bondsHH) angles = [] for part in range(num_atoms / 3): angles.append((num_Trotter_beads + 1 + 3 * part + 1, num_Trotter_beads + 1 + 3 * part, num_Trotter_beads + 1 + 3 * part + 2)) ftl = espressopp.FixedTripleList(system.storage) ftl.addTriples(angles) vl = espressopp.VerletListAdress(system, cutoff=interaction_cutoff, adrcut=interaction_cutoff, dEx=ex_size, dHy=hy_size, adrCenter=[Lx / 2, Ly / 2, Lz / 2], exclusionlist=bondsOH + bondsHH, sphereAdr=spherical_adress) if nb_forcefield_setup == 1: interNB = espressopp.interaction.VerletListPIadressTabulatedLJ( vl, ftpl, nTrotter, speedupInterAtom) elif nb_forcefield_setup == 2: interNB = espressopp.interaction.VerletListPIadressNoDriftTabulated( vl, ftpl, nTrotter, speedupInterAtom) elif nb_forcefield_setup == 3: interNB = espressopp.interaction.VerletListPIadressTabulated( vl, ftpl, nTrotter, speedupInterAtom) else: raise ValueError( "Wrong nb_forcefield_setup integer (only 1,2,3 accepted.") potOOqm = espressopp.interaction.Tabulated(itype=3, filename=tabOW_OW, cutoff=potential_cutoff) potHOqm = espressopp.interaction.Tabulated(itype=3, filename=tabHW_OW, cutoff=potential_cutoff) potHHqm = espressopp.interaction.Tabulated(itype=3, filename=tabHW_HW, cutoff=potential_cutoff) if nb_forcefield_setup == 1: interNB.setPotentialQM(type1=1, type2=1, potential=potOOqm) interNB.setPotentialQM(type1=1, type2=0, potential=potHOqm) interNB.setPotentialQM(type1=0, type2=0, potential=potHHqm) potOOcl = espressopp.interaction.LennardJones( epsilon=temp, sigma=0.25, shift='auto', cutoff=1.122462048309373 * 0.25) interNB.setPotentialCL(type1=1, type2=1, potential=potOOcl) elif nb_forcefield_setup == 2: interNB.setPotential(type1=1, type2=1, potential=potOOqm) interNB.setPotential(type1=1, type2=0, potential=potHOqm) interNB.setPotential(type1=0, type2=0, potential=potHHqm) elif nb_forcefield_setup == 3: interNB.setPotentialQM(type1=1, type2=1, potential=potOOqm) interNB.setPotentialQM(type1=1, type2=0, potential=potHOqm) interNB.setPotentialQM(type1=0, type2=0, potential=potHHqm) interNB.setPotentialCL(type1=1, type2=1, potential=potOOqm) interNB.setPotentialCL(type1=1, type2=0, potential=potHOqm) interNB.setPotentialCL(type1=0, type2=0, potential=potHHqm) system.addInteraction(interNB) potBondHH = espressopp.interaction.Tabulated(itype=3, filename=tabBondHH) potBondOH = espressopp.interaction.Tabulated(itype=3, filename=tabBondOH) interBondedHH = espressopp.interaction.FixedPairListPIadressTabulated( system, fplHH, ftpl, potBondHH, nTrotter, speedupInterAtom) interBondedOH = espressopp.interaction.FixedPairListPIadressTabulated( system, fplOH, ftpl, potBondOH, nTrotter, speedupInterAtom) system.addInteraction(interBondedHH) system.addInteraction(interBondedOH) potAngle = espressopp.interaction.TabulatedAngular(itype=3, filename=tabAngle) interAngle = espressopp.interaction.FixedTripleListPIadressTabulatedAngular( system, ftl, ftpl, potAngle, nTrotter, speedupInterAtom) system.addInteraction(interAngle) integrator = espressopp.integrator.PIAdressIntegrator( system=system, verletlist=vl, timestep=timestep_short, sSteps=multiplier_short_to_medium, mSteps=multiplier_medium_to_long, nTrotter=nTrotter, realKinMass=realkinmass, constKinMass=constkinmass, temperature=temp, gamma=gamma, centroidThermostat=centroidthermostat, CMDparameter=CMDparameter, PILE=PILE, PILElambda=PILElambda, CLmassmultiplier=clmassmultiplier, speedup=speedupFreezeRings, KTI=KTI) if not KTI: fec = espressopp.integrator.FreeEnergyCompensation( system, center=[Lx / 2, Ly / 2, Lz / 2], ntrotter=nTrotter) fec.addForce(itype=3, filename=tabFEC_O, type=1) fec.addForce(itype=3, filename=tabFEC_H, type=0) integrator.addExtension(fec) thdf = espressopp.integrator.TDforce(system, vl) thdf.addForce(itype=3, filename=tabTHDF_O, type=1) thdf.addForce(itype=3, filename=tabTHDF_H, type=0) integrator.addExtension(thdf) if KTI: for i in range(1, num_Trotter_beads + num_atoms + 1): system.storage.modifyParticle(i, 'lambda_adrd', 0.0) system.storage.modifyParticle(i, 'lambda_adr', 0.0) system.storage.modifyParticle( i, 'varmass', clmassmultiplier * system.storage.getParticle(i).mass) system.storage.decompose() espressopp.tools.AdressDecomp(system, integrator) Eb = interBondedOH.computeEnergy() + interBondedHH.computeEnergy() EAng = interAngle.computeEnergy() ELj = interNB.computeEnergy() Ek = integrator.computeKineticEnergy() EPI = integrator.computeRingEnergy() if KTI == False: Ecorr = fec.computeCompEnergy() + thdf.computeTDEnergy() else: Ecorr = 0.0 energy_before_thistest = Ek + Eb + EAng + ELj + EPI + Ecorr integrator.run(steps) Eb = interBondedOH.computeEnergy() + interBondedHH.computeEnergy() EAng = interAngle.computeEnergy() ELj = interNB.computeEnergy() Ek = integrator.computeKineticEnergy() EPI = integrator.computeRingEnergy() if KTI == False: Ecorr = fec.computeCompEnergy() + thdf.computeTDEnergy() else: Ecorr = 0.0 energy_after_thistest = Ek + Eb + EAng + ELj + EPI + Ecorr self.assertAlmostEqual(energy_before_thistest, energy_before, places=5) self.assertAlmostEqual(energy_after_thistest, energy_after, places=5)
def test_set_fixedtriplelist(self): ftl = espressopp.FixedTripleList(self.system.storage) ftl.addTriples([(1, 1, 1)]) self.interaction.setFixedTripleList(ftl) ret_ftl = self.interaction.getFixedTripleList() self.assertEqual(ret_ftl.getTriples(), [[(1, 1, 1)]])