Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4FTFModel.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// $Id$
28// GEANT4 tag $Name: $
29//
30
31// ------------------------------------------------------------
32// GEANT 4 class implementation file
33//
34// ---------------- G4FTFModel ----------------
35// by Gunter Folger, May 1998.
36// class implementing the excitation in the FTF Parton String Model
37// ------------------------------------------------------------
38
39#include <utility>
40
41#include "G4FTFModel.hh"
42#include "G4ios.hh"
43#include "G4PhysicalConstants.hh"
44#include "G4SystemOfUnits.hh"
45#include "G4FTFParameters.hh"
46#include "G4FTFParticipants.hh"
47#include "G4DiffractiveSplitableHadron.hh"
48#include "G4InteractionContent.hh"
49#include "G4LorentzRotation.hh"
50#include "G4ParticleDefinition.hh"
51#include "G4ParticleTable.hh"
52#include "G4IonTable.hh"
53
54// Class G4FTFModel
55
56G4FTFModel::G4FTFModel(const G4String& modelName):G4VPartonStringModel(modelName),
57 theExcitation(new G4DiffractiveExcitation()),
58 theElastic(new G4ElasticHNScattering()),
59 theAnnihilation(new G4FTFAnnihilation())
60{
61 G4VPartonStringModel::SetThisPointer(this);
62 theParameters=0;
63 NumberOfInvolvedNucleon=0;
64 NumberOfInvolvedNucleonOfProjectile=0;
65 SetEnergyMomentumCheckLevels(2*perCent, 150*MeV);
66}
67
68struct DeleteVSplitableHadron { void operator()(G4VSplitableHadron * aH){ delete aH;} };
69
70G4FTFModel::~G4FTFModel()
71{
72// Because FTF model can be called for various particles
73// theParameters must be erased at the end of each call.
74// Thus the delete is also in G4FTFModel::GetStrings() method
75 if( theParameters != 0 ) delete theParameters;
76 if( theExcitation != 0 ) delete theExcitation;
77 if( theElastic != 0 ) delete theElastic;
78 if( theAnnihilation != 0 ) delete theAnnihilation;
79
80// Erasing of strings created at annihilation
81 if(theAdditionalString.size() != 0)
82 {
83 std::for_each(theAdditionalString.begin(), theAdditionalString.end(),
84 DeleteVSplitableHadron());
85 }
86 theAdditionalString.clear();
87
88// Erasing of target involved nucleons
89 if( NumberOfInvolvedNucleon != 0)
90 {
91 for(G4int i=0; i < NumberOfInvolvedNucleon; i++)
92 {
93 G4VSplitableHadron * aNucleon = TheInvolvedNucleon[i]->GetSplitableHadron();
94 if(aNucleon) delete aNucleon;
95 }
96 }
97
98// Erasing of projectile involved nucleons
99/*
100 if( NumberOfInvolvedNucleonOfProjectile != 0)
101 {
102 for(G4int i=0; i < NumberOfInvolvedNucleonOfProjectile; i++)
103 {
104 G4VSplitableHadron * aNucleon = TheInvolvedNucleonOfProjectile[i]->GetSplitableHadron();
105 if(aNucleon) delete aNucleon;
106 }
107 }
108*/
109}
110
111// ------------------------------------------------------------
112void G4FTFModel::Init(const G4Nucleus & aNucleus, const G4DynamicParticle & aProjectile)
113{
114 theProjectile = aProjectile;
115
116 G4double PlabPerParticle(0.); // Laboratory momentum Pz per particle/nucleon
117
118/*
119G4cout<<"FTF init Pro Name "<<theProjectile.GetDefinition()->GetParticleName()<<G4endl;
120G4cout<<"FTF init Pro Mass "<<theProjectile.GetMass()<<" "<<theProjectile.GetMomentum()<<G4endl;
121G4cout<<"FTF init Pro B Q "<<theProjectile.GetDefinition()->GetBaryonNumber()<<" "<<(G4int) theProjectile.GetDefinition()->GetPDGCharge()<<G4endl;
122G4cout<<"FTF init A Z "<<aNucleus.GetA_asInt()<<" "<<aNucleus.GetZ_asInt()<<G4endl;
123G4cout<<" "<<aNucleus.GetN()<<" "<<aNucleus.GetZ()<<G4endl;
124//G4int Uzhi; G4cin>>Uzhi;
125*/
126
127 theParticipants.SetProjectileNucleus(0);
128 theParticipants.Init(aNucleus.GetA_asInt(),aNucleus.GetZ_asInt());
129
130 if(std::abs(theProjectile.GetDefinition()->GetBaryonNumber()) <= 1)
131 { // Projectile is a hadron
132 PlabPerParticle=theProjectile.GetMomentum().z();
133
134// S = sqr( theProjectile.GetMass() ) + sqr( ProtonMass ) +
135// 2*ProtonMass*theProjectile.GetTotalEnergy();
136 }
137
138
139 if(theProjectile.GetDefinition()->GetBaryonNumber() > 1)
140 { // Projectile is a nucleus
141 theParticipants.InitProjectileNucleus(
142 theProjectile.GetDefinition()->GetBaryonNumber(),
143 (G4int) theProjectile.GetDefinition()->GetPDGCharge() );
144
145 G4ThreeVector BoostVector=theProjectile.GetMomentum()/theProjectile.GetTotalEnergy();
146 theParticipants.theProjectileNucleus->DoLorentzBoost(BoostVector);
147
148 PlabPerParticle=theProjectile.GetMomentum().z()/
149 theProjectile.GetDefinition()->GetBaryonNumber();
150
151// S = 2.*sqr( ProtonMass ) + 2*ProtonMass*
152// theProjectile.GetTotalEnergy()/theProjectile.GetDefinition()->GetBaryonNumber();
153 }
154
155 if(theProjectile.GetDefinition()->GetBaryonNumber() < -1)
156 { // Projectile is an anti-nucleus
157 theParticipants.InitProjectileNucleus(
158 std::abs( theProjectile.GetDefinition()->GetBaryonNumber()),
159 std::abs((G4int) theProjectile.GetDefinition()->GetPDGCharge()) );
160
161 G4ThreeVector BoostVector=theProjectile.GetMomentum()/theProjectile.GetTotalEnergy();
162
163 theParticipants.theProjectileNucleus->StartLoop();
164 G4Nucleon * aNucleon;
165 while ( (aNucleon = theParticipants.theProjectileNucleus->GetNextNucleon()) )
166 {
167 if(aNucleon->GetDefinition()->GetPDGEncoding() == 2212) // Proton
168 {aNucleon->SetParticleType(G4AntiProton::AntiProton());}
169
170 if(aNucleon->GetDefinition()->GetPDGEncoding() == 2112) // Neutron
171 {aNucleon->SetParticleType(G4AntiNeutron::AntiNeutron());}
172 } // end of while (theParticipant.theProjectileNucleus->GetNextNucleon())
173
174 theParticipants.theProjectileNucleus->DoLorentzBoost(BoostVector);
175
176 PlabPerParticle= theProjectile.GetMomentum().z()/
177 std::abs(theProjectile.GetDefinition()->GetBaryonNumber());
178
179// S = 2.*sqr( ProtonMass ) + 2*ProtonMass*
180// theProjectile.GetTotalEnergy()/
181// std::abs(theProjectile.GetDefinition()->GetBaryonNumber());
182 }
183
184// ------------------------------------------------------------------------
185 if( theParameters != 0 ) delete theParameters;
186 theParameters = new G4FTFParameters(theProjectile.GetDefinition(),
187 aNucleus.GetA_asInt(),aNucleus.GetZ_asInt(),
188 PlabPerParticle);
189//G4cout<<" End Init "<<theProjectile.GetMomentum()<<G4endl;
190// To turn on/off (1/0) elastic scattering close/open ...
191//theParameters->SetProbabilityOfElasticScatt(0.);
192//G4cout<<" etProbabilityOfElasticScatt "<<theParameters->GetProbabilityOfElasticScatt()<<G4endl;
193//G4cout<<" INIT ";
194//G4int Uzhi; G4cin>>Uzhi;
195
196 if(theAdditionalString.size() != 0)
197 {
198 std::for_each(theAdditionalString.begin(), theAdditionalString.end(),
199 DeleteVSplitableHadron());
200 }
201 theAdditionalString.clear();
202//G4cout<<" End Init theProjectile.GetMomentum()"<<theProjectile.GetMomentum()<<G4endl;
203}
204
205// ------------------------------------------------------------
206G4ExcitedStringVector * G4FTFModel::GetStrings()
207{
208 G4ExcitedStringVector * theStrings(0);
209
210 theParticipants.GetList(theProjectile,theParameters);
211// StoreInvolvedNucleon();
212//G4cout<<" GetList theProjectile.GetMomentum() GetBaryonNumber() "<<theProjectile.GetMomentum()<<" "<<theProjectile.GetDefinition()->GetBaryonNumber()<<G4endl;
213 G4bool Success(true);
214
215 if((std::abs(theProjectile.GetDefinition()->GetBaryonNumber()) <= 1) &&
216 (theProjectile.GetDefinition()->GetBaryonNumber() != -1) )
217 { // Standard variant of FTF for projectile hadron/nucleon
218//G4cout<<"Standard variant of FTF for projectile hadron/nucleon"<<G4endl;
219 ReggeonCascade();
220//G4cout<<"Success after Reggeon "<<Success<<" PutOnMasShell"<<G4endl;
221 Success=PutOnMassShell();
222//G4cout<<"Success after PutOn "<<Success<<" GetResid"<<G4endl;
223 GetResidualNucleus();
224 }
225//G4cout<<"Success after GetN "<<Success<<G4endl;
226//G4int Uzhi; G4cin>>Uzhi;
227 if(theProjectile.GetDefinition()->GetBaryonNumber() > 1)
228 { // Variant of FTF for projectile nuclei
229//G4cout<<"Variant of FTF for projectile nuclei"<<G4endl;
230 StoreInvolvedNucleon();
231 ReggeonCascade();
232 Success=PutOnMassShell();
233 GetResidualNucleus();
234 }
235
236// G4bool LowE_Anti_Ion(false);
237 if(theProjectile.GetDefinition()->GetBaryonNumber() <= -1)
238 { // Projectile is Anti-baryon or Anti-Nucleus
239//G4cout<<"Projectile is Anti-baryon or Anti-Nucleus "<<G4endl;
240//G4cout<<"Be4 Store"<<G4endl;
241 StoreInvolvedNucleon();
242 if(theProjectile.GetTotalMomentum()/
243 std::abs(theProjectile.GetDefinition()->GetBaryonNumber()) > 5000.*MeV)
244 {// High energy interaction
245//G4cout<<"High energy interaction "<<G4endl;
246//G4cout<<"Regeon "<<G4endl;
247 ReggeonCascade();
248//G4cout<<"Put on mass "<<G4endl;
249 Success=PutOnMassShell();
250//G4cout<<"Residual "<<G4endl;
251 GetResidualNucleus();
252 }
253 else
254 {
255//G4cout<<"Low energy interaction "<<G4endl;
256// LowE_Anti_Ion=true;
257 Success=true;
258 }
259 }
260//G4cout<<"Before Excite Success "<<Success<<G4endl;
261 Success=Success && ExciteParticipants();
262//G4cout<<"Success ExciteParticipants()? "<<Success<<G4endl;
263// if(LowE_Anti_Ion) Success=Success && GetResidualNucleusAfterAnnihilation();
264
265 if( Success )
266 {
267 theStrings = BuildStrings();
268//G4cout<<"BuildStrings OK"<<G4endl;
269 if( theParameters != 0 )
270 {
271 delete theParameters;
272 theParameters=0;
273 }
274 }
275/*
276 if( Success )
277 {
278 if( ExciteParticipants() )
279 {
280//G4cout<<"Excite partic OK"<<G4endl;
281 theStrings = BuildStrings();
282//G4cout<<"Build String OK"<<G4endl;
283 if(LowE_Anti_Ion) GetResidualNucleusAfterAnnihilation();
284
285 if( theParameters != 0 )
286 {
287 delete theParameters;
288 theParameters=0;
289 }
290 } else // if( ExciteParticipants() )
291 { Success=false;}
292 } else // if( Success )
293 { Success=false;}
294*/
295 if(!Success)
296 {
297 // -------------- Erase the projectile ----------------
298//G4cout<<"Erase Proj"<<G4endl;
299 std::vector<G4VSplitableHadron *> primaries;
300
301 theParticipants.StartLoop(); // restart a loop
302 while ( theParticipants.Next() )
303 {
304 const G4InteractionContent & interaction=theParticipants.GetInteraction();
305
306 // do not allow for duplicates ...
307 if ( primaries.end() == std::find(primaries.begin(), primaries.end(),
308 interaction.GetProjectile()) )
309 primaries.push_back(interaction.GetProjectile());
310 }
311 std::for_each(primaries.begin(), primaries.end(), DeleteVSplitableHadron());
312 primaries.clear();
313 }
314// -------------- Cleaning of the memory --------------
315 G4VSplitableHadron * aNucleon = 0;
316// -------------- Erase the projectile nucleon --------
317/*
318 G4VSplitableHadron * aNucleon = 0;
319 for(G4int i=0; i < NumberOfInvolvedNucleonOfProjectile; i++)
320 {
321 aNucleon = TheInvolvedNucleonOfProjectile[i]->GetSplitableHadron();
322 if(aNucleon) delete aNucleon;
323 }
324
325 NumberOfInvolvedNucleonOfProjectile=0;
326*/ // Maybe it will be needed latter------------------
327
328// -------------- Erase the target nucleons -----------
329//G4cout<<"Erase Target Ninv "<<NumberOfInvolvedNucleon<<G4endl;
330 for(G4int i=0; i < NumberOfInvolvedNucleon; i++)
331 {
332 aNucleon = TheInvolvedNucleon[i]->GetSplitableHadron();
333 if(aNucleon) delete aNucleon;
334 }
335
336 NumberOfInvolvedNucleon=0;
337//G4cout<<"Go to fragmentation"<<G4endl;
338 return theStrings;
339
340}
341
342//-------------------------------------------------------------------
343void G4FTFModel::StoreInvolvedNucleon()
344{ //--- To store nucleons involved in low energy interaction -------
345if(std::abs(theProjectile.GetDefinition()->GetBaryonNumber()) <= 1)
346{ // the projectile is a hadron -----------
347//G4cout<<"the projectile is a hadron"<<G4endl;
348 NumberOfInvolvedNucleon=0;
349
350 theParticipants.StartLoop();
351
352 while (theParticipants.Next())
353 {
354//G4cout<<"theParticipants.Next()"<<G4endl;
355 const G4InteractionContent & collision=theParticipants.GetInteraction();
356//G4cout<<"collision=theParticipants.GetInteraction()"<<G4endl;
357 G4Nucleon * TargetNucleon=collision.GetTargetNucleon();
358//G4cout<<"TargetNucleon=collision.GetTargetNucleon()"<<G4endl;
359
360 TheInvolvedNucleon[NumberOfInvolvedNucleon]=TargetNucleon;
361 NumberOfInvolvedNucleon++;
362//G4cout<<G4endl<<"Prim NumberOfInvolvedNucleon "<<NumberOfInvolvedNucleon<<G4endl;
363 } // end of while (theParticipants.Next())
364
365 NumberOfInvolvedTargetNucleon=NumberOfInvolvedNucleon;
366// ---------------- Calculation of creation time for each target nucleon -----------
367//G4cout<<"theParticipants.StartLoop() "<<G4endl;
368 theParticipants.StartLoop(); // restart a loop
369//G4cout<<"theParticipants.Next();"<<G4endl;
370 theParticipants.Next();
371 G4VSplitableHadron * primary = theParticipants.GetInteraction().GetProjectile();
372//G4cout<<"primary->Get4Momentum() "<<primary->Get4Momentum()<<G4endl;
373//G4cout<<"primary->Get4Momentum().pz() "<<primary->Get4Momentum().pz()<<G4endl;
374//G4cout<<"primary->Get4Momentum().e() "<<primary->Get4Momentum().e()<<G4endl;
375
376 G4double betta_z=primary->Get4Momentum().pz()/primary->Get4Momentum().e();
377//G4cout<<"betta_z "<<betta_z<<G4endl;
378 primary->SetTimeOfCreation(0.);
379
380 G4double ZcoordinateOfPreviousCollision(0.);
381 G4double ZcoordinateOfCurrentInteraction(0.);
382 G4double TimeOfPreviousCollision(0.);
383 G4double TimeOfCurrentCollision(0);
384
385 theParticipants.theNucleus->StartLoop();
386 G4Nucleon * aNucleon;
387 G4bool theFirstInvolvedNucleon(true);
388 while ( (aNucleon = theParticipants.theNucleus->GetNextNucleon()) )
389 {
390//G4cout<<"aNucleon->AreYouHit() "<<aNucleon->AreYouHit()<<G4endl;
391 if(aNucleon->AreYouHit())
392 {
393 if(theFirstInvolvedNucleon)
394 {
395 ZcoordinateOfPreviousCollision=aNucleon->GetPosition().z();
396//G4cout<<"ZcoordinateOfPreviousCollision "<<ZcoordinateOfPreviousCollision/fermi<<G4endl;
397 theFirstInvolvedNucleon=false;
398 }
399
400 ZcoordinateOfCurrentInteraction=aNucleon->GetPosition().z();
401//G4cout<<"ZcoordinateOfCurrentInteraction "<<ZcoordinateOfCurrentInteraction/fermi<<G4endl;
402//G4cout<<"TimeOfPreviousCollision "<<TimeOfPreviousCollision<<G4endl;
403
404 // A.R. 18-Oct-2011 : Protection needed for nuclear capture of
405 // anti-proton at rest.
406 if ( betta_z > 1.0e-10 ) {
407 TimeOfCurrentCollision=TimeOfPreviousCollision+
408 (ZcoordinateOfCurrentInteraction-ZcoordinateOfPreviousCollision)/betta_z;
409 } else {
410 TimeOfCurrentCollision=TimeOfPreviousCollision;
411 }
412
413//G4cout<<"TimeOfCurrentCollision "<<TimeOfCurrentCollision<<G4endl;
414// It is assumed that the nucleons are ordered on increasing z-coordinate ------------
415 aNucleon->GetSplitableHadron()->SetTimeOfCreation(TimeOfCurrentCollision);
416
417 ZcoordinateOfPreviousCollision=ZcoordinateOfCurrentInteraction;
418 TimeOfPreviousCollision=TimeOfCurrentCollision;
419 } // end of if(aNucleon->AreYouHit())
420 } // end of while (theParticipant.theNucleus->GetNextNucleon())
421//
422 return;
423} // end of if(std::abs(theProjectile.GetDefinition()->GetBaryonNumber()) <= 1)
424
425// The projectile is a nucleus or an anti-nucleus
426//G4cout<<"FTF The projectile is a nucleus or an anti-nucleus"<<G4endl;
427 NumberOfInvolvedNucleonOfProjectile=0;
428
429 G4V3DNucleus * ProjectileNucleus =theParticipants.GetProjectileNucleus();
430 ProjectileNucleus->StartLoop();
431
432 G4Nucleon * ProjectileNucleon;
433 while ( (ProjectileNucleon=ProjectileNucleus->GetNextNucleon()) )
434 {
435 if ( ProjectileNucleon->AreYouHit() )
436 { // Projectile nucleon was involved in the interaction.
437 TheInvolvedNucleonOfProjectile[NumberOfInvolvedNucleonOfProjectile]=
438 ProjectileNucleon;
439 NumberOfInvolvedNucleonOfProjectile++;
440 }
441 } // End of while ( (ProjectileNucleon=ProjectileNucleus->GetNextNucleon()) )
442
443//------------------
444 NumberOfInvolvedNucleon=0;
445
446 G4V3DNucleus * TargetNucleus =theParticipants.GetWoundedNucleus();
447 TargetNucleus->StartLoop();
448
449 G4Nucleon * TargetNucleon;
450 while ( (TargetNucleon=TargetNucleus->GetNextNucleon()) )
451 {
452 if ( TargetNucleon->AreYouHit() )
453 { // Target nucleon was involved in the interaction.
454 TheInvolvedNucleon[NumberOfInvolvedNucleon]=TargetNucleon;
455 NumberOfInvolvedNucleon++;
456 }
457 } // End of while ( (TargetNucleon=TargetNucleus->GetNextNucleon()) )
458//G4cout<<"Store inv "<<NumberOfInvolvedNucleonOfProjectile<<" "<<NumberOfInvolvedNucleon<<G4endl;
459
460 NumberOfInvolvedTargetNucleon=NumberOfInvolvedNucleon;
461 return;
462} // Uzhi 10 Feb. 2011
463
464//-------------------------------------------------------------------
465void G4FTFModel::ReggeonCascade()
466{ //--- Implementation of the reggeon theory inspired model-------
467//G4cout<<"In reggeon"<<G4endl;
468
469 if(std::abs(theProjectile.GetDefinition()->GetBaryonNumber()) > 1) return;
470// For Nucleus-nucleus or Anti-nucleus - nucleus interactions
471// the cascading will be implemented latter.
472
473 NumberOfInvolvedNucleon=0;
474
475 theParticipants.StartLoop();
476 while (theParticipants.Next())
477 {
478 const G4InteractionContent & collision=theParticipants.GetInteraction();
479
480 G4Nucleon * TargetNucleon=collision.GetTargetNucleon();
481
482 TheInvolvedNucleon[NumberOfInvolvedNucleon]=TargetNucleon;
483 NumberOfInvolvedNucleon++;
484//G4cout<<"Prim NumberOfInvolvedNucleon "<<NumberOfInvolvedNucleon<<G4endl;
485 G4double XofWoundedNucleon = TargetNucleon->GetPosition().x();
486 G4double YofWoundedNucleon = TargetNucleon->GetPosition().y();
487
488 theParticipants.theNucleus->StartLoop();
489 G4Nucleon * Neighbour(0);
490
491 while ( (Neighbour = theParticipants.theNucleus->GetNextNucleon()) )
492 {
493 if(!Neighbour->AreYouHit())
494 {
495 G4double impact2= sqr(XofWoundedNucleon - Neighbour->GetPosition().x()) +
496 sqr(YofWoundedNucleon - Neighbour->GetPosition().y());
497
498 if(G4UniformRand() < theParameters->GetCofNuclearDestruction()*
499 std::exp(-impact2/theParameters->GetR2ofNuclearDestruction()))
500 { // The neighbour nucleon is involved in the reggeon cascade
501
502 TheInvolvedNucleon[NumberOfInvolvedNucleon]=Neighbour;
503 NumberOfInvolvedNucleon++;
504//G4cout<<"Seco NumberOfInvolvedNucleon "<<NumberOfInvolvedNucleon<<G4endl;
505
506 G4VSplitableHadron *targetSplitable;
507 targetSplitable = new G4DiffractiveSplitableHadron(*Neighbour);
508
509 Neighbour->Hit(targetSplitable);
510 targetSplitable->SetStatus(2);
511 }
512 } // end of if(!Neighbour->AreYouHit())
513 } // end of while (theParticipant.theNucleus->GetNextNucleon())
514 } // end of while (theParticipants.Next())
515
516 NumberOfInvolvedTargetNucleon=NumberOfInvolvedNucleon;
517
518// ---------------- Calculation of creation time for each target nucleon -----------
519 theParticipants.StartLoop(); // restart a loop
520 theParticipants.Next();
521 G4VSplitableHadron * primary = theParticipants.GetInteraction().GetProjectile();
522 G4double betta_z=primary->Get4Momentum().pz()/primary->Get4Momentum().e();
523 primary->SetTimeOfCreation(0.);
524
525 G4double ZcoordinateOfPreviousCollision(0.);
526 G4double ZcoordinateOfCurrentInteraction(0.);
527 G4double TimeOfPreviousCollision(0.);
528 G4double TimeOfCurrentCollision(0);
529
530 theParticipants.theNucleus->StartLoop();
531 G4Nucleon * aNucleon;
532 G4bool theFirstInvolvedNucleon(true);
533 while ( (aNucleon = theParticipants.theNucleus->GetNextNucleon()) )
534 {
535 if(aNucleon->AreYouHit())
536 {
537 if(theFirstInvolvedNucleon)
538 {
539 ZcoordinateOfPreviousCollision=aNucleon->GetPosition().z();
540 theFirstInvolvedNucleon=false;
541 }
542
543 ZcoordinateOfCurrentInteraction=aNucleon->GetPosition().z();
544 TimeOfCurrentCollision=TimeOfPreviousCollision+
545 (ZcoordinateOfCurrentInteraction-ZcoordinateOfPreviousCollision)/betta_z;
546// It is assumed that the nucleons are ordered on increasing z-coordinate ------------
547 aNucleon->GetSplitableHadron()->SetTimeOfCreation(TimeOfCurrentCollision);
548
549 ZcoordinateOfPreviousCollision=ZcoordinateOfCurrentInteraction;
550 TimeOfPreviousCollision=TimeOfCurrentCollision;
551 } // end of if(aNucleon->AreYouHit())
552 } // end of while (theParticipant.theNucleus->GetNextNucleon())
553//
554// The algorithm can be improved, but it will be more complicated, and will require
555// changes in G4DiffractiveExcitation.cc and G4ElasticHNScattering.cc
556} // Uzhi 26 July 2009
557
558// ------------------------------------------------------------
559G4bool G4FTFModel::PutOnMassShell()
560{
561//G4cout<<"PutOnMassShell start "<<G4endl;
562 if(std::abs(theProjectile.GetDefinition()->GetBaryonNumber()) > 1) // !!!!
563 { // The projectile is a nucleus or an anti-nucleus
564//G4cout<<"PutOnMassShell AA "<<G4endl;
565 G4LorentzVector P_total(0.,0.,0.,0.);
566
567 G4LorentzVector P_participants(0.,0.,0.,0.);
568 G4int MultiplicityOfParticipants(0);
569
570 G4V3DNucleus * ProjectileNucleus =theParticipants.GetProjectileNucleus();
571 ProjectileNucleus->StartLoop();
572
573 G4Nucleon * ProjectileNucleon;
574 while ( (ProjectileNucleon=ProjectileNucleus->GetNextNucleon()) )
575 {
576 if ( ProjectileNucleon->AreYouHit() )
577 { // Projectile nucleon was involved in the interaction.
578 P_total+=ProjectileNucleon->Get4Momentum();
579 MultiplicityOfParticipants++;
580 P_participants+=ProjectileNucleon->Get4Momentum();
581 }
582 } // End of while ( (ProjectileNucleon=ProjectileNucleus->GetNextNucleon()) )
583//G4cout<<"MultParts mom Pr "<<MultiplicityOfParticipants<<" "<<P_participants<<G4endl;
584//------------------
585 G4int ResidualMassNumber(0);
586 G4int ResidualCharge(0);
587 ResidualExcitationEnergy=0.;
588 G4LorentzVector PnuclearResidual(0.,0.,0.,0.);
589
590 G4double ExcitationEnergyPerWoundedNucleon=
591 theParameters->GetExcitationEnergyPerWoundedNucleon();
592
593 G4V3DNucleus * TargetNucleus =theParticipants.GetWoundedNucleus();
594 TargetNucleus->StartLoop();
595
596 G4Nucleon * TargetNucleon;
597 while ( (TargetNucleon=TargetNucleus->GetNextNucleon()) )
598 {
599 P_total+=TargetNucleon->Get4Momentum();
600 if ( TargetNucleon->AreYouHit() )
601 { // Target nucleon was involved in the interaction.
602 MultiplicityOfParticipants++;
603 P_participants+=TargetNucleon->Get4Momentum();
604 ResidualExcitationEnergy+=ExcitationEnergyPerWoundedNucleon;
605 }
606 else
607 {
608 ResidualMassNumber+=1;
609 ResidualCharge+=(G4int) TargetNucleon->GetDefinition()->GetPDGCharge();
610 PnuclearResidual+=TargetNucleon->Get4Momentum();
611 }
612 } // End of while ( (TargetNucleon=TargetNucleus->GetNextNucleon()) )
613
614 G4double ResidualMass(0.);
615 if(ResidualMassNumber == 0)
616 {
617 ResidualMass=0.;
618 ResidualExcitationEnergy=0.;
619 }
620 else
621 {
622 ResidualMass=G4ParticleTable::GetParticleTable()->GetIonTable()->
623 GetIonMass(ResidualCharge ,ResidualMassNumber);
624 if(ResidualMassNumber == 1) {ResidualExcitationEnergy=0.;}
625 }
626// ResidualMass +=ResidualExcitationEnergy; // Will be given after checks
627
628//G4cout<<"MultPars mom+Tr "<<MultiplicityOfParticipants<<" "<<P_participants<<G4endl;
629//G4cout<<"Res "<<ResidualMassNumber<<" "<<PnuclearResidual<<G4endl;
630//G4cout<<"P_total "<<P_total<<G4endl;
631
632//G4cout<<"Rez A Z M E* "<<ResidualMassNumber<<" "<<ResidualCharge<<" "<<ResidualMass<<" "<<ResidualExcitationEnergy<<G4endl;
633//--------------
634 G4double SqrtS=P_total.mag();
635 G4double S=P_total.mag2();
636
637// if(theProjectile.GetDefinition()->GetBaryonNumber() > 1)
638 { // For nucleus-nucleus interactions
639 G4double MassOfParticipants=P_participants.mag();
640 G4double MassOfParticipants2=sqr(MassOfParticipants);
641
642//G4cout<<"ResidualMass + MassOfParticipants "<<ResidualMass + MassOfParticipants<<G4endl;
643 if(SqrtS < ResidualMass + MassOfParticipants) {return false;}
644
645 if(SqrtS < ResidualMass+ResidualExcitationEnergy + MassOfParticipants)
646 {ResidualExcitationEnergy=0.;}
647
648 ResidualMass +=ResidualExcitationEnergy;
649//G4cout<<"Rez A Z M E* "<<ResidualMassNumber<<" "<<ResidualCharge<<" "<<ResidualMass<<" "<<ResidualExcitationEnergy<<G4endl;
650
651 G4double ResidualMass2=sqr(ResidualMass);
652
653 G4LorentzRotation toCms(-1*P_total.boostVector());
654
655 G4LorentzVector Pcms=toCms*P_participants;
656//G4cout<<"Ppart in CMS "<<Ptmp<<G4endl;
657
658 if ( Pcms.pz() <= 0. )
659 { // "String" moving backwards in CMS, abort collision !!
660 //G4cout << " abort ColliDeleteVSplitableHadronsion!! " << G4endl;
661 return false;
662 }
663
664 toCms.rotateZ(-1*Pcms.phi()); // Uzhi 5.12.09
665 toCms.rotateY(-1*Pcms.theta()); // Uzhi 5.12.09
666
667//G4cout<<"Mpa M res "<<ResidualMass<<" "<<MassOfParticipants<<" "<<SqrtS<<G4endl;
668 G4LorentzRotation toLab(toCms.inverse());
669
670 G4double DecayMomentum2=
671 sqr(S)+sqr(MassOfParticipants2)+ sqr(ResidualMass2) -
672 2.*S*MassOfParticipants2 - 2.*S*ResidualMass2
673 -2.*MassOfParticipants2*ResidualMass2;
674
675 if(DecayMomentum2 < 0.) return false;
676
677 DecayMomentum2/=(4.*S);
678 G4double DecayMomentum = std::sqrt(DecayMomentum2);
679//G4cout<<"DecayMomentum "<<DecayMomentum<<G4endl;
680
681 G4LorentzVector New_P_participants(0.,0.,DecayMomentum,
682 std::sqrt(DecayMomentum2+MassOfParticipants2));
683 G4LorentzVector New_PnuclearResidual(0.,0.,-DecayMomentum,
684 std::sqrt(DecayMomentum2+ResidualMass2));
685
686//G4cout<<"MultPars mom "<<MultiplicityOfParticipants<<" "<<New_P_participants<<G4endl;
687//G4cout<<"Res "<<ResidualMassNumber<<" "<<New_PnuclearResidual<<G4endl;
688 New_P_participants.transform(toLab);
689 New_PnuclearResidual.transform(toLab);
690
691//G4cout<<"MultPars mom "<<MultiplicityOfParticipants<<" "<<New_P_participants<<G4endl;
692//G4cout<<"Res "<<ResidualMassNumber<<" "<<New_PnuclearResidual<<G4endl;
693
694 G4LorentzVector DeltaP_participants=(New_P_participants - P_participants)/
695 ((G4double) MultiplicityOfParticipants);
696
697//G4cout<<"DeltaP_participants "<<DeltaP_participants<<G4endl;
698//-------------
699 ProjectileNucleus->StartLoop();
700 while ( (ProjectileNucleon=ProjectileNucleus->GetNextNucleon()) )
701 {
702 if ( ProjectileNucleon->AreYouHit() )
703 { // Projectile nucleon was involved in the interaction.
704 G4LorentzVector Ptmp=ProjectileNucleon->Get4Momentum() + DeltaP_participants;
705 ProjectileNucleon->GetSplitableHadron()->Set4Momentum(Ptmp);
706 ProjectileNucleon->SetMomentum(Ptmp);
707 }
708 } // End of while ( (ProjectileNucleon=ProjectileNucleus->GetNextNucleon()) )
709
710//-------------
711 TargetNucleus->StartLoop();
712 while ( (TargetNucleon=TargetNucleus->GetNextNucleon()) )
713 {
714 if ( TargetNucleon->AreYouHit() )
715 { // Target nucleon was involved in the interaction.
716 G4LorentzVector Ptmp=TargetNucleon->Get4Momentum() + DeltaP_participants;
717 TargetNucleon->GetSplitableHadron()->Set4Momentum(Ptmp);
718 }
719 } // End of while ( (TargetNucleon=TargetNucleus->GetNextNucleon()) )
720
721 Residual4Momentum = New_PnuclearResidual;
722// return true;
723 } // End of if(theProjectile.GetDefinition()->GetBaryonNumber() > 1)
724
725 return true;
726 }
727//---------------------------------------------------------------------
728// -------- The projectile is hadron, or baryon, or anti-baryon -------
729// -------------- Properties of the projectile ------------------------
730 theParticipants.StartLoop(); // restart a loop
731 theParticipants.Next();
732 G4VSplitableHadron * primary = theParticipants.GetInteraction().GetProjectile();
733 G4LorentzVector Pprojectile=primary->Get4Momentum();
734
735// 13.06.2012 G4bool ProjectileIsAntiBaryon = primary->GetDefinition()->GetBaryonNumber() < 0;
736
737//G4cout<<"PutOnMass Pprojectile "<<Pprojectile<<G4endl;
738// To get original projectile particle
739
740 if(Pprojectile.z() < 0.){return false;}
741
742 G4double Mprojectile = Pprojectile.mag();
743 G4double M2projectile = Pprojectile.mag2();
744//-------------------------------------------------------------
745 G4LorentzVector Psum = Pprojectile;
746
747 G4double SumMasses = Mprojectile + 20.*MeV; // 13.12.09
748 // Separation energy for projectile
749// if(ProjectileIsAntiBaryon) {SumMasses = Mprojectile;}
750//G4cout<<"SumMasses Pr "<<SumMasses<<G4endl;
751//--------------- Target nucleus ------------------------------
752 G4V3DNucleus *theNucleus = GetWoundedNucleus();
753 G4int ResidualMassNumber=theNucleus->GetMassNumber();
754 G4int ResidualCharge =theNucleus->GetCharge();
755
756 ResidualExcitationEnergy=0.;
757 G4LorentzVector Ptarget(0.,0.,0.,0.);
758 G4LorentzVector PnuclearResidual(0.,0.,0.,0.); // Uzhi 12.06.2012
759
760 G4double ExcitationEnergyPerWoundedNucleon=
761 theParameters->GetExcitationEnergyPerWoundedNucleon();
762
763//G4cout<<"ExcitationEnergyPerWoundedNucleon "<<ExcitationEnergyPerWoundedNucleon<<G4endl;
764
765 theNucleus->StartLoop();
766
767 while (G4Nucleon * aNucleon = theNucleus->GetNextNucleon())
768 {
769 Ptarget+=aNucleon->Get4Momentum();
770
771 if(aNucleon->AreYouHit())
772 { // Involved nucleons
773//G4cout<<"PutOn Tr "<<aNucleon->Get4Momentum()<<G4endl;
774// Psum += aNucleon->Get4Momentum(); // Uzhi 20 Sept.
775// if(!ProjectileIsAntiBaryon) // Uzhi 13.06.2012
776// {
777 SumMasses += std::sqrt(sqr(aNucleon->GetDefinition()->GetPDGMass()) //Uzhi 12.06.2012
778 + aNucleon->Get4Momentum().perp2()); //Uzhi 12.06.2012
779 SumMasses += 20.*MeV; // 13.12.09 Separation energy for a nucleon
780 ResidualExcitationEnergy+=ExcitationEnergyPerWoundedNucleon;
781/* //Uzhi 13.06.2012
782 } else
783 {
784 SumMasses += aNucleon->Get4Momentum().mag(); // 4.12.2010
785 G4LorentzVector tmp=aNucleon->Get4Momentum();
786 tmp.setE(aNucleon->Get4Momentum().mag()); // It is need to save mass 6.12.2011
787 aNucleon->SetMomentum(tmp);
788 }
789*/ //Uzhi 13.06.2012
790
791 ResidualMassNumber--;
792 ResidualCharge-=(G4int) aNucleon->GetDefinition()->GetPDGCharge();
793 }
794 else
795 { // Spectator nucleons
796 PnuclearResidual += aNucleon->Get4Momentum(); // Uzhi 12.06.2012
797 } // end of if(!aNucleon->AreYouHit())
798 } // end of while (theNucleus->GetNextNucleon())
799
800 Psum += Ptarget;
801 PnuclearResidual.setPz(0.); PnuclearResidual.setE(0.); // Uzhi 12.06.2012
802//G4cout<<"ResidualCharge ,ResidualMassNumber "<<ResidualCharge<<" "<<ResidualMassNumber<<" "<<Ptarget<<" "<<PnuclearResidual<<G4endl;
803
804 G4double ResidualMass(0.);
805 if(ResidualMassNumber == 0)
806 {
807 ResidualMass=0.;
808 ResidualExcitationEnergy=0.;
809 }
810 else
811 {
812 ResidualMass=G4ParticleTable::GetParticleTable()->GetIonTable()->
813 GetIonMass(ResidualCharge ,ResidualMassNumber);
814 if(ResidualMassNumber == 1) {ResidualExcitationEnergy=0.;}
815 }
816
817// ResidualMass +=ResidualExcitationEnergy; // Will be given after checks
818//G4cout<<"SumMasses And ResidualMass "<<SumMasses<<" "<<ResidualMass<<G4endl;
819 SumMasses += std::sqrt(sqr(ResidualMass)+PnuclearResidual.mag2()); // Uzhi 12.06.2012
820//G4cout<<"SumMasses + ResM "<<SumMasses<<G4endl;
821//G4cout<<"Psum "<<Psum<<G4endl;
822//-------------------------------------------------------------
823
824 G4double SqrtS=Psum.mag();
825 G4double S=Psum.mag2();
826
827//G4cout<<"SqrtS < SumMasses "<<SqrtS<<" "<<SumMasses<<G4endl;
828
829 if(SqrtS < SumMasses) {return false;} // It is impossible to simulate
830 // after putting nuclear nucleons
831 // on mass-shell
832
833 SumMasses -= std::sqrt(sqr(ResidualMass)+PnuclearResidual.mag2()); // Uzhi 12.06.2012
834 SumMasses += std::sqrt(sqr(ResidualMass+ResidualExcitationEnergy)
835 +PnuclearResidual.mag2()); // Uzhi 12.06.2012
836 if(SqrtS < SumMasses) // Uzhi 12.06.2012
837 {
838 SumMasses -= std::sqrt(sqr(ResidualMass+ResidualExcitationEnergy)
839 +PnuclearResidual.mag2()); // Uzhi 12.06.2012
840 SumMasses += std::sqrt(sqr(ResidualMass)+PnuclearResidual.mag2());// Uzhi 12.06.2012
841 ResidualExcitationEnergy=0.;
842 }
843
844 ResidualMass +=ResidualExcitationEnergy;
845// SumMasses +=ResidualExcitationEnergy; // Uzhi 12.06.2012
846//G4cout<<"ResidualMass SumMasses ResidualExcitationEnergy "<<ResidualMass<<" "<<SumMasses<<" "<<ResidualExcitationEnergy<<G4endl;
847//-------------------------------------------------------------
848// Sampling of nucleons what are transfered to delta-isobars --
849 G4int MaxNumberOfDeltas = (int)((SqrtS - SumMasses)/(400.*MeV));
850 G4int NumberOfDeltas(0);
851//G4cout<<"MaxNumberOfDeltas "<<MaxNumberOfDeltas<<G4endl;
852 if(theNucleus->GetMassNumber() != 1)
853 {
854//G4cout<<"NumberOfInvolvedNucleon "<<NumberOfInvolvedNucleon<<G4endl;
855 G4double ProbDeltaIsobar(0.05); // Uzhi 6.07.2012
856 for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
857 {
858 if((G4UniformRand() < ProbDeltaIsobar)&&(NumberOfDeltas < MaxNumberOfDeltas))
859 {
860 NumberOfDeltas++;
861 G4VSplitableHadron * targetSplitable=TheInvolvedNucleon[i]->GetSplitableHadron();
862 G4double MassDec=std::sqrt(sqr(targetSplitable->GetDefinition()->GetPDGMass())
863 + targetSplitable->Get4Momentum().perp2());
864
865 G4int PDGcode = targetSplitable->GetDefinition()->GetPDGEncoding();
866 G4ParticleDefinition* Old_def = targetSplitable->GetDefinition();
867
868 G4int newPDGcode = PDGcode/10; newPDGcode=newPDGcode*10+4; // Delta
869 G4ParticleDefinition* ptr =
870 G4ParticleTable::GetParticleTable()->FindParticle(newPDGcode);
871 targetSplitable->SetDefinition(ptr);
872 G4double MassInc=std::sqrt(sqr(targetSplitable->GetDefinition()->GetPDGMass())
873 + targetSplitable->Get4Momentum().perp2());
874 if(SqrtS < SumMasses + MassInc - MassDec) // Uzhi 12.06.2012
875 { // Change cannot be acsepted!
876 targetSplitable->SetDefinition(Old_def);
877 ProbDeltaIsobar = 0.;
878 } else
879 { // Change is acsepted.
880 SumMasses += (MassInc - MassDec);
881 }
882 }
883 } // end of for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
884 } // end of if(theNucleus.GetMassNumber() != 1)
885
886//-------------------------------------------------------------
887
888 G4LorentzRotation toCms(-1*Psum.boostVector());
889 G4LorentzVector Ptmp=toCms*Pprojectile;
890 if ( Ptmp.pz() <= 0. )
891 { // "String" moving backwards in CMS, abort collision !!
892 //G4cout << " abort ColliDeleteVSplitableHadronsion!! " << G4endl;
893 return false;
894 }
895
896 G4LorentzRotation toLab(toCms.inverse());
897
898 Ptmp=toCms*Ptarget;
899 G4double YtargetNucleus=Ptmp.rapidity();
900//G4cout<<"YtargetNucleus "<<YtargetNucleus<<G4endl;
901//-------------------------------------------------------------
902//------- Ascribing of the involved nucleons Pt and Xminus ----
903 G4double Dcor = theParameters->GetDofNuclearDestruction()/
904 theNucleus->GetMassNumber();
905
906 G4double AveragePt2 = theParameters->GetPt2ofNuclearDestruction();
907 G4double maxPtSquare = theParameters->GetMaxPt2ofNuclearDestruction();
908//G4cout<<"Dcor "<<theParameters->GetDofNuclearDestruction()<<" "<<Dcor<<" AveragePt2 "<<AveragePt2<<G4endl;
909 G4double M2target(0.);
910 G4double WminusTarget(0.);
911 G4double WplusProjectile(0.);
912
913 G4int NumberOfTries(0);
914 G4double ScaleFactor(1.);
915 G4bool OuterSuccess(true);
916 do // while (!OuterSuccess)
917 {
918 OuterSuccess=true;
919
920 do // while (SqrtS < Mprojectile + std::sqrt(M2target))
921 { // while (DecayMomentum < 0.)
922
923 NumberOfTries++;
924
925 if(NumberOfTries == 100*(NumberOfTries/100)) // 100
926 { // At large number of tries it would be better to reduce the values
927 ScaleFactor/=2.;
928 Dcor *=ScaleFactor;
929 AveragePt2 *=ScaleFactor;
930 }
931
932 G4ThreeVector PtSum(0.,0.,0.);
933 G4double XminusSum(0.);
934 G4double Xminus(0.);
935 G4bool InerSuccess=true;
936
937 do // while(!InerSuccess);
938 {
939 InerSuccess=true;
940
941 PtSum =G4ThreeVector(0.,0.,0.);
942 XminusSum=0.;
943
944 for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
945 {
946 G4Nucleon * aNucleon = TheInvolvedNucleon[i];
947
948 G4ThreeVector tmpPt = GaussianPt(AveragePt2, maxPtSquare);
949 PtSum += tmpPt;
950
951 G4ThreeVector tmpX=GaussianPt(Dcor*Dcor, 1.);
952 Xminus=tmpX.x();
953 XminusSum+=Xminus;
954
955 G4LorentzVector tmp(tmpPt.x(),tmpPt.y(),Xminus, // 6 Dec.2010
956 aNucleon->Get4Momentum().e()); // 6 Dec.2010
957
958 aNucleon->SetMomentum(tmp);
959 } // end of for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
960
961//---------------------------------------------------------------------------
962 G4double DeltaX = (PtSum.x()-PnuclearResidual.x())/NumberOfInvolvedNucleon;
963 G4double DeltaY = (PtSum.y()-PnuclearResidual.y())/NumberOfInvolvedNucleon;
964 G4double DeltaXminus(0.);
965
966 if(ResidualMassNumber == 0)
967 {
968 DeltaXminus = (XminusSum-1.)/NumberOfInvolvedNucleon;
969 }
970 else
971 {
972 DeltaXminus = -1./theNucleus->GetMassNumber();
973 }
974
975 XminusSum=1.;
976 M2target =0.;
977
978 for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
979 {
980 G4Nucleon * aNucleon = TheInvolvedNucleon[i];
981
982 Xminus = aNucleon->Get4Momentum().pz() - DeltaXminus;
983 XminusSum-=Xminus;
984
985 if(ResidualMassNumber == 0)
986 {
987 if((Xminus <= 0.) || (Xminus > 1.)) {InerSuccess=false; break;}
988 } else
989 {
990 if((Xminus <= 0.) || (Xminus > 1.) ||
991 (XminusSum <=0.) || (XminusSum > 1.)) {InerSuccess=false; break;}
992 }
993
994 G4double Px=aNucleon->Get4Momentum().px() - DeltaX;
995 G4double Py=aNucleon->Get4Momentum().py() - DeltaY;
996
997// if(!ProjectileIsAntiBaryon) // 4.12.2010
998// {
999 M2target +=(aNucleon->GetSplitableHadron()->GetDefinition()->GetPDGMass()*
1000 aNucleon->GetSplitableHadron()->GetDefinition()->GetPDGMass() +
1001 Px*Px + Py*Py)/Xminus;
1002/*
1003 } else
1004 {
1005 M2target +=(aNucleon->Get4Momentum().e() *
1006 aNucleon->Get4Momentum().e() + // 6.12.2010
1007 Px*Px + Py*Py)/Xminus;
1008 }
1009*/
1010 G4LorentzVector tmp(Px,Py,Xminus,aNucleon->Get4Momentum().e()); // 6.12.2010
1011 aNucleon->SetMomentum(tmp);
1012 } // end of for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
1013
1014 if(InerSuccess && (ResidualMassNumber != 0))
1015 {
1016 M2target +=(sqr(ResidualMass) + PnuclearResidual.mag2())/XminusSum;
1017 }
1018//G4cout<<"InerSuccess "<<InerSuccess<<" "<<SqrtS<<" "<<Mprojectile + std::sqrt(M2target)<<" "<<std::sqrt(M2target)<<G4endl;
1019//G4int Uzhi;G4cin>>Uzhi;
1020 } while(!InerSuccess);
1021 } while (SqrtS < Mprojectile + std::sqrt(M2target));
1022//-------------------------------------------------------------
1023 G4double DecayMomentum2= S*S+M2projectile*M2projectile+M2target*M2target
1024 -2.*S*M2projectile - 2.*S*M2target
1025 -2.*M2projectile*M2target;
1026
1027 WminusTarget=(S-M2projectile+M2target+std::sqrt(DecayMomentum2))/2./SqrtS;
1028 WplusProjectile=SqrtS - M2target/WminusTarget;
1029
1030 G4double Pzprojectile=WplusProjectile/2. - M2projectile/2./WplusProjectile;// 8.06.11
1031 G4double Eprojectile =WplusProjectile/2. + M2projectile/2./WplusProjectile;// 8.06.11
1032 G4double Yprojectile=0.5*std::log((Eprojectile+Pzprojectile)/
1033 (Eprojectile-Pzprojectile)); // 1.07.11
1034
1035//G4cout<<"Yprojectile "<<Yprojectile<<G4endl;
1036//G4LorentzVector TestPprojectile=Pprojectile;
1037//TestPprojectile.setPz(Pzprojectile); TestPprojectile.setE(Eprojectile);
1038
1039//G4cout<<"DecayMomentum2 "<<DecayMomentum2<<G4endl;
1040//G4cout<<"WminusTarget WplusProjectile "<<WminusTarget<<" "<<WplusProjectile<<G4endl;
1041//G4int Uzhi;G4cin>>Uzhi;
1042//-------------------------------------------------------------
1043 for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
1044 {
1045 G4Nucleon * aNucleon = TheInvolvedNucleon[i];
1046 G4LorentzVector tmp=aNucleon->Get4Momentum();
1047
1048 G4double Mt2(0.);
1049
1050// if(!ProjectileIsAntiBaryon) // 4.12.2010
1051// {
1052 Mt2 = sqr(tmp.x())+sqr(tmp.y())+
1053 sqr(aNucleon->GetSplitableHadron()->GetDefinition()->GetPDGMass());
1054/*
1055 } else
1056 {
1057 Mt2 = sqr(tmp.x())+sqr(tmp.y())+ // 4.12.2010
1058 sqr(aNucleon->Get4Momentum().e()); // sqr
1059 }
1060*/
1061 G4double Xminus=tmp.z();
1062
1063 G4double Pz=-WminusTarget*Xminus/2. + Mt2/(2.*WminusTarget*Xminus);
1064 G4double E = WminusTarget*Xminus/2. + Mt2/(2.*WminusTarget*Xminus);
1065 G4double YtargetNucleon=0.5*std::log((E+Pz)/(E-Pz)); // 1.07.11 //Uzhi 20 Sept.
1066
1067//G4cout<<"YtargetNucleon "<<YtargetNucleon<<G4endl;
1068//G4cout<<"YtargetNucleon-YtargetNucleus "<<YtargetNucleon-YtargetNucleus<<G4endl;
1069//G4cout<<"Yprojectile YtargetNucleon "<<Yprojectile<<" "<<YtargetNucleon<<G4endl;
1070if((std::abs(YtargetNucleon-YtargetNucleus) > 2) ||
1071 (Yprojectile < YtargetNucleon)) {OuterSuccess=false; break;} // 1.07.11
1072
1073 } // end of for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
1074//if(ProjectileIsAntiBaryon) {G4int Uzhi;G4cin>>Uzhi;}
1075 } while(!OuterSuccess);
1076
1077//-------------------------------------------------------------
1078 G4double Pzprojectile=WplusProjectile/2. - M2projectile/2./WplusProjectile;
1079 G4double Eprojectile =WplusProjectile/2. + M2projectile/2./WplusProjectile;
1080 Pprojectile.setPz(Pzprojectile); Pprojectile.setE(Eprojectile);
1081//G4cout<<"Proj after in CMS "<<Pprojectile<<G4endl;
1082
1083 Pprojectile.transform(toLab); // The work with the projectile
1084 primary->Set4Momentum(Pprojectile); // is finished at the moment.
1085//G4cout<<"Final proj mom "<<primary->Get4Momentum()<<G4endl;
1086
1087//-------------------------------------------------------------
1088 G4ThreeVector Residual3Momentum(0.,0.,1.);
1089
1090 for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
1091 {
1092 G4Nucleon * aNucleon = TheInvolvedNucleon[i];
1093 G4LorentzVector tmp=aNucleon->Get4Momentum();
1094//G4cout<<"trg "<<aNucleon->Get4Momentum()<<G4endl;
1095 Residual3Momentum-=tmp.vect();
1096
1097 G4double Mt2(0.);
1098
1099// if(!ProjectileIsAntiBaryon) // 4.12.2010
1100// {
1101 Mt2 = sqr(tmp.x())+sqr(tmp.y())+
1102 sqr(aNucleon->GetSplitableHadron()->GetDefinition()->GetPDGMass());
1103/*
1104 } else
1105 {
1106 Mt2 = sqr(tmp.x())+sqr(tmp.y())+ // 4.12.2010
1107 aNucleon->Get4Momentum().e()*aNucleon->Get4Momentum().e();
1108 }
1109*/
1110 G4double Xminus=tmp.z();
1111
1112 G4double Pz=-WminusTarget*Xminus/2. + Mt2/(2.*WminusTarget*Xminus);
1113 G4double E = WminusTarget*Xminus/2. + Mt2/(2.*WminusTarget*Xminus);
1114
1115 tmp.setPz(Pz);
1116 tmp.setE(E);
1117//G4cout<<"Targ after in CMS "<<tmp<<G4endl;
1118 tmp.transform(toLab);
1119
1120 aNucleon->SetMomentum(tmp);
1121//G4cout<<"Targ after in LAB "<<aNucleon->Get4Momentum()<<G4endl;
1122 G4VSplitableHadron * targetSplitable=aNucleon->GetSplitableHadron();
1123 targetSplitable->Set4Momentum(tmp);
1124
1125 } // end of for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
1126
1127//G4cout<<"ResidualMassNumber and Mom "<<ResidualMassNumber<<" "<<Residual3Momentum<<G4endl;
1128 G4double Mt2Residual=sqr(ResidualMass) +
1129 sqr(Residual3Momentum.x())+sqr(Residual3Momentum.y());
1130//==========================
1131//G4cout<<"WminusTarget Residual3Momentum.z() "<<WminusTarget<<" "<<Residual3Momentum.z()<<G4endl;
1132 G4double PzResidual=0.;
1133 G4double EResidual =0.;
1134 if(ResidualMassNumber != 0)
1135 {
1136 PzResidual=-WminusTarget*Residual3Momentum.z()/2. +
1137 Mt2Residual/(2.*WminusTarget*Residual3Momentum.z());
1138 EResidual = WminusTarget*Residual3Momentum.z()/2. +
1139 Mt2Residual/(2.*WminusTarget*Residual3Momentum.z());
1140 }
1141//==========================
1142 Residual4Momentum.setPx(Residual3Momentum.x());
1143 Residual4Momentum.setPy(Residual3Momentum.y());
1144 Residual4Momentum.setPz(PzResidual);
1145 Residual4Momentum.setE(EResidual);
1146//G4cout<<"Residual4Momentum in CMS Y "<<Residual4Momentum.beta()<<G4endl;
1147//G4int Uzhi; G4cin>>Uzhi;
1148 Residual4Momentum.transform(toLab);
1149//G4cout<<"Residual4Momentum in Lab "<<Residual4Momentum<<G4endl;
1150//G4int Uzhi; G4cin>>Uzhi;
1151//-------------------------------------------------------------
1152 return true;
1153}
1154
1155// ------------------------------------------------------------
1156G4bool G4FTFModel::ExciteParticipants()
1157{
1158//G4cout<<"G4FTFModel::ExciteParticipants() "<<G4endl;
1159 G4bool Successfull(true); //(false); // 1.07.11
1160
1161 theParticipants.StartLoop();
1162 G4int CurrentInteraction(0); // Uzhi Feb26
1163
1164 G4int MaxNumOfInelCollisions=G4int(theParameters->GetMaxNumberOfCollisions());
1165//G4cout<<"MaxNumOfInelCollisions "<<MaxNumOfInelCollisions<<G4endl;
1166 G4double NumberOfInel(0.);
1167//
1168 if(MaxNumOfInelCollisions > 0)
1169 { // Plab > Pbound, Normal application of FTF is possible
1170 G4double ProbMaxNumber=theParameters->GetMaxNumberOfCollisions()-
1171 MaxNumOfInelCollisions;
1172 if(G4UniformRand() < ProbMaxNumber) {MaxNumOfInelCollisions++;}
1173 NumberOfInel=MaxNumOfInelCollisions;
1174//G4cout<<"Plab > Pbound MaxNumOfInelCollisions "<<MaxNumOfInelCollisions<<G4endl;
1175 } else
1176 { // Plab < Pbound, Normal application of FTF is impossible,
1177 // low energy corrections applied.
1178 if(theParticipants.theNucleus->GetMassNumber() > 1)
1179 {
1180 NumberOfInel = theParameters->GetProbOfInteraction();
1181 MaxNumOfInelCollisions = 1;
1182 } else
1183 { // Special case for hadron-nucleon interactions
1184 NumberOfInel = 1.;
1185 MaxNumOfInelCollisions = 1;
1186//G4cout<<"Plab < Pbound MaxNumOfInelCollisions "<<MaxNumOfInelCollisions<<G4endl;
1187 }
1188 } // end of if(MaxNumOfInelCollisions > 0)
1189//
1190//G4cout<<"MaxNumOfInelCollisions MaxNumOfInelCollisions "<<MaxNumOfInelCollisions<<" "<<MaxNumOfInelCollisions<<G4endl;
1191
1192 while (theParticipants.Next())
1193 {
1194 CurrentInteraction++;
1195 const G4InteractionContent & collision=theParticipants.GetInteraction();
1196
1197 G4VSplitableHadron * projectile=collision.GetProjectile();
1198 G4VSplitableHadron * target=collision.GetTarget();
1199//
1200//G4cout<<"Ppr tr "<<projectile<<" "<<target<<G4endl;
1201//G4cout<<"theInter Time "<<collision.GetInteractionTime()/fermi<<G4endl;
1202//G4cout<<"Int Status "<<collision.GetStatus()<<" "<<CurrentInteraction<<G4endl;
1203//G4cout<<"Proj M "<<projectile->Get4Momentum()<<" "<<projectile->Get4Momentum().mag()<<G4endl;
1204//G4cout<<"Targ M "<<target->Get4Momentum()<<" "<<target->Get4Momentum().mag()<<G4endl;
1205//G4cout<<"ProbabilityOfElasticScatt "<<theParameters->GetProbabilityOfElasticScatt()<<G4endl;
1206//G4cout<<"ProbabilityOfAnnihilation "<<theParameters->GetProbabilityOfAnnihilation()<<G4endl;
1207//G4cout<<"projectile->GetStatus target->GetStatus "<<projectile->GetStatus()<<" "<<target->GetStatus()<<G4endl;
1208//if((projectile->GetStatus() == 1) && (target->GetStatus() ==1))
1209//
1210if(collision.GetStatus()) // Uzhi Feb26
1211{
1212
1213//theParameters->SetProbabilityOfElasticScatt(1.);
1214//G4cout<<"before pro "<<projectile->Get4Momentum()<<" "<<projectile->Get4Momentum().mag()<<G4endl;
1215//G4cout<<"before tar "<<target->Get4Momentum()<<" "<<target->Get4Momentum().mag()<<G4endl;
1216//G4cout<<"Prob el "<<theParameters->GetProbabilityOfElasticScatt()<<G4endl;
1217//G4cout<<"Prob an "<<theParameters->GetProbabilityOfAnnihilation()<<G4endl;
1218
1219//G4cout<<"Pr Tr "<<projectile->GetDefinition()->GetPDGEncoding()<<" "<<target->GetDefinition()->GetPDGEncoding()<<G4endl;
1220//G4int Uzhi; G4cin>>Uzhi;
1221
1222 if(G4UniformRand()< theParameters->GetProbabilityOfElasticScatt())
1223 { // Elastic scattering -------------------------
1224//G4cout<<"Elastic FTF"<<G4endl;
1225 Successfull = theElastic->ElasticScattering(projectile, target, theParameters)
1226 || Successfull; // 9.06.2012
1227 }
1228 else if(G4UniformRand() > theParameters->GetProbabilityOfAnnihilation())
1229 { // Inelastic scattering ----------------------
1230//G4cout<<"Inelastic FTF"<<G4endl;
1231//G4cout<<"NumberOfInel MaxNumOfInelCollisions "<<NumberOfInel<<" "<<MaxNumOfInelCollisions<<G4endl;
1232 if(G4UniformRand()< NumberOfInel/MaxNumOfInelCollisions)
1233 {
1234 if(theExcitation->ExciteParticipants(projectile, target,
1235 theParameters, theElastic))
1236 {
1237 NumberOfInel--;
1238//G4cout<<"Excitation FTF Successfull "<<G4endl;
1239//G4cout<<"After pro "<<projectile->Get4Momentum()<<" "<<projectile->Get4Momentum().mag()<<G4endl;
1240//G4cout<<"After tar "<<target->Get4Momentum()<<" "<<target->Get4Momentum().mag()<<G4endl;
1241 } else
1242 {
1243//G4cout<<"Excitation FTF Non Successfull -> Elastic scattering "<<Successfull<<G4endl;
1244
1245 Successfull = theElastic->ElasticScattering(projectile, target, theParameters)
1246 || Successfull; // 9.06.2012
1247
1248/*
1249 if(NumberOfInvolvedTargetNucleon > 1)
1250 {
1251 NumberOfInvolvedTargetNucleon--;
1252 target->SetStatus(0); // 1->0 return nucleon to the target VU 10.04.2012
1253 }
1254*/
1255 }
1256 } else // If NumOfInel
1257 {
1258//G4cout<<"Elastic at rejected inelastic scattering"<<G4endl;
1259 Successfull = theElastic->ElasticScattering(projectile, target, theParameters)
1260 || Successfull; // 9.06.2012
1261/*
1262 if(theElastic->ElasticScattering(projectile, target, theParameters))
1263 {
1264// Successfull = Successfull || true;
1265 } else
1266 {
1267// Successfull = Successfull || false;
1268//Successfull = Successfull && false;
1269Successfull = false; break; // 1.07.11
1270
1271 if(NumberOfInvolvedTargetNucleon > 1)
1272 {
1273 NumberOfInvolvedTargetNucleon--;
1274 target->SetStatus(4); // 1->0 return nucleon to the target VU 10.04.2012
1275 }
1276 }
1277*/
1278 } // end if NumOfInel
1279 }
1280 else // Annihilation
1281 {
1282//G4cout<<"Annihilation"<<G4endl;
1283//G4cout<<"Before pro "<<projectile->Get4Momentum()<<G4endl;
1284//G4cout<<"Before tar "<<target->Get4Momentum()<<G4endl;
1285//G4cout<<"Mom pro "<<theProjectile.GetTotalMomentum()<<G4endl;
1286//if(theProjectile.GetTotalMomentum() < 2000.*MeV)
1287{
1288 while (theParticipants.Next())
1289 {
1290 G4InteractionContent & acollision=theParticipants.GetInteraction();//Uzhi Feb26
1291
1292 G4VSplitableHadron * NextProjectileNucleon=acollision.GetProjectile(); // Uzhi Feb26
1293 G4VSplitableHadron * NextTargetNucleon =acollision.GetTarget();
1294 if((projectile == NextProjectileNucleon) ||
1295 (target == NextTargetNucleon )) acollision.SetStatus(0);
1296// if(target != NextTargetNucleon) NextTargetNucleon->SetStatus(0); // Uzhi Feb26
1297 }
1298
1299 theParticipants.StartLoop();
1300 for(G4int I=0; I < CurrentInteraction; I++) theParticipants.Next();
1301
1302//-----------------------------------------
1303// 1Nov2011 AjustTargetNucleonForAnnihilation(projectile, target);
1304//-----------------------------------------
1305//G4cout<<"After Ajsd pro "<<projectile->Get4Momentum()<<G4endl;
1306//G4cout<<"After Ajst tar "<<target->Get4Momentum()<<G4endl;
1307}
1308 G4VSplitableHadron *AdditionalString=0;
1309 if(theAnnihilation->Annihilate(projectile, target, AdditionalString, theParameters))
1310 {
1311 Successfull = Successfull || true;
1312//G4cout<<G4endl<<"*AdditionalString "<<AdditionalString<<G4endl;
1313//G4cout<<"After pro "<<projectile->Get4Momentum()<<G4endl;
1314//G4cout<<"After tar "<<target->Get4Momentum()<<G4endl;
1315
1316 if(AdditionalString != 0) theAdditionalString.push_back(AdditionalString);
1317
1318// break;
1319
1320 } else
1321 {
1322 //A.R. 25-Jul-2012 : commenting the next line to fix a Coverity
1323 // "logically dead code".
1324 //Successfull = Successfull || false;
1325
1326// target->SetStatus(2);
1327 }
1328 }
1329//
1330} // End of if((projectile->GetStatus() == 1) && (target->GetStatus() ==1))
1331
1332 } // end of while (theParticipants.Next())
1333
1334//Successfull=true;
1335//G4cout<<"G4FTFModel::ExciteParticipants() Successfull "<<Successfull<<G4endl;
1336//G4int Uzhi; G4cin>>Uzhi;
1337 return Successfull;
1338}
1339
1340//-------------------------------------------------------------------
1341void G4FTFModel::AjustTargetNucleonForAnnihilation(G4VSplitableHadron *SelectedAntiBaryon,
1342 G4VSplitableHadron *SelectedTargetNucleon)
1343{
1344 G4LorentzVector Pparticipants=SelectedAntiBaryon->Get4Momentum()+
1345 SelectedTargetNucleon->Get4Momentum();
1346
1347 G4V3DNucleus *theNucleus = GetWoundedNucleus();
1348//G4cout<<"Init A mass "<<theNucleus->GetMass()<<" "<<theNucleus->GetMassNumber()<<" "<<theNucleus->GetCharge()<<G4endl;
1349
1350 ResidualExcitationEnergy=0.;
1351 G4int ResidualCharge =theNucleus->GetCharge();
1352 G4int ResidualMassNumber=theNucleus->GetMassNumber();
1353
1354 G4ThreeVector P3nuclearResidual(0.,0.,0.);
1355 G4LorentzVector PnuclearResidual(0.,0.,0.,0.);
1356
1357
1358 G4double ExcitationEnergyPerWoundedNucleon=
1359 theParameters->GetExcitationEnergyPerWoundedNucleon();
1360//-------
1361 G4Nucleon * aNucleon;
1362 theNucleus->StartLoop();
1363 G4int NumberOfHoles(0);
1364//G4cout<<"Start loop"<<G4endl;
1365 while ((aNucleon = theNucleus->GetNextNucleon()))
1366 {
1367 G4int CurrentStatus=0;
1368 if(aNucleon->AreYouHit())
1369 {
1370 if(aNucleon->GetSplitableHadron() == SelectedTargetNucleon)
1371 {CurrentStatus=1;}
1372 else
1373 {
1374 if(aNucleon->GetSplitableHadron()->GetSoftCollisionCount() == 0)
1375 {CurrentStatus=0;}
1376 else {CurrentStatus=1;}
1377 }
1378 }
1379//G4cout<<"CurrentStatus "<<CurrentStatus<<G4endl;
1380 if(CurrentStatus != 0)
1381 { // Participating nucleons
1382//G4cout<<" Partic "<<aNucleon->GetSplitableHadron()->GetStatus()<<" "<<aNucleon->GetSplitableHadron()->GetSoftCollisionCount()<<G4endl;
1383 NumberOfHoles++;
1384 ResidualExcitationEnergy+=ExcitationEnergyPerWoundedNucleon;
1385 ResidualCharge-=(G4int) aNucleon->GetDefinition()->GetPDGCharge();
1386 ResidualMassNumber--;
1387 }
1388 else
1389 { // Spectator nucleon
1390 PnuclearResidual+=aNucleon->Get4Momentum();
1391 }
1392 } // end of while (theNucleus->GetNextNucleon())
1393
1394//G4cout<<"Res Z M "<<ResidualCharge<<" "<<ResidualMassNumber<<G4endl;
1395//-------------------------------
1396 G4LorentzVector Psum=Pparticipants + PnuclearResidual; // 4-momentum in CMS
1397
1398// Transform momenta to cms and then rotate parallel to z axis;
1399 G4LorentzRotation toCms(-1*Psum.boostVector());
1400
1401 G4LorentzVector Ptmp=toCms*Psum;
1402
1403 toCms.rotateZ(-1*Ptmp.phi());
1404 toCms.rotateY(-1*Ptmp.theta());
1405
1406 G4LorentzRotation toLab(toCms.inverse());
1407
1408//-------------------------------
1409 G4double SqrtS=Psum.mag();
1410 G4double S =sqr(SqrtS);
1411
1412 G4double ResidualMass(0.);
1413 if(ResidualMassNumber != 0)
1414 {
1415 ResidualMass=G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(
1416 ResidualCharge,ResidualMassNumber);
1417 } else {return;}
1418
1419//G4cout<<"Res Mass E* "<<ResidualMass<<" "<<ResidualExcitationEnergy<<G4endl;
1420
1421 if(ResidualMass > SqrtS) {return;}
1422 else
1423 {
1424 if(ResidualMass+ResidualExcitationEnergy > SqrtS)
1425 ResidualExcitationEnergy = SqrtS-ResidualMass;
1426 }
1427
1428 ResidualMass+=ResidualExcitationEnergy;
1429 G4double ResidualMass2=sqr(ResidualMass);
1430//G4cout<<"New Res Mass E* "<<ResidualMass<<" "<<ResidualExcitationEnergy<<G4endl;
1431
1432//-------
1433 G4double ParticipantMass=Pparticipants.mag();
1434 G4double ParticipantMass2=sqr(ParticipantMass);
1435
1436 if(ResidualMass + ParticipantMass > SqrtS) ParticipantMass=SqrtS-ResidualMass;
1437
1438//G4cout<<"Parts P "<<Pparticipants<<G4endl;
1439//G4cout<<"Res Nuc "<<PnuclearResidual<<G4endl;
1440
1441 G4double DecayMomentum2=
1442 sqr(S)+sqr(ParticipantMass2)+ sqr(ResidualMass2) -
1443 2.*S*ParticipantMass2 - 2.*S*ResidualMass2
1444 -2.*ParticipantMass2*ResidualMass2;
1445
1446 if(DecayMomentum2 < 0.) return;
1447
1448 DecayMomentum2/=(4.*S);
1449 G4double DecayMomentum = std::sqrt(DecayMomentum2);
1450//G4cout<<"DecayMomentum "<<DecayMomentum<<G4endl;
1451
1452 G4LorentzVector New_Pparticipants(0.,0.,DecayMomentum,
1453 std::sqrt(DecayMomentum2+ParticipantMass2));
1454
1455 G4LorentzVector New_PnuclearResidual(0.,0.,-DecayMomentum,
1456 std::sqrt(DecayMomentum2+ResidualMass2));
1457
1458//G4cout<<"New part P "<<New_Pparticipants<<" "<<New_Pparticipants.mag()<<G4endl;
1459//G4cout<<"New resd P "<<New_PnuclearResidual<<" "<<New_PnuclearResidual.mag()<<G4endl;
1460
1461 New_Pparticipants.transform(toLab);
1462 New_PnuclearResidual.transform(toLab);
1463//G4cout<<"New part P "<<New_Pparticipants<<" "<<New_Pparticipants.mag()<<G4endl;
1464//G4cout<<"New resd P "<<New_PnuclearResidual<<" "<<New_PnuclearResidual.mag()<<G4endl;
1465
1466 G4LorentzVector DeltaP_participants=(Pparticipants - New_Pparticipants)/2.;
1467 G4LorentzVector DeltaP_nuclearResidual=(PnuclearResidual - New_PnuclearResidual)/
1468 (G4double) ResidualMassNumber;
1469//------------------
1470
1471 Ptmp=SelectedAntiBaryon->Get4Momentum() - DeltaP_participants;
1472 SelectedAntiBaryon->Set4Momentum(Ptmp);
1473
1474 Ptmp=SelectedTargetNucleon->Get4Momentum() - DeltaP_participants;
1475 SelectedTargetNucleon->Set4Momentum(Ptmp);
1476//-----------
1477
1478 //A.R. 25-Jul-2012 : Fix to Covery "Division by zero"
1479 //G4double DeltaExcitationEnergy=ResidualExcitationEnergy/((G4double) NumberOfHoles);
1480 G4double DeltaExcitationEnergy = 0.0;
1481 if ( NumberOfHoles != 0 ) {
1482 DeltaExcitationEnergy = ResidualExcitationEnergy / ((G4double) NumberOfHoles);
1483 }
1484
1485// Re-definition of the wounded nucleon momenta
1486 theNucleus->StartLoop();
1487 while ((aNucleon = theNucleus->GetNextNucleon()))
1488 {
1489 G4int CurrentStatus=0;
1490 if(aNucleon->AreYouHit())
1491 {
1492 if(aNucleon->GetSplitableHadron() == SelectedTargetNucleon)
1493 {CurrentStatus=1;}
1494 else
1495 {
1496 if(aNucleon->GetSplitableHadron()->GetSoftCollisionCount() == 0)
1497 {CurrentStatus=0;}
1498 else {CurrentStatus=1;}
1499 }
1500 }
1501//G4cout<<"CurrentStatus "<<CurrentStatus<<G4endl;
1502 if(CurrentStatus != 0)
1503 { // Participating nucleons
1504//G4cout<<" Partic "<<aNucleon->GetSplitableHadron()->GetStatus()<<" "<<aNucleon->GetSplitableHadron()->GetSoftCollisionCount()<<G4endl;
1505 aNucleon->SetBindingEnergy(DeltaExcitationEnergy);
1506 }
1507 else
1508 { // Spectator nucleon of nuclear residual
1509 Ptmp=aNucleon->Get4Momentum() - DeltaP_nuclearResidual;
1510 aNucleon->SetMomentum(Ptmp);
1511 }
1512 } // end of while (theNucleus->GetNextNucleon())
1513
1514//-------------------------------
1515 return;
1516}
1517
1518// ------------------------------------------------------------
1519G4ExcitedStringVector * G4FTFModel::BuildStrings()
1520{
1521// Loop over all collisions; find all primaries, and all target ( targets may
1522// be duplicate in the List ( to unique G4VSplitableHadrons)
1523
1524 G4ExcitedStringVector * strings;
1525 strings = new G4ExcitedStringVector();
1526
1527 std::vector<G4VSplitableHadron *> primaries;
1528
1529 G4ExcitedString * FirstString(0); // If there will be a kink,
1530 G4ExcitedString * SecondString(0); // two strings will be produced.
1531
1532 theParticipants.StartLoop(); // restart a loop
1533//
1534 while ( theParticipants.Next() )
1535 {
1536 const G4InteractionContent & interaction=theParticipants.GetInteraction();
1537// if(interaction.GetStatus() != 0) // Uzhi Feb26
1538 {
1539 // do not allow for duplicates ...
1540 if ( primaries.end() == std::find(primaries.begin(), primaries.end(),
1541 interaction.GetProjectile()) )
1542 primaries.push_back(interaction.GetProjectile());
1543 } // Uzhi Feb26
1544 }
1545
1546//G4cout<<G4endl<<"primaries.size() "<<primaries.size()<<G4endl;
1547 for (unsigned int ahadron=0; ahadron < primaries.size() ; ahadron++)
1548 {
1549 G4bool isProjectile(0);
1550
1551 if(primaries[ahadron]->GetStatus() <= 1) {isProjectile=true; } // VU 10.04.2012
1552// if(primaries[ahadron]->GetStatus() == 3) {isProjectile=false;}
1553
1554 FirstString=0; SecondString=0;
1555 theExcitation->CreateStrings(primaries[ahadron], isProjectile,
1556 FirstString, SecondString,
1557 theParameters);
1558
1559 if(FirstString != 0) strings->push_back(FirstString);
1560 if(SecondString != 0) strings->push_back(SecondString);
1561//G4cout<<"Quarks in the string in FTF"<<FirstString->GetRightParton()->GetPDGcode()<<" "<<FirstString->GetLeftParton()->GetPDGcode()<<G4endl;
1562
1563//G4cout<<FirstString<<" "<<SecondString<<G4endl;
1564 }
1565
1566//G4cout<<"Check "<<strings->operator[](0)->GetRightParton()->GetPDGcode()<<" "<<strings->operator[](0)->GetLeftParton()->GetPDGcode()<<G4endl;
1567//
1568// Looking for spectator nucleons of the projectile-----------
1569 G4V3DNucleus * ProjectileNucleus =theParticipants.GetProjectileNucleus();
1570 if(ProjectileNucleus)
1571 {
1572 ProjectileNucleus->StartLoop();
1573
1574 G4Nucleon * ProjectileNucleon;
1575 while ( (ProjectileNucleon=ProjectileNucleus->GetNextNucleon()) )
1576 {
1577 if ( !ProjectileNucleon->AreYouHit() )
1578 { // Projectile nucleon was involved in the interaction.
1579
1580 G4VSplitableHadron * ProjectileSplitable=0;
1581 ProjectileSplitable= new G4DiffractiveSplitableHadron(*ProjectileNucleon);
1582 ProjectileNucleon->Hit(0);
1583
1584 G4bool isProjectile=true;
1585 FirstString=0; SecondString=0;
1586 theExcitation->CreateStrings(ProjectileSplitable,
1587 isProjectile,
1588 FirstString, SecondString,
1589 theParameters);
1590 if(FirstString != 0) strings->push_back(FirstString);
1591 if(SecondString != 0) strings->push_back(SecondString);
1592
1593 delete ProjectileSplitable;
1594 }
1595 } // End of while ( (ProjectileNucleon=ProjectileNucleus->GetNextNucleon()) )
1596 } // End of if(ProjectileNucleus)
1597
1598//G4cout<<G4endl<<"theAdditionalString.size() "<<theAdditionalString.size()<<G4endl;
1599 if(theAdditionalString.size() != 0)
1600 {
1601 for (unsigned int ahadron=0; ahadron < theAdditionalString.size() ; ahadron++)
1602 {
1603 G4bool isProjectile(0);
1604
1605 if(theAdditionalString[ahadron]->GetStatus() <= 1) {isProjectile=true; } // VU 10.04.2012
1606// if(theAdditionalString[ahadron]->GetStatus() == 3) {isProjectile=false;}
1607
1608 FirstString=0; SecondString=0;
1609 theExcitation->CreateStrings(theAdditionalString[ahadron], isProjectile,
1610 FirstString, SecondString,
1611 theParameters);
1612
1613 if(FirstString != 0) strings->push_back(FirstString);
1614 if(SecondString != 0) strings->push_back(SecondString);
1615//G4cout<<"Quarks in the string in FTF"<<FirstString->GetRightParton()->GetPDGcode()<<" "<<FirstString->GetLeftParton()->GetPDGcode()<<G4endl;
1616//G4cout<<FirstString<<" "<<SecondString<<G4endl;
1617 }
1618 }
1619//G4cout<<"Check "<<strings->operator[](0)->GetRightParton()->GetPDGcode()<<" "<<strings->operator[](0)->GetLeftParton()->GetPDGcode()<<G4endl;
1620//G4cout<<"Check "<<strings->operator[](1)->GetRightParton()->GetPDGcode()<<" "<<strings->operator[](1)->GetLeftParton()->GetPDGcode()<<G4endl;
1621//
1622//G4cout<<G4endl<<"NumberOfInvolvedNucleon "<<NumberOfInvolvedNucleon<<G4endl;
1623 for (G4int ahadron=0; ahadron < NumberOfInvolvedNucleon ; ahadron++)
1624 {
1625//G4cout<<"Nucleon status & int# "<<ahadron<<" "<<TheInvolvedNucleon[ahadron]->GetSplitableHadron()->GetStatus()<<" "<<TheInvolvedNucleon[ahadron]->GetSplitableHadron()->GetSoftCollisionCount()<<G4endl;
1626 if(TheInvolvedNucleon[ahadron]->GetSplitableHadron()->GetStatus() ==4)
1627 { // A nucleon is returned back to the nucleus after annihilation act for example
1628//G4cout<<" Delete 0"<<G4endl;
1629 delete TheInvolvedNucleon[ahadron]->GetSplitableHadron();
1630 G4VSplitableHadron *aHit=0;
1631 TheInvolvedNucleon[ahadron]->Hit(aHit);
1632 }
1633 else if((TheInvolvedNucleon[ahadron]->GetSplitableHadron()->GetStatus() <=1) && // VU 10.04.2012
1634 (TheInvolvedNucleon[ahadron]->GetSplitableHadron()->GetSoftCollisionCount() ==0))
1635 { // A nucleon is returned back to the nucleus after rejected interactions
1636 // due to an annihilation before
1637//G4cout<<" Delete int# 0"<<G4endl;
1638 delete TheInvolvedNucleon[ahadron]->GetSplitableHadron();
1639 G4VSplitableHadron *aHit=0;
1640 TheInvolvedNucleon[ahadron]->Hit(aHit);
1641 }
1642 else if((TheInvolvedNucleon[ahadron]->GetSplitableHadron()->GetStatus() <=1) && // VU 10.04.2012
1643 (TheInvolvedNucleon[ahadron]->GetSplitableHadron()->GetSoftCollisionCount() !=0))
1644 { // Nucleon which participate in the interactions,
1645//G4cout<<"Taken 1 !=0"<<G4endl;
1646 G4bool isProjectile=false;
1647 FirstString=0; SecondString=0;
1648 theExcitation->CreateStrings(
1649 TheInvolvedNucleon[ahadron]->GetSplitableHadron(),
1650 isProjectile,
1651 FirstString, SecondString,
1652 theParameters);
1653 if(FirstString != 0) strings->push_back(FirstString);
1654 if(SecondString != 0) strings->push_back(SecondString);
1655 }
1656 else if(TheInvolvedNucleon[ahadron]->GetSplitableHadron()->GetStatus() ==2)
1657 { // Nucleon which was involved in the Reggeon cascading
1658//G4cout<<"Taken st 2"<<G4endl;
1659 G4bool isProjectile=false;
1660 FirstString=0; SecondString=0;
1661 theExcitation->CreateStrings(
1662 TheInvolvedNucleon[ahadron]->GetSplitableHadron(),
1663 isProjectile,
1664 FirstString, SecondString,
1665 theParameters);
1666 if(FirstString != 0) strings->push_back(FirstString);
1667 if(SecondString != 0) strings->push_back(SecondString);
1668//G4cout<<FirstString<<" "<<SecondString<<G4endl;
1669 }
1670 else if(TheInvolvedNucleon[ahadron]->GetSplitableHadron()->GetStatus() ==3)
1671 { // Nucleon which has participated in annihilation and disappiered
1672//G4cout<<"Status 3 "<<G4endl;
1673 TheInvolvedNucleon[ahadron]->SetBindingEnergy(theParameters->GetExcitationEnergyPerWoundedNucleon());
1674 }
1675 else {}
1676
1677 }
1678/*
1679G4cout<<"Check "<<strings->operator[](0)->GetRightParton()->GetPDGcode()<<" "<<strings->operator[](0)->GetLeftParton()->GetPDGcode()<<G4endl;
1680G4cout<<"Check "<<strings->operator[](1)->GetRightParton()->GetPDGcode()<<" "<<strings->operator[](1)->GetLeftParton()->GetPDGcode()<<G4endl;
1681//G4cout<<"Check "<<strings->operator[](2)->GetRightParton()->GetPDGcode()<<" "<<strings->operator[](2)->GetLeftParton()->GetPDGcode()<<G4endl;
1682
1683G4cout<<"*** "<<strings->operator[](0)->GetRightParton()<<" "<<strings->operator[](0)->GetLeftParton()<<G4endl;
1684G4cout<<"*** "<<strings->operator[](1)->GetRightParton()<<" "<<strings->operator[](1)->GetLeftParton()<<G4endl;
1685//G4cout<<"*** "<<strings->operator[](2)->GetRightParton()<<" "<<strings->operator[](2)->GetLeftParton()<<G4endl;
1686*/
1687 std::for_each(primaries.begin(), primaries.end(), DeleteVSplitableHadron());
1688 primaries.clear();
1689/*
1690G4cout<<"*** "<<strings->operator[](0)->GetRightParton()<<" "<<strings->operator[](0)->GetLeftParton()<<G4endl;
1691G4cout<<"*** "<<strings->operator[](1)->GetRightParton()<<" "<<strings->operator[](1)->GetLeftParton()<<G4endl;
1692G4cout<<"*** "<<strings->operator[](2)->GetRightParton()<<" "<<strings->operator[](2)->GetLeftParton()<<G4endl;
1693
1694G4cout<<"Check "<<strings->operator[](0)->GetRightParton()->GetPDGcode()<<" "<<strings->operator[](0)->GetLeftParton()->GetPDGcode()<<G4endl;
1695G4cout<<"Check "<<strings->operator[](1)->GetRightParton()->GetPDGcode()<<" "<<strings->operator[](1)->GetLeftParton()->GetPDGcode()<<G4endl;
1696G4cout<<"Check "<<strings->operator[](2)->GetRightParton()->GetPDGcode()<<" "<<strings->operator[](2)->GetLeftParton()->GetPDGcode()<<G4endl;
1697*/
1698
1699/*
1700for (unsigned int ahadron=0; ahadron < strings->size() ; ahadron++)
1701{
1702G4cout<<ahadron<<" "<<strings->operator[](ahadron)->GetRightParton()->GetPDGcode()<<" "<<strings->operator[](ahadron)->GetLeftParton()->GetPDGcode()<<G4endl;
1703}
1704G4cout<<"------------------------"<<G4endl;
1705*/
1706//G4int Uzhi; G4cin >> Uzhi;
1707 return strings;
1708}
1709// ------------------------------------------------------------
1710void G4FTFModel::GetResidualNucleus()
1711{ // This method is needed for the correct application of G4PrecompoundModelInterface
1712 G4double DeltaExcitationE=ResidualExcitationEnergy/
1713 (G4double) NumberOfInvolvedNucleon;
1714 G4LorentzVector DeltaPResidualNucleus = Residual4Momentum/
1715 (G4double) NumberOfInvolvedNucleon;
1716
1717 for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
1718 {
1719 G4Nucleon * aNucleon = TheInvolvedNucleon[i];
1720// G4LorentzVector tmp=aNucleon->Get4Momentum()-DeltaPResidualNucleus;
1721 G4LorentzVector tmp=-DeltaPResidualNucleus;
1722 aNucleon->SetMomentum(tmp);
1723 aNucleon->SetBindingEnergy(DeltaExcitationE);
1724 } // end of for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
1725
1726}
1727
1728// ------------------------------------------------------------
1729G4ThreeVector G4FTFModel::GaussianPt(G4double AveragePt2, G4double maxPtSquare) const
1730{ // @@ this method is used in FTFModel as well. Should go somewhere common!
1731
1732 G4double Pt2(0.);
1733 if(AveragePt2 <= 0.) {Pt2=0.;}
1734 else
1735 {
1736 Pt2 = -AveragePt2 * std::log(1. + G4UniformRand() *
1737 (std::exp(-maxPtSquare/AveragePt2)-1.));
1738 }
1739 G4double Pt=std::sqrt(Pt2);
1740 G4double phi=G4UniformRand() * twopi;
1741
1742 return G4ThreeVector (Pt*std::cos(phi), Pt*std::sin(phi), 0.);
1743}
1744
1745void G4FTFModel::ModelDescription(std::ostream& desc) const
1746{
1747 desc << "please add description here" << G4endl;
1748}
G4ExcitedStringVector
std::vector< G4ExcitedString * > G4ExcitedStringVector
Definition: G4ExcitedStringVector.hh:41
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:42
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4bool
bool G4bool
Definition: G4Types.hh:67
G4endl
#define G4endl
Definition: G4ios.hh:52
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:53
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
CLHEP::HepLorentzVector::theta
double theta() const
CLHEP::HepLorentzVector::boostVector
Hep3Vector boostVector() const
Definition: LorentzVector.cc:177
CLHEP::HepLorentzVector::vect
Hep3Vector vect() const
CLHEP::HepLorentzVector::rotateZ
HepLorentzVector & rotateZ(double)
Definition: LorentzVector.cc:80
CLHEP::HepLorentzVector::perp2
double perp2() const
CLHEP::HepLorentzVector::rotateY
HepLorentzVector & rotateY(double)
Definition: LorentzVector.cc:76
CLHEP::HepLorentzVector::transform
HepLorentzVector & transform(const HepRotation &)
G4AntiNeutron::AntiNeutron
static G4AntiNeutron * AntiNeutron()
Definition: G4AntiNeutron.cc:103
G4AntiProton::AntiProton
static G4AntiProton * AntiProton()
Definition: G4AntiProton.cc:93
G4DiffractiveExcitation::ExciteParticipants
virtual G4bool ExciteParticipants(G4VSplitableHadron *aPartner, G4VSplitableHadron *bPartner, G4FTFParameters *theParameters, G4ElasticHNScattering *theElastic) const
Definition: G4DiffractiveExcitation.cc:74
G4DiffractiveExcitation::CreateStrings
virtual void CreateStrings(G4VSplitableHadron *aHadron, G4bool isProjectile, G4ExcitedString *&FirstString, G4ExcitedString *&SecondString, G4FTFParameters *theParameters) const
Definition: G4DiffractiveExcitation.cc:1076
G4ElasticHNScattering::ElasticScattering
virtual G4bool ElasticScattering(G4VSplitableHadron *aPartner, G4VSplitableHadron *bPartner, G4FTFParameters *theParameters) const
Definition: G4ElasticHNScattering.cc:57
G4FTFAnnihilation::Annihilate
virtual G4bool Annihilate(G4VSplitableHadron *aPartner, G4VSplitableHadron *bPartner, G4VSplitableHadron *&AdditionalString, G4FTFParameters *theParameters) const
Definition: G4FTFAnnihilation.cc:76
G4FTFModel::GetWoundedNucleus
G4V3DNucleus * GetWoundedNucleus() const
Definition: G4FTFModel.hh:121
G4FTFModel::Init
void Init(const G4Nucleus &aNucleus, const G4DynamicParticle &aProjectile)
Definition: G4FTFModel.cc:112
G4FTFModel::G4FTFModel
G4FTFModel(const G4String &modelName="FTF")
Definition: G4FTFModel.cc:56
G4FTFModel::ModelDescription
virtual void ModelDescription(std::ostream &) const
Definition: G4FTFModel.cc:1745
G4FTFModel::GetStrings
G4ExcitedStringVector * GetStrings()
Definition: G4FTFModel.cc:206
G4FTFParameters::GetProbabilityOfAnnihilation
G4double GetProbabilityOfAnnihilation()
Definition: G4FTFParameters.hh:354
G4FTFParameters::GetMaxNumberOfCollisions
G4double GetMaxNumberOfCollisions()
Definition: G4FTFParameters.hh:387
G4FTFParameters::GetPt2ofNuclearDestruction
G4double GetPt2ofNuclearDestruction()
Definition: G4FTFParameters.hh:399
G4FTFParameters::GetMaxPt2ofNuclearDestruction
G4double GetMaxPt2ofNuclearDestruction()
Definition: G4FTFParameters.hh:400
G4FTFParameters::GetProbabilityOfElasticScatt
G4double GetProbabilityOfElasticScatt()
Definition: G4FTFParameters.hh:345
G4FTFParameters::GetExcitationEnergyPerWoundedNucleon
G4double GetExcitationEnergyPerWoundedNucleon()
Definition: G4FTFParameters.hh:393
G4FTFParameters::GetProbOfInteraction
G4double GetProbOfInteraction()
Definition: G4FTFParameters.hh:388
G4FTFParameters::GetDofNuclearDestruction
G4double GetDofNuclearDestruction()
Definition: G4FTFParameters.hh:397
G4FTFParameters::GetR2ofNuclearDestruction
G4double GetR2ofNuclearDestruction()
Definition: G4FTFParameters.hh:391
G4FTFParameters::GetCofNuclearDestruction
G4double GetCofNuclearDestruction()
Definition: G4FTFParameters.hh:390
G4FTFParticipants::SetProjectileNucleus
void SetProjectileNucleus(G4V3DNucleus *aNucleus)
Definition: G4FTFParticipants.cc:75
G4FTFParticipants::GetProjectileNucleus
G4V3DNucleus * GetProjectileNucleus()
Definition: G4FTFParticipants.cc:82
G4FTFParticipants::GetList
void GetList(const G4ReactionProduct &thePrimary, G4FTFParameters *theParameters)
Definition: G4FTFParticipants.cc:94
G4FTFParticipants::InitProjectileNucleus
void InitProjectileNucleus(G4int theZ, G4int theA)
Definition: G4FTFParticipants.cc:87
G4FTFParticipants::theProjectileNucleus
G4V3DNucleus * theProjectileNucleus
Definition: G4FTFParticipants.hh:74
G4FTFParticipants::GetInteraction
G4InteractionContent & GetInteraction()
Definition: G4FTFParticipants.hh:103
G4InteractionContent::GetTargetNucleon
G4Nucleon * GetTargetNucleon() const
Definition: G4InteractionContent.hh:135
G4InteractionContent::GetProjectile
G4VSplitableHadron * GetProjectile() const
Definition: G4InteractionContent.hh:115
G4InteractionContent::SetStatus
void SetStatus(G4int aValue)
Definition: G4InteractionContent.cc:63
G4InteractionContent::GetTarget
G4VSplitableHadron * GetTarget() const
Definition: G4InteractionContent.hh:120
G4IonTable::GetIonMass
G4double GetIonMass(G4int Z, G4int A, G4int L=0) const
!! Only ground states are supported now
Definition: G4IonTable.cc:774
G4Nucleon::AreYouHit
G4bool AreYouHit() const
Definition: G4Nucleon.hh:97
G4Nucleon::SetMomentum
void SetMomentum(G4LorentzVector &aMomentum)
Definition: G4Nucleon.hh:70
G4Nucleon::GetSplitableHadron
G4VSplitableHadron * GetSplitableHadron() const
Definition: G4Nucleon.hh:96
G4Nucleon::Get4Momentum
virtual const G4LorentzVector & Get4Momentum() const
Definition: G4Nucleon.hh:72
G4Nucleon::Hit
void Hit(G4VSplitableHadron *aHit)
Definition: G4Nucleon.hh:90
G4Nucleon::GetPosition
virtual const G4ThreeVector & GetPosition() const
Definition: G4Nucleon.hh:68
G4Nucleon::SetParticleType
void SetParticleType(G4Proton *aProton)
Definition: G4Nucleon.hh:77
G4Nucleon::SetBindingEnergy
void SetBindingEnergy(G4double anEnergy)
Definition: G4Nucleon.hh:74
G4Nucleon::GetDefinition
virtual G4ParticleDefinition * GetDefinition() const
Definition: G4Nucleon.hh:85
G4Nucleus::GetA_asInt
G4int GetA_asInt() const
Definition: G4Nucleus.hh:109
G4Nucleus::GetZ_asInt
G4int GetZ_asInt() const
Definition: G4Nucleus.hh:115
G4ParticleDefinition::GetPDGCharge
G4double GetPDGCharge() const
Definition: G4ParticleDefinition.hh:119
G4ParticleTable::FindParticle
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
Definition: G4ParticleTable.cc:472
G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition: G4ParticleTable.cc:63
G4ParticleTable::GetIonTable
G4IonTable * GetIonTable()
G4ReactionProduct::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4ReactionProduct.hh:123
G4ReactionProduct::GetTotalEnergy
G4double GetTotalEnergy() const
Definition: G4ReactionProduct.hh:126
G4ReactionProduct::GetMomentum
G4ThreeVector GetMomentum() const
Definition: G4ReactionProduct.hh:120
G4ReactionProduct::GetDefinition
G4ParticleDefinition * GetDefinition() const
Definition: G4ReactionProduct.hh:104
G4V3DNucleus::GetNextNucleon
virtual G4Nucleon * GetNextNucleon()=0
G4V3DNucleus::GetCharge
virtual G4int GetCharge()=0
G4V3DNucleus::StartLoop
virtual G4bool StartLoop()=0
G4V3DNucleus::DoLorentzBoost
virtual void DoLorentzBoost(const G4LorentzVector &theBoost)=0
G4V3DNucleus::GetMassNumber
virtual G4int GetMassNumber()=0
G4VHighEnergyGenerator::SetEnergyMomentumCheckLevels
void SetEnergyMomentumCheckLevels(G4double relativeLevel, G4double AbsoluteLevel)
Definition: G4VHighEnergyGenerator.cc:49
G4VParticipants::Init
virtual void Init(G4int theZ, G4int theA)
Definition: G4VParticipants.cc:55
G4VParticipants::theNucleus
G4V3DNucleus * theNucleus
Definition: G4VParticipants.hh:65
G4VParticipants::GetWoundedNucleus
virtual G4V3DNucleus * GetWoundedNucleus() const
Definition: G4VParticipants.hh:73
G4VPartonStringModel::SetThisPointer
void SetThisPointer(G4VPartonStringModel *aPointer)
Definition: G4VPartonStringModel.hh:92
G4VSplitableHadron::SetTimeOfCreation
void SetTimeOfCreation(G4double aTime)
Definition: G4VSplitableHadron.hh:152
G4VSplitableHadron::SetStatus
void SetStatus(const G4int aStatus)
Definition: G4VSplitableHadron.hh:172
G4VSplitableHadron::GetDefinition
G4ParticleDefinition * GetDefinition() const
Definition: G4VSplitableHadron.hh:142
G4VSplitableHadron::Set4Momentum
void Set4Momentum(const G4LorentzVector &a4Momentum)
Definition: G4VSplitableHadron.hh:127
G4VSplitableHadron::Get4Momentum
const G4LorentzVector & Get4Momentum() const
Definition: G4VSplitableHadron.hh:132
G4VSplitableHadron::SetDefinition
void SetDefinition(G4ParticleDefinition *aDefinition)
Definition: G4VSplitableHadron.hh:137
DeleteVSplitableHadron::operator()
void operator()(G4VSplitableHadron *aH)
Definition: G4FTFModel.cc:68
sqr
T sqr(const T &x)
Definition: templates.hh:145