Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/models/parton_string/diffraction/src/G4FTFParticipants.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/hadronic/models/parton_string/diffraction/src/G4FTFParticipants.cc (Version 11.3.0) and /processes/hadronic/models/parton_string/diffraction/src/G4FTFParticipants.cc (Version 10.6.p3)


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