G4CollisionManager Class Reference

#include <G4CollisionManager.hh>


Public Member Functions

 G4CollisionManager ()
 ~G4CollisionManager ()
G4int Entries ()
void AddCollision (G4double time, G4KineticTrack *proj, G4KineticTrack *target=NULL)
void AddCollision (G4CollisionInitialState *collision)
void RemoveCollision (G4CollisionInitialState *collision)
void RemoveTracksCollisions (G4KineticTrackVector *ktv)
void ClearAndDestroy ()
G4CollisionInitialState * GetNextCollision ()
void Print ()

Detailed Description

Definition at line 36 of file G4CollisionManager.hh.

Constructor & Destructor Documentation

G4CollisionManager::G4CollisionManager (  ) 

Definition at line 35 of file G4CollisionManager.cc.

00036 {
00037   theCollisionList = new G4ListOfCollisions;
00038 }

G4CollisionManager::~G4CollisionManager (  ) 

Definition at line 41 of file G4CollisionManager.cc.

References ClearAndDestroy().

00042 {
00043   ClearAndDestroy();
00044   delete theCollisionList;
00045 }

Member Function Documentation

void G4CollisionManager::AddCollision ( G4CollisionInitialState *  collision  )  [inline]

Definition at line 45 of file G4CollisionManager.hh.

00046   {
00047     theCollisionList->push_back(collision);
00048   }

void G4CollisionManager::AddCollision ( G4double  time,
G4KineticTrack *  proj,
G4KineticTrack *  target = NULL 
)

Definition at line 48 of file G4CollisionManager.cc.

References DBL_MAX, G4cerr, G4endl, G4KineticTrack::Get4Momentum(), G4KineticTrack::GetDefinition(), and G4ParticleDefinition::GetParticleName().

00051 {
00052       if ( time < DBL_MAX )
00053       {
00054          G4CollisionInitialState *
00055              collision = new G4CollisionInitialState(time, proj, target);
00056          theCollisionList->push_back(collision);
00057       } else {
00058          G4cerr << "G4Scatterer invalid TimeTo Interaction : " << time;
00059          G4cerr <<"    projectile "<<proj->Get4Momentum()<<" "
00060                                    <<proj->GetDefinition()->GetParticleName()<<G4endl;
00061          if (target) G4cerr <<"    target     "
00062                                 <<target->Get4Momentum()<<" "
00063                                 <<target->GetDefinition()->GetParticleName()<<G4endl;
00064          G4cerr <<"G4Scatterer error message end"<< G4endl;
00065          throw G4HadronicException(__FILE__, __LINE__, "G4Scatterer::AddCollision()");
00066       }
00067 }

void G4CollisionManager::ClearAndDestroy (  ) 

Definition at line 131 of file G4CollisionManager.cc.

Referenced by G4BinaryCascade::ApplyYourself(), G4BinaryCascade::Propagate(), and ~G4CollisionManager().

00132 {
00133   std::vector<G4CollisionInitialState *>::iterator i;
00134   for(i = theCollisionList->begin(); i != theCollisionList->end(); ++i)
00135     delete *i;
00136   theCollisionList->clear();
00137 }

G4int G4CollisionManager::Entries (  )  [inline]

Definition at line 65 of file G4CollisionManager.hh.

Referenced by G4BinaryCascade::Propagate().

00066 {
00067   return theCollisionList->size();
00068 }

G4CollisionInitialState * G4CollisionManager::GetNextCollision (  ) 

Definition at line 140 of file G4CollisionManager.cc.

References DBL_MAX, G4cerr, and G4endl.

Referenced by G4BinaryCascade::Propagate().

00141 {
00142   G4CollisionInitialState * theNext=0;
00143   G4double nextTime = DBL_MAX;
00144   std::vector<G4CollisionInitialState *>::iterator i;
00145   for(i = theCollisionList->begin(); i != theCollisionList->end(); ++i)
00146   {
00147     if(nextTime > (*i)->GetCollisionTime())
00148     {
00149       nextTime = (*i)->GetCollisionTime();
00150       theNext = *i;
00151     }
00152   }
00153   #ifdef debug_G4CollisionManager
00154   if(theNext == 0 && theCollisionList->size()!=0)
00155   {
00156     G4double debugTime = DBL_MAX;
00157     G4cerr <<"G4CollisionManager::GetNextCollision - Fatal"<<G4endl;
00158     G4cerr <<" number of collisions left "<<theCollisionList->size()<<G4endl;
00159     for(i = theCollisionList->begin(); i != theCollisionList->end(); ++i)
00160     {
00161       G4cerr <<" Time to collision "<<(*i)->GetCollisionTime()<<" "<<G4endl;
00162       G4cerr <<"    projectile "<<(*i)->GetPrimary()->Get4Momentum()<<" "
00163                                 <<(*i)->GetPrimary()->GetDefinition()->GetParticleName()<<G4endl;
00164       if ((*i)->GetTarget()) G4cerr <<"    target     "<<(*i)->GetTarget()->Get4Momentum()<<" "
00165                                 <<(*i)->GetTarget()->GetDefinition()->GetParticleName()<<G4endl;
00166     }
00167     G4cerr <<"G4CollisionManager::GetNextCollision - End of message"<<G4endl;
00168   }
00169   #endif
00170 
00171   return theNext;
00172 }

void G4CollisionManager::Print (  ) 

Definition at line 175 of file G4CollisionManager.cc.

References G4cout, G4endl, G4CollisionInitialState::GetCollisionTime(), G4KineticTrack::GetDefinition(), G4CollisionInitialState::GetGenerator(), G4ParticleDefinition::GetPDGEncoding(), G4CollisionInitialState::GetPrimary(), and G4CollisionInitialState::GetTarget().

00176 {
00177   std::vector<G4CollisionInitialState *>::iterator i;
00178 
00179   G4cout << "CollisionManager: " << theCollisionList->size()
00180          << " entries at " << theCollisionList << G4endl;
00181   G4CollisionInitialState * collision;
00182   for(i = theCollisionList->begin(); i != theCollisionList->end(); ++i)
00183   {
00184     collision = *i;
00185     G4int tgtPdg=collision->GetTarget() ?
00186            collision->GetTarget()->GetDefinition()->GetPDGEncoding() : 0;
00187     G4cout << "  collision " << collision << " time: "
00188            << collision->GetCollisionTime()/second << " proj: "
00189            << collision->GetPrimary() << "/pdg="
00190            << collision->GetPrimary()->GetDefinition()->GetPDGEncoding()
00191            << " trgt: "
00192            << collision->GetTarget() << "/pdg="
00193            << tgtPdg
00194            << " Collision type: "<< typeid(*collision->GetGenerator()).name()
00195            << G4endl;
00196   }
00197 }

void G4CollisionManager::RemoveCollision ( G4CollisionInitialState *  collision  ) 

Definition at line 70 of file G4CollisionManager.cc.

Referenced by G4BinaryCascade::Propagate().

00071 {
00072   theCollisionList->erase(std::find(theCollisionList->begin(),
00073                                       theCollisionList->end(),
00074                                       collision));
00075   delete collision;
00076   collision = NULL; // prevent future use of the pointer
00077 }

void G4CollisionManager::RemoveTracksCollisions ( G4KineticTrackVector *  ktv  ) 

Definition at line 80 of file G4CollisionManager.cc.

References G4CollisionInitialState::GetPrimary(), G4CollisionInitialState::GetTarget(), and G4CollisionInitialState::GetTargetCollection().

00081 {
00082   if(toBeCaned == NULL)
00083     return;
00084   if(toBeCaned->empty())
00085     return;
00086 
00087   G4CollisionInitialState * collision;
00088   std::vector<G4CollisionInitialState *>::iterator collIter, collIter2;
00089   std::vector<G4KineticTrack *>::iterator trackIter;
00090   G4ListOfCollisions toRemove;
00091 
00092   for(collIter = theCollisionList->begin();
00093       collIter != theCollisionList->end(); collIter++)
00094   {
00095     collision = *collIter;
00096     G4KineticTrackVector & targets = collision->GetTargetCollection();
00097     G4bool getNextCollision = false;
00098     for(trackIter = toBeCaned->begin(); trackIter != toBeCaned->end(); ++trackIter)
00099     {
00100       if((collision->GetTarget() == *trackIter) ||
00101          (collision->GetPrimary() == *trackIter))
00102       {  // cannot remove the collision from the list inside the loop. Save and do it later
00103         toRemove.push_back(collision);
00104         break;  // exit from the "trackIter" loop
00105       }
00106       for(size_t tcount=0; tcount<targets.size(); tcount++)
00107       {
00108         if(targets[tcount] == *trackIter)
00109         {
00110           toRemove.push_back(collision);
00111           getNextCollision = true;
00112           break;
00113         }
00114       }
00115       if(getNextCollision) break;
00116     }
00117   }
00118 
00119   // now remove the collisions
00120   for(collIter = toRemove.begin(); collIter != toRemove.end(); ++collIter)
00121   {
00122     collision = *collIter;
00123     collIter2 = std::find(theCollisionList->begin(),
00124                             theCollisionList->end(), collision);
00125     theCollisionList->erase(collIter2);  // remove from list...
00126     delete collision;                    // ...and delete the collision
00127   }
00128 }

The documentation for this class was generated from the following files:
Generated on Mon May 27 17:51:39 2013 for Geant4 by  doxygen 1.4.7