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::G4CollisionManager

(

)

Definition at line 35 of file G4CollisionManager.cc.

{
  theCollisionList = new G4ListOfCollisions;
}

~G4CollisionManager()

G4CollisionManager::~G4CollisionManager

(

)

Definition at line 41 of file G4CollisionManager.cc.

{
  ClearAndDestroy();
  delete theCollisionList;
}

Member Function Documentation

AddCollision() [1/2]

void G4CollisionManager::AddCollision ( G4CollisionInitialState *  collision )

inline

Definition at line 45 of file G4CollisionManager.hh.

  {
    theCollisionList->push_back(collision);
  }

AddCollision() [2/2]

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

Definition at line 48 of file G4CollisionManager.cc.

{
      if ( time < DBL_MAX )
      {
         G4CollisionInitialState *
         collision = new G4CollisionInitialState(time, proj, target);
         theCollisionList->push_back(collision);
      } else {
         G4cerr << "G4Scatterer invalid TimeTo Interaction : " << time;
         G4cerr <<"    projectile "<<proj->Get4Momentum()<<" "
                                   <<proj->GetDefinition()->GetParticleName()<<G4endl;
         if (target) G4cerr <<"    target     "
                <<target->Get4Momentum()<<" "
                                <<target->GetDefinition()->GetParticleName()<<G4endl;
         G4cerr <<"G4Scatterer error message end"<< G4endl;
     throw G4HadronicException(__FILE__, __LINE__, "G4Scatterer::AddCollision()");
      }
}

ClearAndDestroy()

void G4CollisionManager::ClearAndDestroy

(

)

Definition at line 131 of file G4CollisionManager.cc.

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

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

Entries()

G4int G4CollisionManager::Entries ( )

inline

Definition at line 65 of file G4CollisionManager.hh.

{
  return theCollisionList->size();
}

Referenced by G4BinaryCascade::Propagate().

GetNextCollision()

G4CollisionInitialState * G4CollisionManager::GetNextCollision

(

)

Definition at line 140 of file G4CollisionManager.cc.

{
  G4CollisionInitialState * theNext=0;
  G4double nextTime = DBL_MAX;
  std::vector<G4CollisionInitialState *>::iterator i;
  for(i = theCollisionList->begin(); i != theCollisionList->end(); ++i)
  {
    if(nextTime > (*i)->GetCollisionTime())
    {
      nextTime = (*i)->GetCollisionTime();
      theNext = *i;
    }
  }
  #ifdef debug_G4CollisionManager
  if(theNext == 0 && theCollisionList->size()!=0)
  {
    G4double debugTime = DBL_MAX;
    G4cerr <<"G4CollisionManager::GetNextCollision - Fatal"<<G4endl;
    G4cerr <<" number of collisions left "<<theCollisionList->size()<<G4endl;
    for(i = theCollisionList->begin(); i != theCollisionList->end(); ++i)
    {
      G4cerr <<" Time to collision "<<(*i)->GetCollisionTime()<<" "<<G4endl;
      G4cerr <<"    projectile "<<(*i)->GetPrimary()->Get4Momentum()<<" "
                                <<(*i)->GetPrimary()->GetDefinition()->GetParticleName()<<G4endl;
      if ((*i)->GetTarget()) G4cerr <<"    target     "<<(*i)->GetTarget()->Get4Momentum()<<" "
                                <<(*i)->GetTarget()->GetDefinition()->GetParticleName()<<G4endl;
    }
    G4cerr <<"G4CollisionManager::GetNextCollision - End of message"<<G4endl;
  }
  #endif
 
  return theNext;
}

Referenced by G4BinaryCascade::Propagate().

Print()

void G4CollisionManager::Print

(

)

Definition at line 175 of file G4CollisionManager.cc.

{
  std::vector<G4CollisionInitialState *>::iterator i;
 
  G4cout << "CollisionManager: " << theCollisionList->size()
     << " entries at " << theCollisionList << G4endl;
  G4CollisionInitialState * collision;
  for(i = theCollisionList->begin(); i != theCollisionList->end(); ++i)
  {
    collision = *i;
    G4int tgtPdg=collision->GetTarget() ?
       collision->GetTarget()->GetDefinition()->GetPDGEncoding() : 0;
    G4cout << "  collision " << collision << " time: "
       << collision->GetCollisionTime()/second << " proj: "
       << collision->GetPrimary() << "/pdg="
       << collision->GetPrimary()->GetDefinition()->GetPDGEncoding()
       << " trgt: "
       << collision->GetTarget() << "/pdg="
       << tgtPdg
       << " Collision type: "<< typeid(*collision->GetGenerator()).name()
       << G4endl;
  }
}

RemoveCollision()

void G4CollisionManager::RemoveCollision

(

G4CollisionInitialState *

collision

)

Definition at line 70 of file G4CollisionManager.cc.

{
  theCollisionList->erase(std::find(theCollisionList->begin(),
                      theCollisionList->end(),
                      collision));
  delete collision;
  collision = NULL; // prevent future use of the pointer
}

Referenced by G4BinaryCascade::Propagate().

RemoveTracksCollisions()

void G4CollisionManager::RemoveTracksCollisions

(

G4KineticTrackVector *

ktv

)

Definition at line 80 of file G4CollisionManager.cc.

{
  if(toBeCaned == NULL)
    return;
  if(toBeCaned->empty())
    return;
 
  G4CollisionInitialState * collision;
  std::vector<G4CollisionInitialState *>::iterator collIter, collIter2;
  std::vector<G4KineticTrack *>::iterator trackIter;
  G4ListOfCollisions toRemove;
 
  for(collIter = theCollisionList->begin();
      collIter != theCollisionList->end(); collIter++)
  {
    collision = *collIter;
    G4KineticTrackVector & targets = collision->GetTargetCollection();
    G4bool getNextCollision = false;
    for(trackIter = toBeCaned->begin(); trackIter != toBeCaned->end(); ++trackIter)
    {
      if((collision->GetTarget() == *trackIter) ||
     (collision->GetPrimary() == *trackIter))
      {  // cannot remove the collision from the list inside the loop. Save and do it later
    toRemove.push_back(collision);
    break;  // exit from the "trackIter" loop
      }
      for(size_t tcount=0; tcount<targets.size(); tcount++)
      {
        if(targets[tcount] == *trackIter)
        {
      toRemove.push_back(collision);
      getNextCollision = true;
      break;
    }
      }
      if(getNextCollision) break;
    }
  }
 
  // now remove the collisions
  for(collIter = toRemove.begin(); collIter != toRemove.end(); ++collIter)
  {
    collision = *collIter;
    collIter2 = std::find(theCollisionList->begin(),
                theCollisionList->end(), collision);
    theCollisionList->erase(collIter2);  // remove from list...
    delete collision;                    // ...and delete the collision
  }
}

---

The documentation for this class was generated from the following files:

• G4CollisionManager.hh
• G4CollisionManager.cc