| 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 // $Id$
>> 28 // GEANT4 tag $Name: $
27 // 29 //
28 <<
29 // ------------------------------------------- 30 // ------------------------------------------------------------
30 // GEANT 4 class implementation file 31 // GEANT 4 class implementation file
31 // 32 //
32 // ---------------- G4FTFParticipants---- 33 // ---------------- G4FTFParticipants----------------
33 // by Gunter Folger, June 1998. 34 // by Gunter Folger, June 1998.
34 // class finding colliding particles in 35 // class finding colliding particles in FTFPartonStringModel
35 // Changed in a part by V. Uzhinsky in oder t 36 // Changed in a part by V. Uzhinsky in oder to put in correcpondence
36 // with original FRITIOF mode. November 37 // with original FRITIOF mode. November - December 2006.
37 // Ajusted for (anti) nucleus - nucleus inter 38 // Ajusted for (anti) nucleus - nucleus interactions by V. Uzhinsky.
38 // (February 2011) 39 // (February 2011)
39 // ------------------------------------------- 40 // ------------------------------------------------------------
40 41
41 #include <utility> 42 #include <utility>
42 #include <vector> 43 #include <vector>
43 #include <algorithm> 44 #include <algorithm>
44 45
45 #include "G4FTFParticipants.hh" 46 #include "G4FTFParticipants.hh"
46 #include "G4ios.hh" 47 #include "G4ios.hh"
47 #include "Randomize.hh" 48 #include "Randomize.hh"
48 #include "G4SystemOfUnits.hh" 49 #include "G4SystemOfUnits.hh"
49 #include "G4FTFParameters.hh" << 50 #include "G4FTFParameters.hh" // Uzhi 29.03.08
50 #include "G4DiffractiveSplitableHadron.hh" 51 #include "G4DiffractiveSplitableHadron.hh"
51 #include "G4VSplitableHadron.hh" 52 #include "G4VSplitableHadron.hh"
52 #include "G4PhysicalConstants.hh" <<
53 <<
54 <<
55 //============================================ <<
56 <<
57 //#define debugFTFparticipant <<
58 <<
59 <<
60 //============================================ <<
61 <<
62 G4FTFParticipants::G4FTFParticipants() : Bimpa <<
63 Bmin2 <<
64 curre <<
65 {} <<
66 <<
67 <<
68 //============================================ <<
69 <<
70 G4FTFParticipants::~G4FTFParticipants() {} <<
71 <<
72 //============================================ <<
73 <<
74 void G4FTFParticipants::GetList( const G4React <<
75 G4FTFParamete <<
76 <<
77 #ifdef debugFTFparticipant <<
78 G4cout << "Participants::GetList" << G4endl <<
79 << "thePrimary " << thePrimary.GetMom <<
80 #endif <<
81 <<
82 G4double betta_z = thePrimary.GetMomentum(). <<
83 if ( betta_z < 1.0e-10 ) betta_z = 1.0e-10; <<
84 <<
85 StartLoop(); // reset Loop over Interactions <<
86 <<
87 for ( unsigned int i = 0; i < theInteraction <<
88 theInteractions.clear(); <<
89 <<
90 G4double deltaxy = 2.0 * fermi; // Extra nu <<
91 <<
92 if ( theProjectileNucleus == nullptr ) { // <<
93 <<
94 G4double impactX( 0.0 ), impactY( 0.0 ); <<
95 G4double B( 0.0 ), B2( 0.0 ); <<
96 <<
97 G4VSplitableHadron* primarySplitable = new <<
98 <<
99 #ifdef debugFTFparticipant <<
100 G4cout << "Hadron-nucleus or anti-baryon-n <<
101 #endif <<
102 <<
103 G4double xyradius = theNucleus->GetOuterRa <<
104 <<
105 const G4int maxNumberOfLoops = 1000; <<
106 G4int loopCounter = 0; <<
107 do { <<
108 <<
109 std::pair< G4double, G4double > theImpac <<
110 if ( SampleBinInterval() ) { <<
111 B2 = GetBmin2() + G4UniformRand() * ( <<
112 B = B2 > 0.0 ? std::sqrt( B2 ) : 0.0; <<
113 G4double Phi = twopi * G4UniformRand() <<
114 impactX = B * std::cos( Phi ); <<
115 impactY = B * std::sin( Phi ); <<
116 SetImpactParameter( B ); <<
117 } else { <<
118 theImpactParameter = theNucleus->Choos <<
119 impactX = theImpactParameter.first; <<
120 impactY = theImpactParameter.second; <<
121 SetImpactParameter( std::sqrt( sqr(imp <<
122 } <<
123 <<
124 #ifdef debugFTFparticipant <<
125 G4cout << "New interaction list," << " b <<
126 << std::sqrt( sqr(impactX ) + sqr <<
127 #endif <<
128 <<
129 G4ThreeVector thePosition( impactX, impa <<
130 primarySplitable->SetPosition( thePositi <<
131 53
132 theNucleus->StartLoop(); << 54 G4FTFParticipants::G4FTFParticipants() :
133 G4Nucleon* nucleon; << 55 theProjectileNucleus(0),
134 << 56 currentInteraction(-1)
135 #ifdef debugFTFparticipant << 57 {
136 G4int TrN( 0 ); <<
137 #endif <<
138 <<
139 while ( ( nucleon = theNucleus->GetNextN <<
140 <<
141 G4double impact2 = sqr( impactX - nucl <<
142 sqr( impactY - nucl <<
143 <<
144 if ( theParameters->GetProbabilityOfIn <<
145 G4UniformRand() ) { <<
146 primarySplitable->SetStatus( 1 ); / <<
147 G4VSplitableHadron* targetSplitable <<
148 if ( ! nucleon->AreYouHit() ) { <<
149 targetSplitable = new G4Diffractiv <<
150 nucleon->Hit( targetSplitable ); <<
151 targetSplitable->SetStatus( 1 ); / <<
152 <<
153 #ifdef debugFTFparticipant <<
154 G4cout << "Participated nucleons # <<
155 << primarySplitable << " " <<
156 #endif <<
157 <<
158 } <<
159 G4InteractionContent* aInteraction = <<
160 G4Nucleon* PrNucleon = 0; <<
161 aInteraction->SetProjectileNucleon( <<
162 aInteraction->SetTarget( targetSplit <<
163 aInteraction->SetTargetNucleon( nucl <<
164 aInteraction->SetStatus( 1 ); <<
165 aInteraction->SetInteractionTime( ( <<
166 <<
167 theInteractions.push_back( aInteract <<
168 } <<
169 <<
170 #ifdef debugFTFparticipant <<
171 TrN++; <<
172 #endif <<
173 <<
174 } <<
175 <<
176 } while ( ( theInteractions.size() == 0 ) <<
177 ++loopCounter < maxNumberOfLoops <<
178 if ( loopCounter >= maxNumberOfLoops ) { <<
179 #ifdef debugFTFparticipant <<
180 G4cout << "BAD situation: forced exit fr <<
181 #endif <<
182 return; <<
183 } <<
184 <<
185 #ifdef debugFTFparticipant <<
186 G4cout << "Number of Hit nucleons " << the <<
187 << "\t By[fm] " << impactY/fermi << <<
188 << std::sqrt( sqr( impactX ) + sqr( <<
189 #endif <<
190 <<
191 //SortInteractionsIncT(); // Not need beca <<
192 ShiftInteractionTime(); // To put correct <<
193 return; <<
194 <<
195 } // end of if ( theProjectileNucleus == 0 <<
196 <<
197 // Projectile and target are nuclei <<
198 <<
199 #ifdef debugFTFparticipant <<
200 G4cout << "Projectile and target are nuclei" <<
201 #endif <<
202 <<
203 //G4cout<<theProjectileNucleus->GetOuterRadi <<
204 <<
205 // Range of impact parameter sampling <<
206 G4double xyradius = theProjectileNucleus->Ge <<
207 <<
208 G4double impactX( 0.0 ), impactY( 0.0 ); <<
209 G4double B( 0.0 ), B2( 0.0 ); <<
210 <<
211 const G4int maxNumberOfLoops = 1000; <<
212 G4int loopCounter = 0; <<
213 do { <<
214 <<
215 std::pair< G4double, G4double > theImpactP <<
216 if ( SampleBinInterval() ) { <<
217 B2 = GetBmin2() + G4UniformRand() * ( Ge <<
218 B = B2 > 0.0 ? std::sqrt( B2 ) : 0.0; <<
219 G4double Phi = twopi * G4UniformRand(); <<
220 impactX = B * std::cos( Phi ); <<
221 impactY = B * std::sin( Phi ); <<
222 SetImpactParameter( B ); <<
223 } else { <<
224 theImpactParameter = theNucleus->ChooseI <<
225 impactX = theImpactParameter.first; <<
226 impactY = theImpactParameter.second; <<
227 SetImpactParameter( std::sqrt( sqr(impac <<
228 } <<
229 <<
230 #ifdef debugFTFparticipant <<
231 G4cout << "New interaction list, " << "b[f <<
232 << std::sqrt( sqr( impactX ) + sqr( <<
233 #endif <<
234 <<
235 G4ThreeVector theBeamPosition( impactX, im <<
236 <<
237 theProjectileNucleus->StartLoop(); <<
238 G4Nucleon* ProjectileNucleon; <<
239 <<
240 #ifdef debugFTFparticipant <<
241 G4int PrNuclN( 0 ); <<
242 #endif <<
243 <<
244 while ( ( ProjectileNucleon = theProjectil <<
245 <<
246 G4VSplitableHadron* ProjectileSplitable <<
247 theNucleus->StartLoop(); <<
248 G4Nucleon* TargetNucleon = 0; <<
249 <<
250 #ifdef debugFTFparticipant <<
251 G4int TrNuclN( 0 ); <<
252 #endif <<
253 <<
254 while ( ( TargetNucleon = theNucleus->Ge <<
255 <<
256 G4double impact2 = sqr( impactX + Proj <<
257 TargetNucleon- <<
258 sqr( impactY + Proj <<
259 TargetNucleon- <<
260 G4VSplitableHadron* TargetSplitable = <<
261 if ( theParameters->GetProbabilityOfIn <<
262 G4UniformRand() ) { // An intera <<
263 <<
264 #ifdef debugFTFparticipant <<
265 G4cout << G4endl << "An Interaction <<
266 << " " << ProjectileNucleon-> <<
267 << "Targ N mom " << TrNuclN < <<
268 << "PrN TrN Z coords [fm]" << <<
269 << " " << TargetNucleon->GetP <<
270 << " " << ProjectileNucleon-> <<
271 TargetNucleon->GetP <<
272 #endif <<
273 <<
274 if ( ! ProjectileNucleon->AreYouHit( <<
275 // Projectile nucleon was not invo <<
276 ProjectileSplitable = new G4Diffra <<
277 ProjectileNucleon->Hit( Projectile <<
278 ProjectileSplitable->SetStatus( 1 <<
279 } else { // Projectile nucleon was <<
280 ProjectileSplitable = ProjectileNu <<
281 } <<
282 <<
283 if ( ! TargetNucleon->AreYouHit() ) <<
284 TargetSplitable = new G4Diffractiv <<
285 TargetNucleon->Hit( TargetSplitabl <<
286 TargetSplitable->SetStatus( 1 ); <<
287 } else { // Target nucleon was invo <<
288 TargetSplitable = TargetNucleon->G <<
289 } <<
290 <<
291 G4InteractionContent* anInteraction <<
292 anInteraction->SetTarget( TargetSpli <<
293 anInteraction->SetProjectileNucleon( <<
294 anInteraction->SetTargetNucleon( Tar <<
295 anInteraction->SetInteractionTime( ( <<
296 <<
297 anInteraction->SetStatus( 1 ); <<
298 <<
299 #ifdef debugFTFparticipant <<
300 G4cout << "Part anInteraction->GetIn <<
301 << anInteraction->GetInteract <<
302 << "Splitable Pr* Tr* " << Pr <<
303 << TargetSplitable << G4endl; <<
304 #endif <<
305 <<
306 theInteractions.push_back( anInterac <<
307 <<
308 } // End of an Interaction has happend <<
309 <<
310 #ifdef debugFTFparticipant <<
311 TrNuclN++; <<
312 #endif <<
313 <<
314 } // End of while ( ( TargetNucleon = t <<
315 <<
316 #ifdef debugFTFparticipant <<
317 PrNuclN++; <<
318 #endif <<
319 <<
320 } // End of while ( ( ProjectileNucleon = <<
321 <<
322 if ( theInteractions.size() != 0 ) theProj <<
323 <<
324 } while ( ( theInteractions.size() == 0 ) && <<
325 ++loopCounter < maxNumberOfLoops ) <<
326 if ( loopCounter >= maxNumberOfLoops ) { <<
327 #ifdef debugFTFparticipant <<
328 G4cout << "BAD situation: forced exit from <<
329 #endif <<
330 return; <<
331 } <<
332 <<
333 SortInteractionsIncT(); <<
334 ShiftInteractionTime(); <<
335 <<
336 #ifdef debugFTFparticipant <<
337 G4cout << G4endl << "Number of primary colli <<
338 << "\t Bx[fm] " << impactX/fermi << " <<
339 << "\t B[fm] " << std::sqrt( sqr( imp <<
340 << "FTF participant End. ############ <<
341 #endif <<
342 return; <<
343 } 58 }
344 59
345 << 60 G4FTFParticipants::G4FTFParticipants(const G4FTFParticipants &): G4VParticipants()
346 //============================================ << 61 , theProjectileNucleus(0), currentInteraction(-1) //A.R. 14-Aug-2012 Coverity fix.
347 << 62 {
348 bool G4FTFPartHelperForSortInT( const G4Intera << 63 G4Exception("G4FTFParticipants::G4FTFParticipants()","HAD_FTF_001",
349 const G4Intera << 64 FatalException," Must not use copy ctor()");
350 return Int1->GetInteractionTime() < Int2->Ge <<
351 } 65 }
352 66
353 67
354 //============================================ << 68 G4FTFParticipants::~G4FTFParticipants()
355 << 69 {
356 void G4FTFParticipants::SortInteractionsIncT() << 70 if ( theProjectileNucleus != NULL ) delete theProjectileNucleus;
357 if ( theInteractions.size() < 2 ) return; / <<
358 std::sort( theInteractions.begin(), theInter <<
359 } 71 }
360 72
>> 73 //-------------------------------------------------------------------------
361 74
362 //============================================ << 75 void G4FTFParticipants::SetProjectileNucleus(G4V3DNucleus * aNucleus)
363 << 76 {
364 void G4FTFParticipants::ShiftInteractionTime() << 77 if (theProjectileNucleus) delete theProjectileNucleus;
365 G4double InitialTime = theInteractions[0]->G << 78
366 for ( unsigned int i = 1; i < theInteraction << 79 theProjectileNucleus = aNucleus;
367 G4double InterTime = theInteractions[i]->G <<
368 theInteractions[i]->SetInteractionTime( In <<
369 G4InteractionContent* aCollision = theInte <<
370 G4VSplitableHadron* projectile = aCollisio <<
371 G4VSplitableHadron* target = aCollision->G <<
372 G4ThreeVector prPosition = projectile->Get <<
373 prPosition.setZ( target->GetPosition().z() <<
374 projectile->SetPosition( prPosition ); <<
375 projectile->SetTimeOfCreation( InterTime ) <<
376 target->SetTimeOfCreation( InterTime ); <<
377 } <<
378 return; <<
379 } 80 }
380 81
>> 82 G4V3DNucleus * G4FTFParticipants::GetProjectileNucleus()
>> 83 {
>> 84 return theProjectileNucleus;
>> 85 }
381 86
382 //============================================ << 87 void G4FTFParticipants::InitProjectileNucleus(G4int theA, G4int theZ)
383 << 88 {
384 void G4FTFParticipants::Clean() { << 89 if ( theProjectileNucleus == NULL ) theProjectileNucleus = new G4Fancy3DNucleus();
385 for ( size_t i = 0; i < theInteractions.size << 90 theProjectileNucleus->Init(theA, theZ);
386 if ( theInteractions[ i ] ) { << 91 theProjectileNucleus->SortNucleonsDecZ();
387 delete theInteractions[ i ]; << 92 }
388 theInteractions[ i ] = 0; << 93 //-------------------------------------------------------------------------
389 } << 94 void G4FTFParticipants::GetList(const G4ReactionProduct &thePrimary,
390 } << 95 G4FTFParameters *theParameters)
391 theInteractions.clear(); << 96 {
392 currentInteraction = -1; << 97 //G4cout<<"Participants::GetList"<<G4endl;
>> 98 //G4cout<<"thePrimary "<<thePrimary.GetMomentum()<<G4endl;
>> 99 StartLoop(); // reset Loop over Interactions
>> 100
>> 101 for(unsigned int i=0; i<theInteractions.size(); i++) delete theInteractions[i];
>> 102 theInteractions.clear();
>> 103
>> 104 G4double deltaxy=2 * fermi; // Extra nuclear radius
>> 105 //G4cout<<"theProjectileNucleus "<<theProjectileNucleus<<G4endl;
>> 106 if(theProjectileNucleus == 0)
>> 107 { // Hadron-nucleus or anti-baryon-nucleus interactions
>> 108 //G4cout<<"Hadron-nucleus or anti-baryon-nucleus interactions"<<G4endl;
>> 109
>> 110 G4double impactX(0.), impactY(0.);
>> 111
>> 112 G4VSplitableHadron * primarySplitable=new G4DiffractiveSplitableHadron(thePrimary);
>> 113 //G4cout<<"Prim in Part "<<primarySplitable->Get4Momentum()<<G4endl;
>> 114 G4double xyradius;
>> 115 xyradius =theNucleus->GetOuterRadius() + deltaxy; // Impact parameter sampling
>> 116
>> 117 // G4bool nucleusNeedsShift = true; // Uzhi 20 July 2009
>> 118
>> 119 do
>> 120 {
>> 121 std::pair<G4double, G4double> theImpactParameter;
>> 122 theImpactParameter = theNucleus->ChooseImpactXandY(xyradius);
>> 123 impactX = theImpactParameter.first;
>> 124 impactY = theImpactParameter.second;
>> 125
>> 126 G4ThreeVector thePosition(impactX, impactY, -DBL_MAX);
>> 127 primarySplitable->SetPosition(thePosition);
>> 128
>> 129 theNucleus->StartLoop();
>> 130 G4Nucleon * nucleon;
>> 131
>> 132 G4int TrN(0);
>> 133 while ( (nucleon=theNucleus->GetNextNucleon()) )
>> 134 {
>> 135 G4double impact2= sqr(impactX - nucleon->GetPosition().x()) +
>> 136 sqr(impactY - nucleon->GetPosition().y());
>> 137
>> 138 if ( theParameters->GetProbabilityOfInteraction(impact2/fermi/fermi)
>> 139 > G4UniformRand() )
>> 140 {
>> 141 primarySplitable->SetStatus(1); // It takes part in the interaction
>> 142
>> 143 G4VSplitableHadron * targetSplitable=0;
>> 144 if ( ! nucleon->AreYouHit() )
>> 145 {
>> 146 targetSplitable= new G4DiffractiveSplitableHadron(*nucleon);
>> 147 nucleon->Hit(targetSplitable);
>> 148 nucleon->SetBindingEnergy(3.*nucleon->GetBindingEnergy());
>> 149 //G4cout<<" Part nucl "<<TrN<<" "<<nucleon->Get4Momentum()<<G4endl;
>> 150 //G4cout<<" Part nucl "<<G4endl;
>> 151 targetSplitable->SetStatus(1); // It takes part in the interaction
>> 152 }
>> 153 G4InteractionContent * aInteraction =
>> 154 new G4InteractionContent(primarySplitable);
>> 155 aInteraction->SetTarget(targetSplitable);
>> 156 aInteraction->SetTargetNucleon(nucleon); // Uzhi 16.07.09
>> 157 aInteraction->SetStatus(1); // Uzhi Feb26
>> 158 theInteractions.push_back(aInteraction);
>> 159 }
>> 160 TrN++;
>> 161 }
>> 162 } while ( theInteractions.size() == 0 );
>> 163
>> 164 //if ( theInteractions.size() == 0 ) delete primarySplitable; //A.R. 14-Aug-2012 Coverity fix
>> 165
>> 166 // G4cout << "Number of Hit nucleons " << theInteractions.size()
>> 167 // << "\t" << impactX/fermi << "\t"<<impactY/fermi
>> 168 // << "\t" << std::sqrt(sqr(impactX)+sqr(impactY))/fermi <<G4endl;
>> 169
>> 170 return;
>> 171 } // end of if(theProjectileNucleus == 0)
>> 172
>> 173 //-------------------------------------------------------------------
>> 174 // Projectile and target are nuclei
>> 175 //-------------------------------------------------------------------
>> 176 //VU G4VSplitableHadron * primarySplitable=new G4DiffractiveSplitableHadron(thePrimary);
>> 177 //G4cout<<"Prim in Part "<<primarySplitable->Get4Momentum()<<G4endl;
>> 178 //G4cout<<"Projectile and target are nuclei"<<G4endl;
>> 179 //G4cout<<thePrimary.GetMomentum()<<G4endl;
>> 180 //G4cout<<"Part Pr Tr "<<theProjectileNucleus<<" "<<theNucleus<<G4endl;
>> 181
>> 182
>> 183 G4double xyradius;
>> 184 xyradius =theProjectileNucleus->GetOuterRadius() + // Impact parameter sampling
>> 185 theNucleus->GetOuterRadius() + deltaxy;
>> 186
>> 187 G4double impactX(0.), impactY(0.);
>> 188
>> 189 do
>> 190 {
>> 191 //G4cout<<"New interaction list"<<G4endl;
>> 192 std::pair<G4double, G4double> theImpactParameter;
>> 193 theImpactParameter = theNucleus->ChooseImpactXandY(xyradius);
>> 194 impactX = theImpactParameter.first;
>> 195 impactY = theImpactParameter.second;
>> 196 //G4cout<<"B "<<std::sqrt(sqr(impactX)+sqr(impactY))/fermi<<G4endl;
>> 197
>> 198 G4ThreeVector thePosition(impactX, impactY, -DBL_MAX);
>> 199 //VU primarySplitable->SetPosition(thePosition);
>> 200
>> 201 theProjectileNucleus->StartLoop();
>> 202 G4Nucleon * ProjectileNucleon;
>> 203 G4int PrNuclN(0);
>> 204
>> 205 while ( (ProjectileNucleon=theProjectileNucleus->GetNextNucleon()) )
>> 206 {
>> 207 G4VSplitableHadron * ProjectileSplitable=0;
>> 208 //G4cout<<G4endl<<"Prj N mom "<<ProjectileNucleon->Get4Momentum()<<"-------------"<<G4endl;
>> 209 theNucleus->StartLoop();
>> 210 G4Nucleon * TargetNucleon;
>> 211
>> 212 G4int TrNuclN(0);
>> 213 while ( (TargetNucleon=theNucleus->GetNextNucleon()) )
>> 214 {
>> 215 //G4cout<<"Trg N mom "<<TargetNucleon->Get4Momentum()<<G4endl;
>> 216 G4double impact2=
>> 217 sqr(impactX+ProjectileNucleon->GetPosition().x()-TargetNucleon->GetPosition().x())+
>> 218 sqr(impactY+ProjectileNucleon->GetPosition().y()-TargetNucleon->GetPosition().y());
>> 219
>> 220 G4VSplitableHadron * TargetSplitable=0;
>> 221
>> 222 if ( theParameters->GetProbabilityOfInteraction(impact2/fermi/fermi)
>> 223 > G4UniformRand() )
>> 224 { // An Interaction has happend!
>> 225 //G4cout<<"An Interaction has happend"<<G4endl;
>> 226 //G4cout<<"PrN TrN "<<PrNuclN<<" "<<TrNuclN<<" "<<ProjectileNucleon->GetPosition().z()/fermi<<" "<<TargetNucleon->GetPosition().z()/fermi<<" "<<ProjectileNucleon->GetPosition().z()/fermi + TargetNucleon->GetPosition().z()/fermi <<G4endl;
>> 227
>> 228 if ( ! ProjectileNucleon->AreYouHit() )
>> 229 { // Projectile nucleon was not involved until now.
>> 230 ProjectileSplitable= new G4DiffractiveSplitableHadron(*ProjectileNucleon);
>> 231 ProjectileNucleon->Hit(ProjectileSplitable);
>> 232 ProjectileNucleon->SetBindingEnergy(3.*ProjectileNucleon->GetBindingEnergy());
>> 233 ProjectileSplitable->SetStatus(1); // It takes part in the interaction
>> 234 }
>> 235 else
>> 236 { // Projectile nucleon was involved before.
>> 237 ProjectileSplitable=ProjectileNucleon->GetSplitableHadron();
>> 238 } // End of if ( ! Projectileucleon->AreYouHit() )
>> 239
>> 240 if ( ! TargetNucleon->AreYouHit() )
>> 241 { // Target nucleon was not involved until now
>> 242 TargetSplitable= new G4DiffractiveSplitableHadron(*TargetNucleon);
>> 243 TargetNucleon->Hit(TargetSplitable);
>> 244 TargetNucleon->SetBindingEnergy(3.*ProjectileNucleon->GetBindingEnergy());
>> 245 TargetSplitable->SetStatus(1); // It takes part in the interaction
>> 246 }
>> 247 else
>> 248 { // Target nucleon was involved before.
>> 249 TargetSplitable=TargetNucleon->GetSplitableHadron();
>> 250 } // End of if ( ! TargetNeucleon->AreYouHit() )
>> 251
>> 252 G4InteractionContent * anInteraction =
>> 253 new G4InteractionContent(ProjectileSplitable);
>> 254 anInteraction->SetTarget(TargetSplitable);
>> 255 anInteraction->SetTargetNucleon(TargetNucleon);
>> 256 anInteraction->SetStatus(1); // Uzhi Feb26
>> 257 // anInteraction->SetInteractionTime(ProjectileNucleon->GetPosition().z()+
>> 258 // TargetNucleon->GetPosition().z());
>> 259 //G4cout<<"Z's pr tr "<<ProjectileNucleon->GetPosition().z()/fermi<<" "<<TargetNucleon->GetPosition().z()/fermi<<" "<<ProjectileNucleon->GetPosition().z()/fermi + TargetNucleon->GetPosition().z()/fermi <<G4endl;
>> 260 theInteractions.push_back(anInteraction);
>> 261 //G4cout<<"Ppr tr "<<ProjectileSplitable<<" "<<TargetSplitable<<G4endl;
>> 262 } // End of An Interaction has happend!
>> 263 TrNuclN++;
>> 264 } // End of while ( (TargetNucleon=theNucleus->GetNextNucleon()) )
>> 265 PrNuclN++;
>> 266 } // End of while ( (ProjectileNucleon=theProjectileNucleus->GetNextNucleon()) )
>> 267 } while ( theInteractions.size() == 0 ); // end of while ( theInteractions.size() == 0 )
>> 268
>> 269 //std::sort(theInteractions.begin(),theInteractions.end()); // ????
>> 270
>> 271 // G4cout << "Number of primary collisions " << theInteractions.size()
>> 272 // << "\t" << impactX/fermi << "\t"<<impactY/fermi
>> 273 // << "\t" << std::sqrt(sqr(impactX)+sqr(impactY))/fermi <<G4endl;
>> 274 //G4int Uzhi; G4cin >> Uzhi;
>> 275 return;
393 } 276 }
>> 277 //--------------------------------------------------------------
394 278
>> 279 // Implementation (private) methods
395 280