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