Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/models/parton_string/hadronization/src/G4ExcitedStringDecay.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/hadronization/src/G4ExcitedStringDecay.cc (Version 11.3.0) and /processes/hadronic/models/parton_string/hadronization/src/G4ExcitedStringDecay.cc (Version 9.4.p1)


  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 // Historic fragment from M.Komogorov; clean-u     26 // Historic fragment from M.Komogorov; clean-up still necessary @@@
 27                                                << 
 28 #include "G4ExcitedStringDecay.hh"                 27 #include "G4ExcitedStringDecay.hh"
 29 #include "G4SystemOfUnits.hh"                  << 
 30 #include "G4KineticTrack.hh"                       28 #include "G4KineticTrack.hh"
 31 #include "G4LundStringFragmentation.hh"        << 
 32 #include "G4HadronicInteractionRegistry.hh"    << 
 33                                                << 
 34 #include "G4SampleResonance.hh"                << 
 35                                                << 
 36 //#define debug_G4ExcitedStringDecay           << 
 37 //#define debug_G4ExcitedStringCorr            << 
 38                                                    29 
 39 G4ExcitedStringDecay::G4ExcitedStringDecay(G4V <<  30 G4ExcitedStringDecay::G4ExcitedStringDecay()
 40   : G4VStringFragmentation(), theStringDecay(p << 
 41 {                                                  31 {
 42   if(!ptr) {                                   <<  32   theStringDecay=NULL;
 43     G4HadronicInteraction* p =                 << 
 44       G4HadronicInteractionRegistry::Instance( << 
 45     theStringDecay = static_cast<G4VLongitudin << 
 46     if(!theStringDecay) { theStringDecay = new << 
 47   }                                            << 
 48   SetModelName(theStringDecay->GetModelName()) << 
 49 }                                                  33 }
 50                                                    34 
 51 G4ExcitedStringDecay::~G4ExcitedStringDecay()  <<  35 G4ExcitedStringDecay::G4ExcitedStringDecay(G4VLongitudinalStringDecay * aStringDecay)
                                                   >>  36 : theStringDecay(aStringDecay)
 52 {}                                                 37 {}
 53                                                    38 
 54 G4KineticTrackVector *G4ExcitedStringDecay::Fr <<  39 G4ExcitedStringDecay::G4ExcitedStringDecay(const G4ExcitedStringDecay &) : G4VStringFragmentation()
                                                   >>  40 {
                                                   >>  41 } 
                                                   >>  42 
                                                   >>  43 G4ExcitedStringDecay::~G4ExcitedStringDecay()
 55 {                                                  44 {
 56   return theStringDecay->FragmentString(theStr << 
 57 }                                                  45 }
 58                                                    46 
 59 G4KineticTrackVector *G4ExcitedStringDecay::Fr <<  47 const G4ExcitedStringDecay & G4ExcitedStringDecay::operator=(const G4ExcitedStringDecay &)
 60 {                                                  48 {
 61   G4LorentzVector KTsum(0.,0.,0.,0.);          <<  49   throw G4HadronicException(__FILE__, __LINE__, "G4ExcitedStringDecay::operator= meant to not be accessable");
                                                   >>  50   return *this;
                                                   >>  51 }
 62                                                    52 
 63   #ifdef debug_G4ExcitedStringDecay            <<  53 int G4ExcitedStringDecay::operator==(const G4ExcitedStringDecay &) const
 64   G4cout<<G4endl;                              <<  54 {
 65   G4cout<<"--------------------------- G4Excit <<  55   return 0;
 66   G4cout<<"Hadronization of Excited Strings: t <<  56 }
 67   #endif                                       << 
 68                                                    57 
 69   for ( unsigned int astring=0; astring < theS <<  58 int G4ExcitedStringDecay::operator!=(const G4ExcitedStringDecay &) const
 70   // for ( unsigned int astring=0; astring < 1 <<  59 {
 71   {                                            <<  60   return 1;
 72     // G4cout<<"theStrings->operator[](astring <<  61 }
 73     if ( theStrings->operator[](astring)->IsEx << 
 74          {KTsum+= theStrings->operator[](astri << 
 75     else {KTsum+=theStrings->operator[](astrin << 
 76   }                                            << 
 77                                                    62 
 78   G4LorentzRotation toCms( -1 * KTsum.boostVec <<  63 G4KineticTrackVector *G4ExcitedStringDecay::FragmentString
 79   G4LorentzRotation toLab(toCms.inverse());    <<  64         (const G4ExcitedString &theString)
 80   G4LorentzVector Ptmp;                        <<  65 {
 81   KTsum=G4LorentzVector(0.,0.,0.,0.);          <<  66   if ( theStringDecay == NULL ) 
 82                                                    67 
                                                   >>  68       theStringDecay=new G4LundStringFragmentation();
                                                   >>  69     
                                                   >>  70   return theStringDecay->FragmentString(theString);
                                                   >>  71 }
                                                   >>  72   
                                                   >>  73 G4KineticTrackVector *G4ExcitedStringDecay::FragmentStrings
                                                   >>  74         (const G4ExcitedStringVector * theStrings)
                                                   >>  75 {
                                                   >>  76   G4LorentzVector KTsum(0.,0.,0.,0.);
 83   for ( unsigned int astring=0; astring < theS     77   for ( unsigned int astring=0; astring < theStrings->size(); astring++)
 84   // for ( unsigned int astring=0; astring < 1 << 
 85   {                                                78   {
 86     if ( theStrings->operator[](astring)->IsEx <<  79   KTsum+= theStrings->operator[](astring)->Get4Momentum();
 87     {                                          << 
 88       Ptmp=toCms * theStrings->operator[](astr << 
 89       theStrings->operator[](astring)->GetLeft << 
 90                                                << 
 91       Ptmp=toCms * theStrings->operator[](astr << 
 92       theStrings->operator[](astring)->GetRigh << 
 93                                                    80 
 94       KTsum+= theStrings->operator[](astring)- <<  81   if( !(KTsum.e()<1) && !(KTsum.e()>-1) )
 95     }                                          <<  82   {
 96     else                                       <<  83           throw G4HadronicException(__FILE__, __LINE__, 
 97     {                                          <<  84                              "G4ExcitedStringDecay::FragmentStrings received nan string...");
 98       Ptmp=toCms * theStrings->operator[](astr <<  85   }
 99       theStrings->operator[](astring)->GetKine << 
100       KTsum+= theStrings->operator[](astring)- << 
101     }                                          << 
102   }                                                86   }
103                                                    87 
104   G4SampleResonance BrW;                       << 
105   const G4ParticleDefinition* TrackDefinition= << 
106                                                << 
107   G4KineticTrackVector * theResult = new G4Kin     88   G4KineticTrackVector * theResult = new G4KineticTrackVector;
108   G4int attempts(0);                               89   G4int attempts(0);
109   G4bool success=false;                            90   G4bool success=false;
110   G4bool NeedEnergyCorrector=false;            << 
111   do {                                             91   do {
112         #ifdef debug_G4ExcitedStringDecay      << 
113         G4cout<<"New try No "<<attempts<<" to  << 
114         #endif                                 << 
115                                                    92 
116   std::for_each(theResult->begin() , theResult     93   std::for_each(theResult->begin() , theResult->end() , DeleteKineticTrack());
117   theResult->clear();                              94   theResult->clear();
118                                                    95 
119   attempts++;                                      96   attempts++;
120                                                << 
121   G4LorentzVector KTsecondaries(0.,0.,0.,0.);      97   G4LorentzVector KTsecondaries(0.,0.,0.,0.);
122   NeedEnergyCorrector=false;                   <<  98   G4bool NeedEnergyCorrector=false;
123                                                    99 
124   for ( unsigned int astring=0; astring < theS    100   for ( unsigned int astring=0; astring < theStrings->size(); astring++)
125         // for ( unsigned int astring=0; astri << 
126         // for ( unsigned int astring=1; astri << 
127         // for ( unsigned int astring=0; astri << 
128   {                                               101   {
129           #ifdef debug_G4ExcitedStringDecay    << 102 //G4cout<<G4endl<<"String No "<<astring+1<<" "<<theStrings->operator[](astring)->Get4Momentum().mag()<<G4endl;
130           G4cout<<"String No "<<astring+1<<" E << 
131                                                << 
132           G4cout<<"String No "<<astring+1<<" 4 << 
133           <<" "<<theStrings->operator[](astrin << 
134           #endif                               << 
135                                                   103 
136           G4KineticTrackVector * generatedKine    104           G4KineticTrackVector * generatedKineticTracks = NULL;
                                                   >> 105   
137     if ( theStrings->operator[](astring)->IsEx    106     if ( theStrings->operator[](astring)->IsExcited() )
138     {                                             107     {
139              #ifdef debug_G4ExcitedStringDecay << 
140              G4cout<<"Fragment String with par << 
141                    <<theStrings->operator[](as << 
142                    <<theStrings->operator[](as << 
143                    <<"Direction "<<theStrings- << 
144              #endif                            << 
145          generatedKineticTracks=FragmentString    108          generatedKineticTracks=FragmentString(*theStrings->operator[](astring));
146              #ifdef debug_G4ExcitedStringDecay << 
147              G4cout<<"(G4ExcitedStringDecay) N << 
148                    <<generatedKineticTracks->s << 
149              #endif                            << 
150     } else {                                      109     } else {
151              #ifdef debug_G4ExcitedStringDecay << 
152              G4cout<<"   GetTrack from the Str << 
153              #endif                            << 
154              G4LorentzVector Mom=theStrings->o << 
155              G4KineticTrack * aTrack= new G4Ki << 
156                             theStrings->operat << 
157                             theStrings->operat << 
158                             G4ThreeVector(0),  << 
159                                                << 
160              aTrack->SetPosition(theStrings->o << 
161                                                << 
162              #ifdef debug_G4ExcitedStringDecay << 
163              G4cout<<"   A particle stored in  << 
164              #endif                            << 
165                                                << 
166        generatedKineticTracks = new G4KineticT    110        generatedKineticTracks = new G4KineticTrackVector;
167        generatedKineticTracks->push_back(aTrac << 111        generatedKineticTracks->push_back(theStrings->operator[](astring)->GetKineticTrack());
168     }                                             112     }    
169                                                   113 
170     if (generatedKineticTracks == nullptr || g << 114     if (generatedKineticTracks == NULL) 
171     {                                             115     {
172              // G4cerr << "G4VPartonStringMode << 116        G4cerr << "G4VPartonStringModel:No KineticTracks produced" << G4endl;
173        delete generatedKineticTracks;          << 117        continue;
174        generatedKineticTracks = nullptr;       << 
175              continue;                         << 
176     }                                             118     }
177                                                   119 
178           G4LorentzVector KTsum1(0.,0.,0.,0.);    120           G4LorentzVector KTsum1(0.,0.,0.,0.);
179           for ( unsigned int aTrack=0; aTrack<    121           for ( unsigned int aTrack=0; aTrack<generatedKineticTracks->size();aTrack++)
180     {                                             122     {
181              #ifdef debug_G4ExcitedStringDecay << 123 //G4cout<<" Prod part "<<(*generatedKineticTracks)[aTrack]->GetDefinition()->GetParticleName()<<" "<<(*generatedKineticTracks)[aTrack]->Get4Momentum()<<G4endl;
182              G4cout<<"Prod part No. "<<aTrack+ << 
183                    <<(*generatedKineticTracks) << 
184                    <<(*generatedKineticTracks) << 
185                    <<(*generatedKineticTracks) << 
186              #endif                            << 
187              // --------------- Sampling mass  << 
188              TrackDefinition = (*generatedKine << 
189                                                << 
190        if (TrackDefinition->IsShortLived())    << 
191              {                                 << 
192                G4double NewTrackMass =         << 
193                  BrW.SampleMass( TrackDefiniti << 
194                                  BrW.GetMinimu << 
195                                  TrackDefiniti << 
196                G4LorentzVector Tmp=G4LorentzVe << 
197                Tmp.setE(std::sqrt(sqr(NewTrack << 
198                                                << 
199                (*generatedKineticTracks)[aTrac << 
200                                                << 
201                #ifdef debug_G4ExcitedStringDec << 
202                G4cout<<"Resonance *** "<<aTrac << 
203                      <<(*generatedKineticTrack << 
204                      <<(*generatedKineticTrack << 
205                      <<(*generatedKineticTrack << 
206                #endif                          << 
207            }                                   << 
208              //------------------------------- << 
209                                                << 
210              theResult->push_back(generatedKin    124              theResult->push_back(generatedKineticTracks->operator[](aTrack));
211              KTsum1+= (*generatedKineticTracks    125              KTsum1+= (*generatedKineticTracks)[aTrack]->Get4Momentum();
212     }                                             126     }
213     KTsecondaries+=KTsum1;                        127     KTsecondaries+=KTsum1;
214                                                   128   
215           #ifdef debug_G4ExcitedStringDecay    << 129     if  ( KTsum1.e() > 0 && std::abs((KTsum1.e()-theStrings->operator[](astring)->Get4Momentum().e()) / KTsum1.e()) > perMillion ) 
216           G4cout << "String secondaries(" <<ge << 
217                  <<"Init  string  momentum: "< << 
218                  <<"Final hadrons momentum: "< << 
219           #endif                               << 
220                                                << 
221     if  ( KTsum1.e() > 0 &&                    << 
222                 std::abs((KTsum1.e()-theString << 
223     {                                             130     {
                                                   >> 131 //--debug--           G4cout << "String secondaries(" <<generatedKineticTracks->size()<< ")  momentum: " 
                                                   >> 132 //--debug--           << theStrings->operator[](astring)->Get4Momentum() << " " << KTsum1 << G4endl;
224       NeedEnergyCorrector=true;                   133       NeedEnergyCorrector=true;
225     }                                             134     }
226                                                   135 
227           #ifdef debug_G4ExcitedStringDecay    << 136 //        clean up
228           G4cout<<"NeedEnergyCorrection yes/no << 
229           #endif                               << 
230                                                << 
231           // clean up                          << 
232     delete generatedKineticTracks;                137     delete generatedKineticTracks;
233     success=true;                              << 
234   }                                               138   }
                                                   >> 139 //--DEBUG  G4cout << "Strings/secs total  4 momentum " << KTsum << " " <<KTsecondaries << G4endl;
235                                                   140 
                                                   >> 141         success=true;
236   if ( NeedEnergyCorrector ) success=EnergyAnd    142   if ( NeedEnergyCorrector ) success=EnergyAndMomentumCorrector(theResult, KTsum);
237   } while (!success && (attempts < 100));  /*  << 
238                                                   143 
239   for ( unsigned int aTrack=0; aTrack<theResul << 144   } while(!success && (attempts < 100));
240   {                                            << 
241     Ptmp=(*theResult)[aTrack]->Get4Momentum(); << 
242     Ptmp.transform( toLab);                    << 
243     (*theResult)[aTrack]->Set4Momentum(Ptmp);  << 
244   }                                            << 
245                                                << 
246   #ifdef debug_G4ExcitedStringDecay            << 
247   G4cout<<"End of the strings fragmentation (G << 
248                                                << 
249   G4LorentzVector  KTsum1(0.,0.,0.,0.);        << 
250                                                   145 
                                                   >> 146 #ifdef debug_ExcitedStringDecay
                                                   >> 147   G4LorentzVector  KTsum1=0;
251   for ( unsigned int aTrack=0; aTrack<theResul    148   for ( unsigned int aTrack=0; aTrack<theResult->size();aTrack++)
252   {                                               149   {
253       G4cout << " corrected tracks .. " << (*t    150       G4cout << " corrected tracks .. " << (*theResult)[aTrack]->GetDefinition()->GetParticleName()
254       <<"  " << (*theResult)[aTrack]->Get4Mome << 151       <<"  " << (*theResult)[aTrack]->Get4Momentum() << G4endl;
255       <<"  " << (*theResult)[aTrack]->Get4Mome << 
256       KTsum1+= (*theResult)[aTrack]->Get4Momen    152       KTsum1+= (*theResult)[aTrack]->Get4Momentum();
257   }                                               153   }
258                                                << 154   G4cout << "Needcorrector/success " << NeedEnergyCorrector << "/" << success << ", Corrected total  4 momentum " << KTsum1  << G4endl;
259   G4cout << "Needcorrector/success " << NeedEn << 
260          << ", Corrected total  4 momentum " < << 
261   if ( ! success ) G4cout << "failed to correc    155   if ( ! success ) G4cout << "failed to correct E/p" << G4endl;  
                                                   >> 156 #endif
262                                                   157 
263   G4cout<<"End of the Hadronization (G4Excited << 
264   #endif                                       << 
265                                                << 
266   if (!success)                                << 
267   {                                            << 
268     if (theResult->size() != 0)                << 
269     {                                          << 
270       std::for_each(theResult->begin() , theRe << 
271       theResult->clear();                      << 
272       delete theResult; theResult=0;           << 
273     }                                          << 
274     for ( unsigned int astring=0; astring < th << 
275     // for ( unsigned int astring=0; astring < << 
276     {                                          << 
277       if ( theStrings->operator[](astring)->Is << 
278       {                                        << 
279         Ptmp=theStrings->operator[](astring)-> << 
280         Ptmp.transform( toLab);                << 
281         theStrings->operator[](astring)->GetLe << 
282                                                << 
283         Ptmp=theStrings->operator[](astring)-> << 
284         Ptmp.transform( toLab);                << 
285         theStrings->operator[](astring)->GetRi << 
286       }                                        << 
287       else                                     << 
288       {                                        << 
289         Ptmp=theStrings->operator[](astring)-> << 
290         Ptmp.transform( toLab);                << 
291         theStrings->operator[](astring)->GetKi << 
292       }                                        << 
293     }                                          << 
294   }                                            << 
295   return theResult;                               158   return theResult;
296 }                                                 159 }
297                                                   160 
298                                                << 161 G4bool G4ExcitedStringDecay::EnergyAndMomentumCorrector
299 G4bool G4ExcitedStringDecay::                  << 162     (G4KineticTrackVector* Output, G4LorentzVector& TotalCollisionMom)   
300 EnergyAndMomentumCorrector(G4KineticTrackVecto << 163   {
301 {                                              << 
302     const int    nAttemptScale = 500;             164     const int    nAttemptScale = 500;
303     const double ErrLimit = 1.E-5;                165     const double ErrLimit = 1.E-5;
304     if (Output->empty()) return TRUE;          << 166     if (Output->empty())
                                                   >> 167        return TRUE;
305     G4LorentzVector SumMom;                       168     G4LorentzVector SumMom;
306     G4double        SumMass = 0;               << 169     G4double        SumMass = 0;     
307     G4double        TotalCollisionMass = Total    170     G4double        TotalCollisionMass = TotalCollisionMom.m();
308                                                   171 
309     std::vector<G4double> HadronMass; G4double << 172     if( !(TotalCollisionMass<1) && !(TotalCollisionMass>-1) )
                                                   >> 173     {
                                                   >> 174       std::cout << "TotalCollisionMomentum = "<<TotalCollisionMom<<G4endl;
                                                   >> 175       throw G4HadronicException(__FILE__, __LINE__, "G4ExcitedStringDecay received nan mass...");
                                                   >> 176     }
310                                                   177 
311     #ifdef debug_G4ExcitedStringCorr           << 178 //G4cout<<G4endl<<"EnergyAndMomentumCorrector "<<Output->size()<<G4endl;
312     G4cout<<G4endl<<"EnergyAndMomentumCorrecto << 
313     #endif                                     << 
314     // Calculate sum hadron 4-momenta and summ    179     // Calculate sum hadron 4-momenta and summing hadron mass
315     unsigned int cHadron;                         180     unsigned int cHadron;
316     for (cHadron = 0; cHadron < Output->size() << 181     for(cHadron = 0; cHadron < Output->size(); cHadron++)
317     {                                             182     {
318         SumMom  += Output->operator[](cHadron)    183         SumMom  += Output->operator[](cHadron)->Get4Momentum();
319         HadronM=Output->operator[](cHadron)->G << 184   if( !(SumMom<1) && !(SumMom>-1) )
320         SumMass += Output->operator[](cHadron) << 185   {
                                                   >> 186           throw G4HadronicException(__FILE__, __LINE__, "G4ExcitedStringDecay::EnergyAndMomentumCorrector() received nan momentum...");
                                                   >> 187   }
                                                   >> 188         SumMass += Output->operator[](cHadron)->GetDefinition()->GetPDGMass();
                                                   >> 189   if( !(SumMass<1) && !(SumMass>-1) )
                                                   >> 190   {
                                                   >> 191           throw G4HadronicException(__FILE__, __LINE__, "G4ExcitedStringDecay::EnergyAndMomentumCorrector() received nan mass...");
                                                   >> 192   }
321     }                                             193     }
322                                                   194 
323     #ifdef debug_G4ExcitedStringCorr           << 195 //G4cout<<"SumMass TotalCollisionMass "<<SumMass<<" "<<TotalCollisionMass<<G4endl;
324     G4cout<<"Sum part mom "<<SumMom<<" "<<SumM << 
325           <<"Sum str  mom "<<TotalCollisionMom << 
326     G4cout<<"SumMass TotalCollisionMass "<<Sum << 
327     #endif                                     << 
328                                                   196 
329     // Cannot correct a single particle           197     // Cannot correct a single particle
330     if (Output->size() < 2) return FALSE;         198     if (Output->size() < 2) return FALSE;
331                                                   199 
332     if (SumMass > TotalCollisionMass) return F    200     if (SumMass > TotalCollisionMass) return FALSE;
333     SumMass = SumMom.m2();                        201     SumMass = SumMom.m2();
334     if (SumMass < 0) return FALSE;                202     if (SumMass < 0) return FALSE;
335     SumMass = std::sqrt(SumMass);                 203     SumMass = std::sqrt(SumMass);
336                                                   204 
337     // Compute c.m.s. hadron velocity and boos << 205      // Compute c.m.s. hadron velocity and boost KTV to hadron c.m.s.
338     // G4ThreeVector Beta = -SumMom.boostVecto << 206     G4ThreeVector Beta = -SumMom.boostVector();
339     G4ThreeVector Beta = -TotalCollisionMom.bo << 
340     Output->Boost(Beta);                          207     Output->Boost(Beta);
341                                                   208 
342     // Scale total c.m.s. hadron energy (hadro    209     // Scale total c.m.s. hadron energy (hadron system mass).
343     // It should be equal interaction mass        210     // It should be equal interaction mass
344     G4double Scale = 1;                           211     G4double Scale = 1;
345     G4int cAttempt = 0;                           212     G4int cAttempt = 0;
346     G4double Sum = 0;                             213     G4double Sum = 0;
347     G4bool success = false;                       214     G4bool success = false;
348     for (cAttempt = 0; cAttempt < nAttemptScal << 215     for(cAttempt = 0; cAttempt < nAttemptScale; cAttempt++)
349     {                                             216     {
350       Sum = 0;                                    217       Sum = 0;
351       for (cHadron = 0; cHadron < Output->size << 218       for(cHadron = 0; cHadron < Output->size(); cHadron++)
352       {                                           219       {
353         HadronM = HadronMass.at(cHadron);      << 
354         G4LorentzVector HadronMom = Output->op    220         G4LorentzVector HadronMom = Output->operator[](cHadron)->Get4Momentum();
355         HadronMom.setVect(Scale*HadronMom.vect    221         HadronMom.setVect(Scale*HadronMom.vect());
356         G4double E = std::sqrt(HadronMom.vect( << 222         G4double E = std::sqrt(HadronMom.vect().mag2() + sqr(Output->operator[](cHadron)->GetDefinition()->GetPDGMass()));
357                                                << 
358         HadronMom.setE(E);                        223         HadronMom.setE(E);
359         Output->operator[](cHadron)->Set4Momen    224         Output->operator[](cHadron)->Set4Momentum(HadronMom);
360         Sum += E;                                 225         Sum += E;
361       }                                           226       } 
362       Scale = TotalCollisionMass/Sum;          << 227       Scale = TotalCollisionMass/Sum;    
363       #ifdef debug_G4ExcitedStringCorr         << 228 #ifdef debug_G4ExcitedStringDecay 
364       G4cout << "Scale-1=" << Scale -1            229       G4cout << "Scale-1=" << Scale -1 
365              << ",  TotalCollisionMass=" << To << 230                 << ",  TotalCollisionMass=" << TotalCollisionMass
366              << ",  Sum=" << Sum               << 231     << ",  Sum=" << Sum
367        << G4endl;                              << 232     << G4endl;
368       #endif                                   << 233 #endif     
369       if (std::fabs(Scale - 1) <= ErrLimit)       234       if (std::fabs(Scale - 1) <= ErrLimit) 
370       {                                           235       {
371         success = true;                           236         success = true;
372   break;                                          237   break;
373       }                                           238       }
374     }                                             239     }
375                                                << 240 #ifdef debug_G4ExcitedStringDecay     
376     #ifdef debug_G4ExcitedStringCorr           << 241     if(!success)
377     if (!success)                              << 
378     {                                             242     {
379       G4cout << "G4ExcitedStringDecay::EnergyA    243       G4cout << "G4ExcitedStringDecay::EnergyAndMomentumCorrector - Warning"<<G4endl;
380       G4cout << "   Scale not unity at end of     244       G4cout << "   Scale not unity at end of iteration loop: "<<TotalCollisionMass<<" "<<Sum<<" "<<Scale<<G4endl;
381       G4cout << "   Number of secondaries: " <    245       G4cout << "   Number of secondaries: " << Output->size() << G4endl;
382       G4cout << "   Wanted total energy: " <<     246       G4cout << "   Wanted total energy: " <<  TotalCollisionMom.e() << G4endl; 
383       G4cout << "   Increase number of attempt    247       G4cout << "   Increase number of attempts or increase ERRLIMIT"<<G4endl;
384       // throw G4HadronicException(__FILE__, _ << 248 //       throw G4HadronicException(__FILE__, __LINE__, "G4ExcitedStringDecay failed to correct...");
385     }                                             249     }
386     #endif                                     << 250 #endif     
387                                                << 
388     // Compute c.m.s. interaction velocity and    251     // Compute c.m.s. interaction velocity and KTV back boost   
389     Beta = TotalCollisionMom.boostVector();       252     Beta = TotalCollisionMom.boostVector();
390     Output->Boost(Beta);                          253     Output->Boost(Beta);
391                                                   254 
392     return success;                               255     return success;
393 }                                              << 256   }
394                                                << 
395                                                   257