ESyS-Particle  4.0.1
pi_storage.hpp
00001 
00002 //                                                         //
00003 // Copyright (c) 2003-2011 by The University of Queensland //
00004 // Earth Systems Science Computational Centre (ESSCC)      //
00005 // http://www.uq.edu.au/esscc                              //
00006 //                                                         //
00007 // Primary Business: Brisbane, Queensland, Australia       //
00008 // Licensed under the Open Software License version 3.0    //
00009 // http://www.opensource.org/licenses/osl-3.0.php          //
00010 //                                                         //
00012 
00013 #include "Foundation/vec3.h"
00014 #include "Fields/ScalarInteractionFieldSlave.h"
00015 #include "Fields/CheckedScalarInteractionFieldSlave.h"
00016 #include "Fields/ScalarInteractionFieldSlaveTagged.h"
00017 #include "Fields/CheckedScalarInteractionFieldSlaveTagged.h"
00018 #include "Fields/VectorInteractionFieldSlave.h"
00019 
00020 #include "ppa/src/pp_array.h"
00021 
00022 template <typename I>
00023 bool TParallelInteractionStorage<I>::InteractionIterator::isInner(const Iterator &it)
00024 {
00025   return m_ppa->isInInner(it->getPosFirst());
00026 }
00027 
00028 template <typename I>
00029 TParallelInteractionStorage<I>::InteractionIterator::InteractionIterator(
00030   Iterator begin,
00031   Iterator end,
00032   AParallelParticleArray* ppa
00033 )
00034   : m_numRemaining(0),
00035     m_it(end),
00036     m_end(end),
00037     m_ppa(ppa)
00038 {
00039   m_numRemaining = 0;
00040   for (Iterator it = begin; it != end; it++) {
00041     if  (isInner(it)) {
00042       m_numRemaining++;
00043     }
00044   }
00045   m_it  = begin;
00046   m_end = end;
00047 }
00048 
00049 template <typename I>
00050 bool TParallelInteractionStorage<I>::InteractionIterator::hasNext()
00051 {
00052   return (m_numRemaining > 0);
00053 }
00054 
00055 template <typename I>
00056 typename TParallelInteractionStorage<I>::InteractionIterator::Interaction &
00057 TParallelInteractionStorage<I>::InteractionIterator::next()
00058 {
00059   while (!isInner(m_it)) {
00060     m_it++;
00061   }
00062   Interaction &i = *m_it;
00063   m_it++;
00064   m_numRemaining--;
00065   return i;
00066 }
00067 
00068 template <typename I>
00069 int TParallelInteractionStorage<I>::InteractionIterator::getNumRemaining()
00070 {
00071   return m_numRemaining;
00072 }
00073 
00074 template <typename I>
00075 typename TParallelInteractionStorage<I>::InteractionIterator
00076 TParallelInteractionStorage<I>::getInnerInteractionIterator()
00077 {
00078   return
00079     InteractionIterator(m_interactions.begin(), m_interactions.end(), m_ppa);
00080 }
00081 
00082 
00089 template <typename I> 
00090 template <typename P> 
00091 vector<pair<Vec3,P> > TParallelInteractionStorage<I>::forAllInnerInteractionsGetWithPos(P (I::*rdf)() const)
00092 {
00093   vector<pair<Vec3,P> > res;
00094 
00095   for(typename list<I>::iterator iter=m_interactions.begin();
00096       iter!=m_interactions.end();
00097       iter++){
00098     Vec3 pos=iter->getPosFirst();
00099     if(m_ppa->isInInner(pos)) res.push_back(make_pair(iter->getPos(),((*iter).*rdf)())); 
00100   }
00101 
00102   return res;
00103 }
00104 
00111 template <typename I> 
00112 template <typename P> 
00113 vector<pair<typename TParallelInteractionStorage<I>::Raw2Data,P> >
00114 TParallelInteractionStorage<I>::forAllInnerInteractionsGetRaw2(P (I::*rdf)() const)
00115 {
00116   vector<pair<Raw2Data,P> > res;
00117 
00118   for(typename list<I>::iterator iter=m_interactions.begin();
00119       iter!=m_interactions.end();
00120       iter++){
00121     if(m_ppa->isInInner(iter->getPosFirst())) {      
00122       const Raw2Data data = iter->getRaw2Data();
00123       res.push_back(pair<Raw2Data,P>(data,((*iter).*rdf)())); 
00124     }
00125   }
00126 
00127   return res;
00128 }
00129 
00136 template <typename I> 
00137 template <typename P> 
00138 vector<pair<typename TParallelInteractionStorage<I>::DataWithPosID,P> > 
00139 TParallelInteractionStorage<I>::forAllInnerInteractionsGetDataWithPosID(P (I::*rdf)() const)
00140 {
00141   vector<pair<DataWithPosID,P> > res;
00142 
00143   for(typename list<I>::iterator iter=m_interactions.begin();
00144       iter!=m_interactions.end();
00145       iter++){
00146     if(m_ppa->isInInner(iter->getPosFirst())) {      
00147       vector<int> ids=iter->getAllID();
00148       int id1=ids[0];
00149       int id2;
00150       if(ids.size()>=2) {
00151         id2=ids[1];
00152       } else {
00153         id2=-1;
00154       }
00155       const Raw2Data data = iter->getRaw2Data();
00156       Vec3 pos1=data.get<0>();
00157       Vec3 pos2=data.get<2>();
00158       Vec3 ipos=data.get<4>();
00159       res.push_back(pair<DataWithPosID,P>(DataWithPosID(id1,id2,pos1,pos2,ipos),((*iter).*rdf)())); 
00160     }
00161   }
00162   
00163   return res;
00164 }
00165 
00172 template <typename I> 
00173 template <typename P> 
00174 vector<pair<typename TParallelInteractionStorage<I>::DataWithID,P> > 
00175 TParallelInteractionStorage<I>::forAllInnerInteractionsGetDataWithID(P (I::*rdf)() const)
00176 {
00177   vector<pair<DataWithID,P> > res;
00178 
00179   for(typename list<I>::iterator iter=m_interactions.begin();
00180       iter!=m_interactions.end();
00181       iter++){
00182     if(m_ppa->isInInner(iter->getPosFirst())) {      
00183       vector<int> ids=iter->getAllID();
00184       int id1=ids[0];
00185       int id2;
00186       if(ids.size()>=2) {
00187         id2=ids[1];
00188       } else {
00189         id2=-1;
00190       }
00191       Vec3 pos=iter->getPos();
00192       res.push_back(pair<DataWithID,P>(DataWithID(id1,id2,pos),((*iter).*rdf)())); 
00193     }
00194   }
00195   
00196   return res;
00197 }
00198 
00207 template <typename I> 
00208 template <typename P> 
00209 void TParallelInteractionStorage<I>::forAllInnerInteractionsGet(P& cont,typename P::value_type (I::*rdf)()const)
00210 {
00211   for(typename list<I>::iterator iter=m_interactions.begin();
00212       iter!=m_interactions.end();
00213       iter++){
00214     Vec3 pos=iter->getPosFirst();
00215     if(m_ppa->isInInner(pos)) cont.push_back(((*iter).*rdf)());  
00216   }
00217 }
00218 
00219 
00229 template <typename I> 
00230 template <typename P> 
00231 vector<pair<Vec3,P> > TParallelInteractionStorage<I>::forAllTaggedInnerInteractionsGetWithPos(P (I::*rdf)() const,int tag,int mask)
00232 {
00233   vector<pair<Vec3,P> > res;
00234 
00235   for(typename list<I>::iterator iter=m_interactions.begin();
00236       iter!=m_interactions.end();
00237       iter++){
00238     Vec3 pos=iter->getPosFirst();
00239     if(iter->hasTag(tag,mask)){
00240       if(m_ppa->isInInner(pos)) res.push_back(make_pair(iter->getPos(),((*iter).*rdf)())); 
00241     }
00242   }
00243 
00244   return res;
00245 }
00246 
00256 template <typename I> 
00257 template <typename P> 
00258 void TParallelInteractionStorage<I>::forAllTaggedInnerInteractionsGet(P& cont,typename P::value_type (I::*rdf)()const,int tag,int mask)
00259 {
00260   for(typename list<I>::iterator iter=m_interactions.begin();
00261       iter!=m_interactions.end();
00262       iter++){
00263     Vec3 pos=iter->getPosFirst();
00264     if(iter->hasTag(tag,mask)){
00265       if(m_ppa->isInInner(pos)) cont.push_back(((*iter).*rdf)());  
00266     }
00267   }
00268 }
00269 
00280 template <typename I> 
00281 AFieldSlave* TParallelInteractionStorage<I>::generateNewScalarFieldSlave(TML_Comm* comm,const string& fieldname,int is_checked,int is_tagged,int tag,int mask)
00282 {
00283   InteractionFieldSlave<I>* new_ifs;
00284  
00285 
00286   if(is_checked==0){
00287     typename I::ScalarFieldFunction rdf=I::getScalarFieldFunction(fieldname);
00288     if(is_tagged==0){
00289       new_ifs=new ScalarInteractionFieldSlave<I>(comm,this,rdf);
00290     } else {
00291       new_ifs=new ScalarInteractionFieldSlaveTagged<I>(comm,this,rdf,tag,mask);
00292     }
00293   } else {
00294     typename I::CheckedScalarFieldFunction rdf=I::getCheckedScalarFieldFunction(fieldname);
00295     if(is_tagged==0){
00296       new_ifs=new CheckedScalarInteractionFieldSlave<I>(comm,this,rdf);
00297     } else {
00298       new_ifs=new CheckedScalarInteractionFieldSlaveTagged<I>(comm,this,rdf,tag,mask);
00299     }
00300   }
00301 
00302   return new_ifs;
00303 }
00304 
00315 template <typename I> 
00316 AFieldSlave* TParallelInteractionStorage<I>::generateNewVectorFieldSlave(TML_Comm* comm,const string& fieldname,int is_checked,int is_tagged,int tag,int mask)
00317 {
00318   InteractionFieldSlave<I>* new_ifs = NULL;
00319  
00320 
00321   if(is_checked==0){
00322     typename I::VectorFieldFunction rdf=I::getVectorFieldFunction(fieldname);
00323     if(is_tagged==0){
00324       new_ifs=new VectorInteractionFieldSlave<I>(comm,this,rdf);
00325     } else {
00326       // new_ifs=new VectorInteractionFieldSlaveTagged<I>(comm,this,rdf,tag,mask);
00327     }
00328   } else {
00329     // typename I::CheckedVectorFieldFunction rdf=I::getCheckedVectorFieldFunction(fieldname);
00330     if(is_tagged==0){
00331       // new_ifs=new CheckedVectorInteractionFieldSlave<I>(comm,this,rdf);
00332     } else {
00333       // new_ifs=new CheckedVectorInteractionFieldSlaveTagged<I>(comm,this,rdf,tag,mask);
00334     }
00335   }
00336 
00337   return new_ifs;
00338 }