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.

{
  theCollisionList = new G4ListOfCollisions;
}

G4CollisionManager::~G4CollisionManager

(

)

Definition at line 41 of file G4CollisionManager.cc.

References ClearAndDestroy().

{
  ClearAndDestroy();
  delete theCollisionList;
}

Member Function Documentation

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().

{
      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()");
      }
}

void G4CollisionManager::AddCollision ( G4CollisionInitialState *  collision )

inline

Definition at line 45 of file G4CollisionManager.hh.

  {
    theCollisionList->push_back(collision);
  }

void G4CollisionManager::ClearAndDestroy

(

)

Definition at line 131 of file G4CollisionManager.cc.

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

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

G4int G4CollisionManager::Entries ( )

inline

Definition at line 65 of file G4CollisionManager.hh.

Referenced by G4BinaryCascade::Propagate().

{
  return theCollisionList->size();
}

G4CollisionInitialState * G4CollisionManager::GetNextCollision

(

)

Definition at line 140 of file G4CollisionManager.cc.

References DBL_MAX, G4cerr, and G4endl.

Referenced by G4BinaryCascade::Propagate().

{
  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;
}

void G4CollisionManager::Print

(

void

)

Definition at line 175 of file G4CollisionManager.cc.

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

{
  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;
  }
}

void G4CollisionManager::RemoveCollision

(

G4CollisionInitialState *

collision

)

Definition at line 70 of file G4CollisionManager.cc.

Referenced by G4BinaryCascade::Propagate().

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

void G4CollisionManager::RemoveTracksCollisions

(

G4KineticTrackVector *

ktv

)

Definition at line 80 of file G4CollisionManager.cc.

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

{
  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