Example #1
0
    void 
    destroy(const IdType classId,
	    const IdType objectId) {
#ifndef PMI_OPTIMIZE
      // check whether the class has an associated constructorCaller
      if (classId >= destructorCallers.size())
	PMI_REPORT_INTL_ERROR(printWorkerId()					\
		       << "does not have a destructorCaller for class id " \
		       << classId << ".");
      // check if the object is defined
      if (objectId >= objects.size() || objects[objectId] == NULL)
	PMI_REPORT_INTL_ERROR(printWorkerId()					\
		       << "does not have an initialized object at object id " \
		       << objectId << " (destroy).");
      // TODO: check if object is of the right class
      PMI_REPORT_OK;
#endif
      // delete object
      LOG4ESPP_INFO(logger, printWorkerId()				\
		    << "destroys object id " << objectId		\
		    << " of class id " << classId << ".");
      
      void* voidPtr = objects[objectId];
      DestructorCallerType dc = destructorCallers[classId];
      (*dc)(voidPtr);
      objects[objectId] = NULL;
    }
    //////////////////////////////////////////////////
    // INLINE IMPLEMENTATION
    //////////////////////////////////////////////////
    template < typename _DihedralPotential > inline void
    FixedQuadrupleListInteractionTemplate < _DihedralPotential >::
    addForces() {

      LOG4ESPP_INFO(theLogger, "add forces computed by FixedQuadrupleList");

      const bc::BC& bc = *getSystemRef().bc;  // boundary conditions

      for (FixedQuadrupleList::QuadrupleList::Iterator it(*fixedquadrupleList); it.isValid(); ++it) {
        Particle &p1 = *it->first;
        Particle &p2 = *it->second;
        Particle &p3 = *it->third;
        Particle &p4 = *it->fourth;

        Real3D dist21, dist32, dist43; // 

        bc.getMinimumImageVectorBox(dist21, p2.position(), p1.position());
        bc.getMinimumImageVectorBox(dist32, p3.position(), p2.position());
        bc.getMinimumImageVectorBox(dist43, p4.position(), p3.position());

	    Real3D force1, force2, force3, force4;  // result forces

	    potential->_computeForce(force1, force2, force3, force4,
                                dist21, dist32, dist43);
        p1.force() += force1;
        p2.force() += force2; //p2.force() -= force2;
        p3.force() += force3;
        p4.force() += force4;
      }
    }
Example #3
0
    void create(const IdType classId, 
		const IdType objectId) {
#ifndef PMI_OPTIMIZE
      // check whether the class has an associated constructorCaller
      if (classId >= constructorCallers.size())
	PMI_REPORT_INTL_ERROR(printWorkerId()					\
		       << "does not have a constructorCaller for class id " \
		       << classId << ".");
      // check whether the object is already defined
      if (objectId < objects.size() && objects[objectId] != NULL) {
	PMI_REPORT_INTL_ERROR(printWorkerId()				\
		       << "has object id "			\
		       << objectId << " already defined.");
      } else if (objectId >= objects.size()+1) {
	PMI_REPORT_INTL_ERROR(printWorkerId()					\
		       << ": object id " << objectId			\
		       << " overshoots (size " << objects.size()	\
		       << ").");
      }
      PMI_REPORT_OK;
#endif
      LOG4ESPP_INFO(logger, printWorkerId()				\
		    << "creates an instance of class id "		\
		    << classId << ", object id is " << objectId << ".");
      
      // create object
      ConstructorCallerType cc = constructorCallers[classId];
      if (objectId == objects.size())
	objects.push_back((*cc)());
      else
	objects[objectId] = (*cc)();
    }
Example #4
0
    void invoke(const IdType classId, 
		const IdType methodId, 
		const IdType objectId) {
#ifndef PMI_OPTIMIZE
      // check whether the method has an associated methodCaller
      if (methodId >= methodCallers.size())
	PMI_REPORT_INTL_ERROR(printWorkerId()					\
		       << "does not have a methodCaller for method id " \
		       << methodId << ".");
      if (objectId >= objects.size() || objects[objectId] == NULL)
	PMI_REPORT_INTL_ERROR(printWorkerId()					\
		       << "does not have an initialized object at object id " \
		       << objectId << " (invoke).");
      // TODO: check if object is of the right class
      PMI_REPORT_OK;
#endif
      // call method
      LOG4ESPP_INFO(logger, printWorkerId()				\
		    << "invokes method id " << methodId			\
		    << " of object id " << objectId			\
		    << " of class id " << classId << ".");
      
      void* voidPtr = objects[objectId];
      MethodCallerType mc = methodCallers[methodId];
      (*mc)(voidPtr);
    }
inline real
FixedTripleListTypesInteractionTemplate<_Potential>::
computeVirial() {
  LOG4ESPP_INFO(theLogger, "compute the virial for the FixedTriple List with types");

  real w = 0.0;
  const bc::BC &bc = *getSystemRef().bc;  // boundary conditions
  for (FixedTripleList::TripleList::Iterator it(*fixedtripleList); it.isValid(); ++it) {
    const Particle &p1 = *it->first;
    const Particle &p2 = *it->second;
    const Particle &p3 = *it->third;
    int type1 = p1.type();
    int type2 = p2.type();
    int type3 = p3.type();
    const Potential &potential = getPotential(type1, type2, type3);

    Real3D dist12, dist32;
    bc.getMinimumImageVectorBox(dist12, p1.position(), p2.position());
    bc.getMinimumImageVectorBox(dist32, p3.position(), p2.position());
    Real3D force12, force32;
    potential._computeForce(force12, force32, dist12, dist32);
    w += dist12 * force12 + dist32 * force32;
  }

  // reduce over all CPUs
  real wsum;
  boost::mpi::all_reduce(*mpiWorld, w, wsum, std::plus<real>());
  return wsum;
}
    inline void
    FixedQuadrupleListInteractionTemplate < _DihedralPotential >::
    computeVirialTensor(Tensor& w) {
      LOG4ESPP_INFO(theLogger, "compute the virial tensor of the quadruples");
    
      Tensor wlocal(0.0);
      const bc::BC& bc = *getSystemRef().bc;

      for (FixedQuadrupleList::QuadrupleList::Iterator it(*fixedquadrupleList); it.isValid(); ++it) {
        const Particle &p1 = *it->first;
        const Particle &p2 = *it->second;
        const Particle &p3 = *it->third;
        const Particle &p4 = *it->fourth;

        Real3D dist21, dist32, dist43; 

        bc.getMinimumImageVectorBox(dist21, p2.position(), p1.position());
        bc.getMinimumImageVectorBox(dist32, p3.position(), p2.position());
        bc.getMinimumImageVectorBox(dist43, p4.position(), p3.position());

        Real3D force1, force2, force3, force4;

        potential->_computeForce(force1, force2, force3, force4,
                                dist21, dist32, dist43);

        // TODO: formulas are not correct yet

        wlocal += Tensor(dist21, force1) - Tensor(dist32, force2);
      }
      // reduce over all CPUs
      Tensor wsum(0.0);
      boost::mpi::all_reduce(*mpiWorld, (double*)&wlocal, 6, (double*)&wsum, std::plus<double>());
      w += wsum;
    }
    //////////////////////////////////////////////////
    // INLINE IMPLEMENTATION
    //////////////////////////////////////////////////
    template < typename _Potential > inline void
    FixedPairListTypesInteractionTemplate < _Potential >::addForces() {
      LOG4ESPP_INFO(theLogger, "add forces computed by the FixedPair List");
      const bc::BC& bc = *getSystemRef().bc;

      for (FixedPairList::PairList::Iterator it(*fixedpairList); it.isValid(); ++it) {
        Particle &p1 = *it->first;
        Particle &p2 = *it->second;
        int type1 = p1.type();
        int type2 = p2.type();
        const Potential &potential = getPotential(type1, type2);
        // shared_ptr<Potential> potential = getPotential(type1, type2);

        Real3D force(0.0);
        //if(potential._computeForce(force, p1, p2)) {
        ////if(potential->_computeForce(force, p1, p2)) {
        //  p1.force() += force;
        //  p2.force() -= force;
        //  LOG4ESPP_TRACE(theLogger, "id1=" << p1.id() << " id2=" << p2.id() << " force=" << force);
        //}
        Real3D dist;
        bc.getMinimumImageVectorBox(dist, p1.position(), p2.position());
        if(potential._computeForce(force, p1, p2, dist)) {
          p1.force() += force;
          p2.force() -= force;
        }
      }
    }
    inline real
    FixedQuadrupleListInteractionTemplate < _DihedralPotential >::
    computeVirial() {
      LOG4ESPP_INFO(theLogger, "compute scalar virial of the quadruples");

      real w = 0.0;
      const bc::BC& bc = *getSystemRef().bc;  // boundary conditions
      for (FixedQuadrupleList::QuadrupleList::Iterator it(*fixedquadrupleList); it.isValid(); ++it) {
        const Particle &p1 = *it->first;
        const Particle &p2 = *it->second;
        const Particle &p3 = *it->third;
        const Particle &p4 = *it->fourth;

        Real3D dist21, dist32, dist43; 

        bc.getMinimumImageVectorBox(dist21, p2.position(), p1.position());
        bc.getMinimumImageVectorBox(dist32, p3.position(), p2.position());
        bc.getMinimumImageVectorBox(dist43, p4.position(), p3.position());

        Real3D force1, force2, force3, force4;

        potential->_computeForce(force1, force2, force3, force4,
                                dist21, dist32, dist43);

        // TODO: formulas are not correct yet?

        w += dist21 * force1 + dist32 * force2;
      }
      
      real wsum;
      boost::mpi::all_reduce(*mpiWorld, w, wsum, std::plus<real>());
      return w;
    }
 template < typename _AngularPotential > inline void
 FixedTripleAngleListInteractionTemplate < _AngularPotential >::
 computeVirialTensor(Tensor *w, int n) {
   LOG4ESPP_INFO(theLogger, "compute the virial tensor of the triples");
   
   std::cout << "Warning! At the moment IK computeVirialTensor for fixed triples does'n work"<<std::endl;
 }
inline void
FixedTripleListTypesInteractionTemplate<_Potential>::computeVirialTensor(Tensor &w) {
  LOG4ESPP_INFO(theLogger, "compute the virial tensor for the FixedTriple List");

  Tensor wlocal(0.0);
  const bc::BC& bc = *getSystemRef().bc;
  for (FixedTripleList::TripleList::Iterator it(*fixedtripleList); it.isValid(); ++it) {
    const Particle &p1 = *it->first;
    const Particle &p2 = *it->second;
    const Particle &p3 = *it->third;
    int type1 = p1.type();
    int type2 = p2.type();
    int type3 = p3.type();
    const Potential &potential = getPotential(type1, type2, type3);
    Real3D r12, r32;
    bc.getMinimumImageVectorBox(r12, p1.position(), p2.position());
    bc.getMinimumImageVectorBox(r32, p3.position(), p2.position());
    Real3D force12, force32;
    potential._computeForce(force12, force32, r12, r32);
    wlocal += Tensor(r12, force12) + Tensor(r32, force32);
  }

  // reduce over all CPUs
  Tensor wsum(0.0);
  boost::mpi::all_reduce(*mpiWorld, wlocal, wsum, std::plus<Tensor>());
  w += wsum;
}
    template < typename _AngularPotential > inline void
    FixedTripleAngleListInteractionTemplate < _AngularPotential >::
    computeVirialTensor(Tensor& w) {
      LOG4ESPP_INFO(theLogger, "compute the virial tensor of the triples");

      Tensor wlocal(0.0);
      const bc::BC& bc = *getSystemRef().bc;
      for (FixedTripleAngleList::TripleList::Iterator it(*fixedtripleList); it.isValid(); ++it){
        const Particle &p1 = *it->first;
        const Particle &p2 = *it->second;
        const Particle &p3 = *it->third;
        //const Potential &potential = getPotential(0, 0);
        Real3D r12, r32;
        bc.getMinimumImageVectorBox(r12, p1.position(), p2.position());
        bc.getMinimumImageVectorBox(r32, p3.position(), p2.position());
        Real3D force12, force32;

        real currentAngle = fixedtripleList->getAngle(p1.getId(), p2.getId(), p3.getId());
        
        potential->_computeForce(force12, force32, r12, r32, currentAngle);
        wlocal += Tensor(r12, force12) + Tensor(r32, force32);
      }
      
      // reduce over all CPUs
      Tensor wsum(0.0);
      boost::mpi::all_reduce(*mpiWorld, (double*)&wlocal,6, (double*)&wsum, std::plus<double>());
      w += wsum;
    }
inline real
FixedTripleListTypesInteractionTemplate<_Potential>::
computeEnergy() {
  LOG4ESPP_INFO(theLogger, "compute energy of the FixedTriple list pairs");

  real e = 0.0;
  const bc::BC &bc = *getSystemRef().bc;  // boundary conditions
  for (FixedTripleList::TripleList::Iterator it(*fixedtripleList); it.isValid(); ++it) {
    const Particle &p1 = *it->first;
    const Particle &p2 = *it->second;
    const Particle &p3 = *it->third;
    int type1 = p1.type();
    int type2 = p2.type();
    int type3 = p3.type();

    const Potential &potential = getPotential(type1, type2, type3);

    Real3D dist12 = bc.getMinimumImageVector(p1.position(), p2.position());
    Real3D dist32 = bc.getMinimumImageVector(p3.position(), p2.position());
    e += potential._computeEnergy(dist12, dist32);
    LOG4ESPP_TRACE(theLogger, "id1=" << p1.id() << " id2="
        << p2.id() << " id3=" << p3.id() << " potential energy=" << e);
  }

  // reduce over all CPUs
  real esum;
  boost::mpi::all_reduce(*mpiWorld, e, esum, std::plus<real>());
  return esum;
}
    template < typename _AngularPotential > inline real
    FixedTripleAngleListInteractionTemplate < _AngularPotential >::
    computeVirial() {
      LOG4ESPP_INFO(theLogger, "compute scalar virial of the triples");

      const bc::BC& bc = *getSystemRef().bc;
      real w = 0.0;
      for (FixedTripleAngleList::TripleList::Iterator it(*fixedtripleList); it.isValid(); ++it) {
        const Particle &p1 = *it->first;
        const Particle &p2 = *it->second;
        const Particle &p3 = *it->third;
        //const Potential &potential = getPotential(p1.type(), p2.type());
        const espresso::bc::BC& bc = *getSystemRef().bc;
        Real3D dist12, dist32;
        bc.getMinimumImageVectorBox(dist12, p1.position(), p2.position());
        bc.getMinimumImageVectorBox(dist32, p3.position(), p2.position());
        Real3D force12, force32;

        real currentAngle = fixedtripleList->getAngle(p1.getId(), p2.getId(), p3.getId());
        
        potential->_computeForce(force12, force32, dist12, dist32, currentAngle);
        w += dist12 * force12 + dist32 * force32;
      }
      real wsum;
      boost::mpi::all_reduce(*mpiWorld, w, wsum, std::plus<real>());
      return wsum;
    }
    template < typename _Potential > inline real
    FixedPairListTypesInteractionTemplate < _Potential >::
    computeVirial() {
      LOG4ESPP_INFO(theLogger, "compute the virial for the Fixed Pair List with types");
      std::cout << "Warning! computeVirial in FixedPairListTypesInteractionTemplate has not been tested." << std::endl;
      
      real w = 0.0;
      const bc::BC& bc = *getSystemRef().bc;  // boundary conditions
      for (FixedPairList::PairList::Iterator it(*fixedpairList);
           it.isValid(); ++it) {          
        Particle &p1 = *it->first;                                       
        Particle &p2 = *it->second;                                      
        int type1 = p1.type();                                           
        int type2 = p2.type();
        const Potential &potential = getPotential(type1, type2);
        // shared_ptr<Potential> potential = getPotential(type1, type2);

        Real3D force(0.0, 0.0, 0.0);
        Real3D r21;
        bc.getMinimumImageVectorBox(r21, p1.position(), p2.position());
        if(potential._computeForce(force, p1, p2, r21)) {
        // if(potential->_computeForce(force, p1, p2)) {
          //Real3D r21 = p1.position() - p2.position();
          w = w + r21 * force;
        }
      }

      // reduce over all CPUs
      real wsum;
      boost::mpi::all_reduce(*mpiWorld, w, wsum, std::plus<real>());
      return wsum; 
    }
    inline real
    FixedPairListTypesInteractionTemplate < _Potential >::
    computeEnergy() {
      LOG4ESPP_INFO(theLogger, "compute energy of the FixedPair list pairs");

      real e = 0.0;
      real es = 0.0;
      const bc::BC& bc = *getSystemRef().bc;  // boundary conditions
      for (FixedPairList::PairList::Iterator it(*fixedpairList);
           it.isValid(); ++it) {
        Particle &p1 = *it->first;
        Particle &p2 = *it->second;
        int type1 = p1.type();
        int type2 = p2.type();
        const Potential &potential = getPotential(type1, type2);
        // shared_ptr<Potential> potential = getPotential(type1, type2);
        Real3D r21;
        bc.getMinimumImageVectorBox(r21, p1.position(), p2.position());
        //e   = potential._computeEnergy(p1, p2);
        // e   = potential->_computeEnergy(p1, p2);
        e = potential._computeEnergy(p1,p2,r21);
        es += e;
        LOG4ESPP_TRACE(theLogger, "id1=" << p1.id() << " id2=" << p2.id() << " potential energy=" << e);
        //std::cout << "id1=" << p1.id() << " id2=" << p2.id() << " potential energy=" << e << std::endl;
      }

      // reduce over all CPUs
      real esum;
      boost::mpi::all_reduce(*mpiWorld, es, esum, std::plus<real>());
      return esum;
    }
    inline real
    FixedQuadrupleListInteractionTemplate < _DihedralPotential >::
    computeEnergy() {
      LOG4ESPP_INFO(theLogger, "compute energy of the quadruples");

      const bc::BC& bc = *getSystemRef().bc;  // boundary conditions
      real e = 0.0;
      for (FixedQuadrupleList::QuadrupleList::Iterator it(*fixedquadrupleList); it.isValid(); ++it) {
        const Particle &p1 = *it->first;
        const Particle &p2 = *it->second;
        const Particle &p3 = *it->third;
        const Particle &p4 = *it->fourth;

        Real3D dist21, dist32, dist43; // 

        bc.getMinimumImageVectorBox(dist21, p2.position(), p1.position());
        bc.getMinimumImageVectorBox(dist32, p3.position(), p2.position());
        bc.getMinimumImageVectorBox(dist43, p4.position(), p3.position());

        e += potential->_computeEnergy(dist21, dist32, dist43);
      }
      real esum;
      boost::mpi::all_reduce(*mpiWorld, e, esum, std::plus<real>());
      return esum;
    }
Example #17
0
    FixedListComm::~FixedListComm() {

        //std::cout << "~fixedlist" << std::endl;

        LOG4ESPP_INFO(theLogger, "~FixedListComm");

        con1.disconnect();
        con2.disconnect();
        con3.disconnect();
    }
Example #18
0
    void FixedListComm::onParticlesChanged() {
        LOG4ESPP_INFO(theLogger, "rebuild local bond list from global\n");
        //this->clear();
        longint lastpid1 = -1;

        Particle* p, * pK;
        std::vector<Particle*> tmp;

        GlobalList::const_iterator it = globalLists.begin();
        int size = it->second.size()+1;
        if (size == 2) this->PairList::clear();
        else if (size == 3) this->TripleList::clear();
        else if (size == 4) this->QuadrupleList::clear();


        // iterate through keys of map
        for (;it != globalLists.end(); ++it) {
            if (it->first != lastpid1) { // don't check same pid twice
                pK = storage->lookupRealParticle(it->first);
                if (pK == NULL) {
                    printf("SERIOUS ERROR: particle %d not available\n", it->first);
                }
                lastpid1 = it->first;
            }
            // iterate through vector in map
            for (pvec::const_iterator it2 = it->second.begin(); it2!=it->second.end(); ++it2) {
                p = storage->lookupLocalParticle(*it2);
                if (p == NULL) {
                  printf("SERIOUS ERROR: particle %d not available\n", *it2);
                }
                tmp.push_back(p);
            }
            // add the particles
            if (size == 2) this->PairList::add(pK, tmp.at(0));
            else if (size == 3) this->TripleList::add(pK, tmp.at(0), tmp.at(1));
            else if (size == 4) this->QuadrupleList::add(pK, tmp.at(0), tmp.at(1), tmp.at(2));
            tmp.clear();
        }
        LOG4ESPP_INFO(theLogger, "regenerated local fixed list from global list");
    }
Example #19
0
    FixedListComm::FixedListComm(shared_ptr <storage::Storage> _storage)
        : storage(_storage), globalLists(){

        //std::cout << "fixedlist" << std::endl;

        LOG4ESPP_INFO(theLogger, "construct FixedPairList");
        con1 = storage->beforeSendParticles.connect
          (boost::bind(&FixedListComm::beforeSendParticles, this, _1, _2));
        con2 = storage->afterRecvParticles.connect
          (boost::bind(&FixedListComm::afterRecvParticles, this, _1, _2));
        con3 = storage->onParticlesChanged.connect
          (boost::bind(&FixedListComm::onParticlesChanged, this));
    }
Example #20
0
    bool FixedListComm::add(pvec pids) {


        // ADD THE LOCAL PARTICLES
        Particle* p;
        std::vector<Particle*> tmp;
        
        pvec::iterator it = pids.begin();
        p = storage->lookupRealParticle(*it); //wrong, last particle is key
        if (!p) return false;
        tmp.push_back(p);
        
        for (++it; it!=pids.end(); ++it) {
            p = storage->lookupLocalParticle(*it);
            if (!p)
                // Particle does not exist here, return false
                return false;
            tmp.push_back(p);
        }
        //add(tmp);
        if (pids.size() == 2) this->PairList::add(tmp.at(1), tmp.at(0));
        else if (pids.size() == 3) this->TripleList::add(tmp.at(0), tmp.at(2), tmp.at(1));
        else if (pids.size() == 4) this->QuadrupleList::add(tmp.at(3), tmp.at(0), tmp.at(1), tmp.at(2));
        tmp.clear();

        // ADD THE GLOBAL PARTICLES
        longint pidK = pids.back(); // last pid is key
        pids.pop_back(); // remove last pid
        std::pair<GlobalList::const_iterator, GlobalList::const_iterator>
        equalRange = globalLists.equal_range(pidK);
        // see whether the particle already has pairs
        if (equalRange.first == globalLists.end()) {
            // it hasn't, insert the new pair
            //globalLists.insert(make_pair(pid1, pid2));
            globalLists.insert(make_pair(pidK, pids));
        }
        else {// otherwise test whether the pair already exists
            for (GlobalList::const_iterator it = equalRange.first;
            it != equalRange.second; ++it) {
                if (it->second == pids) {
                   // TODO: Pair already exists, generate error!
                }
                // if not, insert the new pair
                globalLists.insert(equalRange.first, make_pair(pidK, pids));
            }
        }
        LOG4ESPP_INFO(theLogger, "added fixed pair to global pair list");

        return true;
    }
Example #21
0
    void FixedListComm::beforeSendParticles
                                    (ParticleList& pl, OutBuffer& buf) {

        std::vector<longint> toSend;

        // loop over the particle list
        for (ParticleList::Iterator pit(pl); pit.isValid(); ++pit) {
            longint pid = pit->id();
            LOG4ESPP_DEBUG(theLogger, "send particle with pid " << pid << ", find pairs");

            // find all particles that involve this particle id
            int n = globalLists.count(pid);
            if (n > 0) {
                std::pair<GlobalList::const_iterator,
                 GlobalList::const_iterator>
                equalRange = globalLists.equal_range(pid);

                // get the length of the vector in the map
                int l = equalRange.first->second.size();
                toSend.reserve(toSend.size()+3+n*l);
                // first write the pid of the first particle
                toSend.push_back(pid);
                // then the number of partners
                toSend.push_back(n);
                // then the size of the vector
                toSend.push_back(l);
                // and then the pids of the partners
                for (GlobalList::const_iterator it = equalRange.first;
                it != equalRange.second; ++it) {
                    // iterate through vector to add pids
                    for (pvec::const_iterator it2=it->second.begin();
                    it2!=it->second.end(); ++it2) {
                        toSend.push_back(*it2);
                        LOG4ESPP_DEBUG(theLogger, "send global bond: pid "
                               << pid << " and its vector");
                    }
                }

                // delete all of these pairs from the global list
                globalLists.erase(equalRange.first, equalRange.second);
            }
        }
        // send the list
        buf.write(toSend);
        LOG4ESPP_INFO(theLogger, "prepared fixed pair list before send particles");
    }
inline void
FixedQuadrupleListTypesInteractionTemplate<_DihedralPotential>::
computeVirialTensor(Tensor &w, real z) {
    LOG4ESPP_INFO(theLogger, "compute the virial tensor of the quadruples");

    Tensor wlocal(0.0);
    const bc::BC &bc = *getSystemRef().bc;

    std::cout << "Warning!!! computeVirialTensor in specified volume doesn't work for "
              "FixedQuadrupleListTypesInteractionTemplate at the moment" << std::endl;

    for (FixedQuadrupleList::QuadrupleList::Iterator it(*fixedquadrupleList); it.isValid(); ++it) {
        const Particle &p1 = *it->first;
        const Particle &p2 = *it->second;
        const Particle &p3 = *it->third;
        const Particle &p4 = *it->fourth;

        longint type1 = p1.type();
        longint type2 = p2.type();
        longint type3 = p3.type();
        longint type4 = p4.type();

        const Potential &potential = getPotential(type1, type2, type3, type4);

        Real3D dist21, dist32, dist43;

        bc.getMinimumImageVectorBox(dist21, p2.position(), p1.position());
        bc.getMinimumImageVectorBox(dist32, p3.position(), p2.position());
        bc.getMinimumImageVectorBox(dist43, p4.position(), p3.position());

        Real3D force1, force2, force3, force4;

        potential.computeForce(force1, force2, force3, force4,
                               dist21, dist32, dist43);

        // TODO: formulas are not correct yet

        wlocal += Tensor(dist21, force1) - Tensor(dist32, force2);
    }
    // reduce over all CPUs
    Tensor wsum(0.0);
    boost::mpi::all_reduce(*mpiWorld, (double *) &wlocal, 6, (double *) &wsum, std::plus<double>());
    w += wsum;
}
Example #23
0
    void associateMethod(const string &name, const IdType id) {
      if (methodCallersByName().find(name) == methodCallersByName().end())
	PMI_REPORT_USER_ERROR(printWorkerId()				\
			      << "has not registered method \"" << name	\
			      << "\" (methodCaller undefined).");
#ifndef PMI_OPTIMIZE
      // check whether the vector has the right size
      if (methodCallers.size() != id)
	PMI_REPORT_INTL_ERROR(printWorkerId()					\
		       << "has " << methodCallers.size()		\
		       << " associated methods, but received id "	\
		       << id << " as the next id.");
      PMI_REPORT_OK;
#endif
      LOG4ESPP_INFO(logger, printWorkerId()			\
		    << "associates method \""				\
		    << name << "\" to method id " << id << ".");
      
      MethodCallerType mc = methodCallersByName()[name];
      methodCallers.push_back(mc);
      methodCallersByName().erase(name);
    }
 //////////////////////////////////////////////////
 // INLINE IMPLEMENTATION
 //////////////////////////////////////////////////
 template < typename _AngularPotential > inline void
 FixedTripleAngleListInteractionTemplate <_AngularPotential>::
 addForces() {
   LOG4ESPP_INFO(theLogger, "add forces computed by FixedTripleAngleList");
   const bc::BC& bc = *getSystemRef().bc;  // boundary conditions
   for (FixedTripleAngleList::TripleList::Iterator it(*fixedtripleList); it.isValid(); ++it) {
     Particle &p1 = *it->first;
     Particle &p2 = *it->second;
     Particle &p3 = *it->third;
     //const Potential &potential = getPotential(p1.type(), p2.type());
     Real3D dist12, dist32;
     bc.getMinimumImageVectorBox(dist12, p1.position(), p2.position());
     bc.getMinimumImageVectorBox(dist32, p3.position(), p2.position());
     Real3D force12, force32;
     
     real currentAngle = fixedtripleList->getAngle(p1.getId(), p2.getId(), p3.getId());
     
     potential->_computeForce(force12, force32, dist12, dist32, currentAngle);
     p1.force() += force12;
     p2.force() -= force12 + force32;
     p3.force() += force32;
   }
 }
    template < typename _AngularPotential > inline real
    FixedTripleAngleListInteractionTemplate < _AngularPotential >::
    computeEnergy() {
      LOG4ESPP_INFO(theLogger, "compute energy of the triples");

      const bc::BC& bc = *getSystemRef().bc;
      real e = 0.0;
      for (FixedTripleAngleList::TripleList::Iterator it(*fixedtripleList); it.isValid(); ++it) {
        const Particle &p1 = *it->first;
        const Particle &p2 = *it->second;
        const Particle &p3 = *it->third;
        //const Potential &potential = getPotential(p1.type(), p2.type());
        Real3D dist12 = bc.getMinimumImageVector(p1.position(), p2.position());
        Real3D dist32 = bc.getMinimumImageVector(p3.position(), p2.position());
        
        real currentAngle = fixedtripleList->getAngle(p1.getId(), p2.getId(), p3.getId());
        
        e += potential->_computeEnergy(dist12, dist32, currentAngle);
      }
      real esum;
      boost::mpi::all_reduce(*mpiWorld, e, esum, std::plus<real>());
      return esum;
    }
    template < typename _AngularPotential > inline void
    FixedTripleAngleListInteractionTemplate < _AngularPotential >::
    computeVirialTensor(Tensor& w, real z) {
      LOG4ESPP_INFO(theLogger, "compute the virial tensor of the triples");
      
      std::cout << "Warning! At the moment IK computeVirialTensor for fixed triples does'n work"<<std::endl;
      /*
      Tensor wlocal(0.0);
      const bc::BC& bc = *getSystemRef().bc;
      for (FixedTripleAngleList::TripleList::Iterator it(*fixedtripleList); it.isValid(); ++it){
        const Particle &p1 = *it->first;
        const Particle &p2 = *it->second;
        const Particle &p3 = *it->third;
        
        Real3D p2pos = p2.position();
        
        if(  (p2pos[0]>xmin && p2pos[0]<xmax && 
              p2pos[1]>ymin && p2pos[1]<ymax && 
              p2pos[2]>zmin && p2pos[2]<zmax) ){
          Real3D r12, r32;
          bc.getMinimumImageVectorBox(r12, p1.position(), p2.position());
          bc.getMinimumImageVectorBox(r32, p3.position(), p2.position());
          Real3D force12, force32;

          real currentAngle = fixedtripleList->getAngle(p1.getId(), p2.getId(), p3.getId());
        
          potential->_computeForce(force12, force32, r12, r32, currentAngle);
          wlocal += Tensor(r12, force12) + Tensor(r32, force32);
        }
      }
      
      // reduce over all CPUs
      Tensor wsum(0.0);
      boost::mpi::all_reduce(*mpiWorld, (double*)&wlocal, 6, (double*)&wsum, std::plus<double>());
      w += wsum;
       */
    }
Example #27
0
    void FixedListComm::afterRecvParticles
                                    (ParticleList &pl,InBuffer& buf) {

        std::vector<longint> received, pids;
        int n, l, tl;
        longint pid1;
        GlobalList::iterator it = globalLists.begin();


        // receive the bond list
        buf.read(received);
        int size = received.size();
        int i = 0;
        while (i < size) {
            // unpack the list
            pid1 = received[i++];
            n = received[i++];
            l = received[i++];
            LOG4ESPP_DEBUG(theLogger,
                    "recv particle " << pid1 << ", has " << n << " global pairs");
            for (; n > 0; --n) {
                for (tl = l; tl > 0; --tl) {
                    pids.push_back(received[i++]);
                }
                // add the bond to the global list
                LOG4ESPP_DEBUG(theLogger, "received vector for pid " << pid1);
                it = globalLists.insert(it, std::make_pair(pid1, pids));
                pids.clear();
            }
        }
        if (i != size) {
            LOG4ESPP_ERROR(theLogger,
                    "recv particles might have read garbage\n");
        }
        LOG4ESPP_INFO(theLogger,
                "received fixed particle list after receive particles");
    }
inline void
FixedTripleListTypesInteractionTemplate<_Potential>::addForces() {
  LOG4ESPP_INFO(theLogger, "add forces computed by the FixedTriple List");
  const bc::BC &bc = *getSystemRef().bc;

  for (FixedTripleList::TripleList::Iterator it(*fixedtripleList); it.isValid(); ++it) {
    Particle &p1 = *it->first;
    Particle &p2 = *it->second;
    Particle &p3 = *it->third;
    int type1 = p1.type();
    int type2 = p2.type();
    int type3 = p3.type();
    const Potential &potential = getPotential(type1, type2, type3);

    Real3D dist12, dist32;
    bc.getMinimumImageVectorBox(dist12, p1.position(), p2.position());
    bc.getMinimumImageVectorBox(dist32, p3.position(), p2.position());
    Real3D force12, force32;
    potential._computeForce(force12, force32, dist12, dist32);
    p1.force() += force12;
    p2.force() -= force12 + force32;
    p3.force() += force32;
  }
}
Example #29
0
    void associateClass(const string &name, const IdType id) {
      if (constructorCallersByName().find(name) == 
	  constructorCallersByName().end())
	PMI_REPORT_USER_ERROR(printWorkerId()				\
			      << "has not registered class \"" << name	\
			      << "\" (constructor undefined).");
#ifndef PMI_OPTIMIZE
      if (destructorCallersByName().find(name) == destructorCallersByName().end())
	PMI_REPORT_INTL_ERROR(printWorkerId()					\
			      << "has not registered class \"" << name	\
		       << "\" (constructur defined, but destructor undefined).");
      // check whether the vector has the right size
      if (constructorCallers.size() != id)
	PMI_REPORT_INTL_ERROR(printWorkerId()					\
		       << "has " << constructorCallers.size()		\
		       << " associated constructors, but received id "	\
		       << id << " as the next id.");
      // check whether the vector has the right size
      if (destructorCallers.size() != id)
	PMI_REPORT_INTL_ERROR(printWorkerId()					\
		       << "has " << destructorCallers.size()		\
		       << " associated destructors, but received id "	\
		       << id << " as the next id.");
      PMI_REPORT_OK;
#endif
      LOG4ESPP_INFO(logger, printWorkerId()			\
		    << "associates class \""			\
		    << name << "\" to class id " << id << ".");
      
      ConstructorCallerType cc = constructorCallersByName()[name];
      constructorCallers.push_back(cc);
      constructorCallersByName().erase(name);
      DestructorCallerType dc = destructorCallersByName()[name];
      destructorCallers.push_back(dc); 
      destructorCallersByName().erase(name);
    }
inline void
FixedTripleListTypesInteractionTemplate<_Potential>::
computeVirialTensor(Tensor *w, int n) {
  LOG4ESPP_INFO(theLogger, "compute the virial tensor for the FixedTriple List");
}