Geant4-11
G4CollisionManager.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26
27#include <typeinfo>
28
29#include "G4CollisionManager.hh"
30#include "G4SystemOfUnits.hh"
33#include "G4BCAction.hh"
34
36{
38}
39
40
42{
44 delete theCollisionList;
45}
46
47
49 G4KineticTrack * target)
50
51{
52 if ( time < DBL_MAX )
53 {
55 collision = new G4CollisionInitialState(time, proj, target);
56 theCollisionList->push_back(collision);
57 } else {
58 G4cerr << "G4Scatterer invalid TimeTo Interaction : " << time;
59 G4cerr <<" projectile "<<proj->Get4Momentum()<<" "
61 if (target) G4cerr <<" target "
62 <<target->Get4Momentum()<<" "
63 <<target->GetDefinition()->GetParticleName()<<G4endl;
64 G4cerr <<"G4Scatterer error message end"<< G4endl;
65 throw G4HadronicException(__FILE__, __LINE__, "G4Scatterer::AddCollision()");
66 }
67}
68
69
71{
72 theCollisionList->erase(std::find(theCollisionList->begin(),
73 theCollisionList->end(),
74 collision));
75 delete collision;
76 collision = NULL; // prevent future use of the pointer
77}
78
79
81{
82 if(toBeCaned == NULL)
83 return;
84 if(toBeCaned->empty())
85 return;
86
87 G4CollisionInitialState * collision;
88 std::vector<G4CollisionInitialState *>::iterator collIter, collIter2;
89 std::vector<G4KineticTrack *>::iterator trackIter;
90 G4ListOfCollisions toRemove;
91
92 for(collIter = theCollisionList->begin();
93 collIter != theCollisionList->end(); collIter++)
94 {
95 collision = *collIter;
96 G4KineticTrackVector & targets = collision->GetTargetCollection();
97 G4bool getNextCollision = false;
98 for(trackIter = toBeCaned->begin(); trackIter != toBeCaned->end(); ++trackIter)
99 {
100 if((collision->GetTarget() == *trackIter) ||
101 (collision->GetPrimary() == *trackIter))
102 { // cannot remove the collision from the list inside the loop. Save and do it later
103 toRemove.push_back(collision);
104 break; // exit from the "trackIter" loop
105 }
106 for(size_t tcount=0; tcount<targets.size(); tcount++)
107 {
108 if(targets[tcount] == *trackIter)
109 {
110 toRemove.push_back(collision);
111 getNextCollision = true;
112 break;
113 }
114 }
115 if(getNextCollision) break;
116 }
117 }
118
119 // now remove the collisions
120 for(collIter = toRemove.begin(); collIter != toRemove.end(); ++collIter)
121 {
122 collision = *collIter;
123 collIter2 = std::find(theCollisionList->begin(),
124 theCollisionList->end(), collision);
125 theCollisionList->erase(collIter2); // remove from list...
126 delete collision; // ...and delete the collision
127 }
128}
129
130
132{
133 std::vector<G4CollisionInitialState *>::iterator i;
134 for(i = theCollisionList->begin(); i != theCollisionList->end(); ++i)
135 delete *i;
136 theCollisionList->clear();
137}
138
139
141{
142 G4CollisionInitialState * theNext=0;
143 G4double nextTime = DBL_MAX;
144 std::vector<G4CollisionInitialState *>::iterator i;
145 for(i = theCollisionList->begin(); i != theCollisionList->end(); ++i)
146 {
147 if(nextTime > (*i)->GetCollisionTime())
148 {
149 nextTime = (*i)->GetCollisionTime();
150 theNext = *i;
151 }
152 }
153 #ifdef debug_G4CollisionManager
154 if(theNext == 0 && theCollisionList->size()!=0)
155 {
156 G4double debugTime = DBL_MAX;
157 G4cerr <<"G4CollisionManager::GetNextCollision - Fatal"<<G4endl;
158 G4cerr <<" number of collisions left "<<theCollisionList->size()<<G4endl;
159 for(i = theCollisionList->begin(); i != theCollisionList->end(); ++i)
160 {
161 G4cerr <<" Time to collision "<<(*i)->GetCollisionTime()<<" "<<G4endl;
162 G4cerr <<" projectile "<<(*i)->GetPrimary()->Get4Momentum()<<" "
163 <<(*i)->GetPrimary()->GetDefinition()->GetParticleName()<<G4endl;
164 if ((*i)->GetTarget()) G4cerr <<" target "<<(*i)->GetTarget()->Get4Momentum()<<" "
165 <<(*i)->GetTarget()->GetDefinition()->GetParticleName()<<G4endl;
166 }
167 G4cerr <<"G4CollisionManager::GetNextCollision - End of message"<<G4endl;
168 }
169 #endif
170
171 return theNext;
172}
173
174
176{
177 std::vector<G4CollisionInitialState *>::iterator i;
178
179 G4cout << "CollisionManager: " << theCollisionList->size()
180 << " entries at " << theCollisionList << G4endl;
181 G4CollisionInitialState * collision;
182 for(i = theCollisionList->begin(); i != theCollisionList->end(); ++i)
183 {
184 collision = *i;
185 G4int tgtPdg=collision->GetTarget() ?
186 collision->GetTarget()->GetDefinition()->GetPDGEncoding() : 0;
187 const G4BCAction &action= *collision->GetGenerator();
188 G4cout << " collision " << collision << " time: "
189 << collision->GetCollisionTime()/second << " proj: "
190 << collision->GetPrimary() << "/pdg="
191 << collision->GetPrimary()->GetDefinition()->GetPDGEncoding()
192 << " trgt: "
193 << collision->GetTarget() << "/pdg="
194 << tgtPdg
195 << " Collision type: "<< typeid(action).name()
196 << G4endl;
197 }
198}
std::vector< G4CollisionInitialState * > G4ListOfCollisions
static constexpr double second
Definition: G4SIunits.hh:137
double G4double
Definition: G4Types.hh:83
bool G4bool
Definition: G4Types.hh:86
int G4int
Definition: G4Types.hh:85
G4GLOB_DLL std::ostream G4cerr
#define G4endl
Definition: G4ios.hh:57
G4GLOB_DLL std::ostream G4cout
G4KineticTrackVector & GetTargetCollection(void)
const G4BCAction * GetGenerator()
G4KineticTrack * GetTarget(void)
G4KineticTrack * GetPrimary(void)
void RemoveCollision(G4CollisionInitialState *collision)
void RemoveTracksCollisions(G4KineticTrackVector *ktv)
void AddCollision(G4double time, G4KineticTrack *proj, G4KineticTrack *target=NULL)
G4CollisionInitialState * GetNextCollision()
G4ListOfCollisions * theCollisionList
const G4ParticleDefinition * GetDefinition() const
const G4LorentzVector & Get4Momentum() const
const G4String & GetParticleName() const
const char * name(G4int ptype)
#define DBL_MAX
Definition: templates.hh:62