Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/models/parton_string/hadronization/src/G4FragmentingString.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/G4FragmentingString.cc (Version 11.3.0) and /processes/hadronic/models/parton_string/hadronization/src/G4FragmentingString.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 //                                                 26 //
 27                                                    27 
 28                                                    28 
 29 // -------------------------------------------     29 // ------------------------------------------------------------
 30 //      GEANT 4 class implementation file          30 //      GEANT 4 class implementation file
 31 //                                                 31 //
 32 //      ---------------- G4FragmentingString -     32 //      ---------------- G4FragmentingString ----------------
 33 //             by Gunter Folger, September 200     33 //             by Gunter Folger, September 2001.
 34 //       class for an excited string used in F     34 //       class for an excited string used in Fragmention
 35 // -------------------------------------------     35 // ------------------------------------------------------------
 36                                                    36 
 37                                                    37 
 38 // G4FragmentingString                             38 // G4FragmentingString
 39 #include "G4FragmentingString.hh"                  39 #include "G4FragmentingString.hh"
 40 #include "G4ExcitedString.hh"                      40 #include "G4ExcitedString.hh"
 41                                                    41 
 42 //--------------------------------------------     42 //---------------------------------------------------------------------------------
 43                                                    43 
 44 //--------------------------------------------     44 //---------------------------------------------------------------------------------
 45                                                    45 
 46 G4FragmentingString::G4FragmentingString(const     46 G4FragmentingString::G4FragmentingString(const G4FragmentingString &old)
 47 {                                                  47 {
 48   LeftParton=old.LeftParton;                       48   LeftParton=old.LeftParton;
 49   RightParton=old.RightParton;                     49   RightParton=old.RightParton;
 50   Ptleft=old.Ptleft;                               50   Ptleft=old.Ptleft;
 51   Ptright=old.Ptright;                             51   Ptright=old.Ptright;
 52   Pplus=old.Pplus;                                 52   Pplus=old.Pplus;
 53   Pminus=old.Pminus;                               53   Pminus=old.Pminus;
 54   theStableParton=old.theStableParton;         << 
 55   theDecayParton=old.theDecayParton;           << 
 56   decaying=old.decaying;                           54   decaying=old.decaying;
 57         Pstring=old.Pstring;                   << 
 58         Pleft  =old.Pleft;                     << 
 59         Pright =old.Pright;                    << 
 60 }                                              << 
 61                                                << 
 62 G4FragmentingString & G4FragmentingString::ope << 
 63 {                                              << 
 64    if (this != &old)                           << 
 65    {                                           << 
 66      LeftParton=old.LeftParton;                << 
 67      RightParton=old.RightParton;              << 
 68      Ptleft=old.Ptleft;                        << 
 69      Ptright=old.Ptright;                      << 
 70      Pplus=old.Pplus;                          << 
 71      Pminus=old.Pminus;                        << 
 72      theStableParton=old.theStableParton;      << 
 73      theDecayParton=old.theDecayParton;        << 
 74      decaying=old.decaying;                    << 
 75      Pstring=old.Pstring;                      << 
 76      Pleft  =old.Pleft;                        << 
 77      Pright =old.Pright;                       << 
 78    }                                           << 
 79    return *this;                               << 
 80 }                                                  55 }
 81                                                    56 
 82 //--------------------------------------------     57 //---------------------------------------------------------------------------------
 83                                                    58 
 84 G4FragmentingString::G4FragmentingString(const     59 G4FragmentingString::G4FragmentingString(const G4ExcitedString &excited)
 85 {                                                  60 {
 86   LeftParton=excited.GetLeftParton()->GetDefin     61   LeftParton=excited.GetLeftParton()->GetDefinition();
 87   RightParton=excited.GetRightParton()->GetDef     62   RightParton=excited.GetRightParton()->GetDefinition();
 88   Ptleft=excited.GetLeftParton()->Get4Momentum     63   Ptleft=excited.GetLeftParton()->Get4Momentum().vect();
 89   Ptleft.setZ(0.);                                 64   Ptleft.setZ(0.);
 90   Ptright=excited.GetRightParton()->Get4Moment     65   Ptright=excited.GetRightParton()->Get4Momentum().vect();
 91   Ptright.setZ(0.);                                66   Ptright.setZ(0.);
 92   theStableParton=0;                           <<  67   G4LorentzVector P=excited.Get4Momentum();
 93   theDecayParton=0;                            <<  68   Pplus =P.e() + P.pz();
 94                                                <<  69   Pminus=P.e() - P.pz();
 95         if (excited.GetDirection() > 0) {decay <<  70   decaying=None;
 96         else                            {decay << 
 97                                                << 
 98         Pleft  = excited.GetLeftParton()->Get4 << 
 99         Pright = excited.GetRightParton()->Get << 
100         Pstring= Pleft + Pright;               << 
101                                                << 
102         Pplus  = Pstring.plus();               << 
103         Pminus = Pstring.minus();              << 
104 }                                                  71 }
105                                                    72 
106 //--------------------------------------------     73 //---------------------------------------------------------------------------------
107                                                    74 
108 G4FragmentingString::G4FragmentingString(const     75 G4FragmentingString::G4FragmentingString(const G4FragmentingString &old,
109            G4ParticleDefinition * newdecay,        76            G4ParticleDefinition * newdecay,
110            const G4LorentzVector *momentum)        77            const G4LorentzVector *momentum)
111 {                                                  78 {
112   decaying=None;                                   79   decaying=None;
113   // Momentum of produced hadron               <<  80   if ( old.decaying == Left )
114         G4LorentzVector Momentum = G4LorentzVe <<  81   {
115                                                <<  82     RightParton= old.RightParton;
116         if ( old.decaying == Left )            <<  83     Ptright    = old.Ptright;
117         {                                      <<  84     LeftParton = newdecay;
118                 RightParton= old.RightParton;  <<  85     Ptleft     = old.Ptleft - momentum->vect();
119                 Ptright    = old.Ptright;      <<  86     Ptleft.setZ(0.);
120                 Pright     = old.Pright;       <<  87   } else if ( old.decaying == Right )
121                                                <<  88   {
122                 LeftParton = newdecay;         <<  89     RightParton = newdecay;
123                 Ptleft     = old.Ptleft - mome <<  90     Ptright     = old.Ptright - momentum->vect();
124                 Ptleft.setZ(0.);               <<  91     Ptright.setZ(0.);
125                 Pleft = old.Pleft - Momentum;  <<  92     LeftParton  = old.LeftParton;
126                                                <<  93     Ptleft      = old.Ptleft;
127                 Pstring = Pleft + Pright;      <<  94   } else
128                 Pplus   = Pstring.plus();      << 
129                 Pminus  = Pstring.minus();     << 
130                                                << 
131                 theDecayParton=GetLeftParton() << 
132                 theStableParton=GetRightParton << 
133                 decaying = Left;               << 
134         } else if ( old.decaying == Right )    << 
135         {                                      << 
136           RightParton = newdecay;              << 
137                 Ptright     = old.Ptright - mo << 
138                 Ptright.setZ(0.);              << 
139                 Pright = old.Pright - Momentum << 
140                                                << 
141                 LeftParton  = old.LeftParton;  << 
142                 Ptleft      = old.Ptleft;      << 
143                 Pleft  = old.Pleft;            << 
144                                                << 
145                 Pstring = Pleft + Pright;      << 
146                 Pplus   = Pstring.plus();      << 
147                 Pminus  = Pstring.minus();     << 
148                                                << 
149                 theDecayParton=GetRightParton( << 
150                 theStableParton=GetLeftParton( << 
151                 decaying = Right;              << 
152         } else                                 << 
153   {                                                95   {
154     throw G4HadronicException(__FILE__, __LINE <<  96     throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::G4FragmentingString: no decay Direction defined");
155                   "G4FragmentingString::G4Frag << 
156   }                                                97   }
                                                   >>  98   Pplus  = old.Pplus  - (momentum->e() + momentum->pz());
                                                   >>  99   Pminus = old.Pminus - (momentum->e() - momentum->pz());
                                                   >> 100   
                                                   >> 101   //G4double Eold=0.5 * (old.Pplus + old.Pminus);
                                                   >> 102   //G4double Enew=0.5 * (Pplus + Pminus);
157 }                                                 103 }
158                                                   104 
159                                                   105 
160 //--------------------------------------------    106 //---------------------------------------------------------------------------------
161                                                   107 
162 G4FragmentingString::G4FragmentingString(const    108 G4FragmentingString::G4FragmentingString(const G4FragmentingString &old,  
163            G4ParticleDefinition * newdecay)       109            G4ParticleDefinition * newdecay) 
164 {                                                 110 {                                                                         
165   decaying=None;                                  111   decaying=None;                                                    
166                                                << 
167         Ptleft.setX(0.);  Ptleft.setY(0.);  Pt << 
168         Ptright.setX(0.); Ptright.setY(0.); Pt << 
169         Pplus=0.; Pminus=0.;                   << 
170         theStableParton=0; theDecayParton=0;   << 
171                                                << 
172         Pstring=G4LorentzVector(0.,0.,0.,0.);  << 
173         Pleft  =G4LorentzVector(0.,0.,0.,0.);  << 
174         Pright =G4LorentzVector(0.,0.,0.,0.);  << 
175                                                << 
176   if ( old.decaying == Left )                     112   if ( old.decaying == Left )                                       
177   {                                               113   {                                                                 
178     RightParton= old.RightParton;                 114     RightParton= old.RightParton;                             
179     LeftParton = newdecay;                        115     LeftParton = newdecay;                                    
180                 decaying=Left;                 << 
181   } else if ( old.decaying == Right )             116   } else if ( old.decaying == Right )                               
182   {                                               117   {                                                                 
183     RightParton = newdecay;                       118     RightParton = newdecay;                                   
184     LeftParton  = old.LeftParton;                 119     LeftParton  = old.LeftParton;                             
185                 decaying=Right;                << 
186   } else                                          120   } else                                                            
187   {                                               121   {
188     throw G4HadronicException(__FILE__, __LINE << 122     throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::G4FragmentingString: no decay Direction defined");
189                   "G4FragmentingString::G4Frag << 
190   }                                               123   }
191 }                                                 124 }
192                                                   125 
193                                                   126 
194 //--------------------------------------------    127 //---------------------------------------------------------------------------------
195                                                   128 
196 G4FragmentingString::~G4FragmentingString()       129 G4FragmentingString::~G4FragmentingString()
197 {}                                                130 {}
198                                                   131 
                                                   >> 132 
199 //--------------------------------------------    133 //---------------------------------------------------------------------------------
200                                                   134 
201 void G4FragmentingString::SetLeftPartonStable(    135 void G4FragmentingString::SetLeftPartonStable()
202 {                                                 136 {
203      theStableParton=GetLeftParton();             137      theStableParton=GetLeftParton();
204      theDecayParton=GetRightParton();             138      theDecayParton=GetRightParton();
205      decaying=Right;                              139      decaying=Right;
206 }                                                 140 }
207                                                   141 
208 //--------------------------------------------    142 //---------------------------------------------------------------------------------
209                                                   143 
210 void G4FragmentingString::SetRightPartonStable    144 void G4FragmentingString::SetRightPartonStable()
211 {                                                 145 {
212      theStableParton=GetRightParton();            146      theStableParton=GetRightParton();
213      theDecayParton=GetLeftParton();              147      theDecayParton=GetLeftParton();
214      decaying=Left;                               148      decaying=Left;
215 }                                                 149 }
216                                                   150 
217 //--------------------------------------------    151 //---------------------------------------------------------------------------------
218                                                   152 
219 G4int G4FragmentingString::GetDecayDirection()    153 G4int G4FragmentingString::GetDecayDirection() const
220 {                                                 154 {
221   if      (decaying == Left ) return +1;          155   if      (decaying == Left ) return +1;
222   else if (decaying == Right) return -1;          156   else if (decaying == Right) return -1;
223   else throw G4HadronicException(__FILE__, __L << 157   else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::GetDecayDirection: decay side UNdefined!");
224                "G4FragmentingString::GetDecayD << 
225   return 0;                                       158   return 0;
226 }                                                 159 }
227                                                   160  
228 //--------------------------------------------    161 //---------------------------------------------------------------------------------
229                                                   162 
230 G4bool G4FragmentingString::IsAFourQuarkString << 163 G4bool G4FragmentingString::FourQuarkString() const
231 {                                                 164 {
232   return   LeftParton->GetParticleSubType()==     165   return   LeftParton->GetParticleSubType()== "di_quark" 
233        && RightParton->GetParticleSubType()==     166        && RightParton->GetParticleSubType()== "di_quark";
234 }                                                 167 }
235                                                   168 
236 //--------------------------------------------    169 //---------------------------------------------------------------------------------
237                                                   170 
238 G4bool G4FragmentingString::DecayIsQuark()        171 G4bool G4FragmentingString::DecayIsQuark()
239 {                                                 172 {
240   return theDecayParton->GetParticleSubType()=    173   return theDecayParton->GetParticleSubType()== "quark";
241 }                                                 174 }
242                                                   175 
243 G4bool G4FragmentingString::StableIsQuark()       176 G4bool G4FragmentingString::StableIsQuark()
244 {                                                 177 {
245   return theStableParton->GetParticleSubType()    178   return theStableParton->GetParticleSubType()== "quark";
246 }                                                 179 }
247                                                   180 
248 //--------------------------------------------    181 //---------------------------------------------------------------------------------
249                                                   182 
250 G4ThreeVector G4FragmentingString::StablePt()     183 G4ThreeVector G4FragmentingString::StablePt()
251 {                                                 184 {
252   if (decaying == Left ) return Ptright;          185   if (decaying == Left ) return Ptright;
253   else if (decaying == Right ) return Ptleft;     186   else if (decaying == Right ) return Ptleft;
254   else throw G4HadronicException(__FILE__, __L    187   else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::DecayPt: decay side UNdefined!");
255   return G4ThreeVector();                         188   return G4ThreeVector();
256 }                                                 189 }
257                                                   190 
258 G4ThreeVector G4FragmentingString::DecayPt()      191 G4ThreeVector G4FragmentingString::DecayPt()
259 {                                                 192 {
260   if (decaying == Left ) return Ptleft;           193   if (decaying == Left ) return Ptleft;
261   else if (decaying == Right ) return Ptright;    194   else if (decaying == Right ) return Ptright;
262   else throw G4HadronicException(__FILE__, __L    195   else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::DecayPt: decay side UNdefined!");
263   return G4ThreeVector();                         196   return G4ThreeVector();
264 }                                                 197 }
265                                                   198 
266 //--------------------------------------------    199 //---------------------------------------------------------------------------------
267                                                   200 
268 G4double G4FragmentingString::LightConePlus()     201 G4double G4FragmentingString::LightConePlus()
269 {                                                 202 {
270   return Pplus;                                   203   return Pplus;
271 }                                                 204 }
272                                                   205 
273 G4double G4FragmentingString::LightConeMinus()    206 G4double G4FragmentingString::LightConeMinus()
274 {                                                 207 {
275   return Pminus;                                  208   return Pminus;
276 }                                                 209 }
277                                                   210 
278 G4double G4FragmentingString::LightConeDecay()    211 G4double G4FragmentingString::LightConeDecay()
279 {                                                 212 {
280   if (decaying == Left ) return Pplus;            213   if (decaying == Left ) return Pplus;
281   else if (decaying == Right ) return Pminus;     214   else if (decaying == Right ) return Pminus;
282   else throw G4HadronicException(__FILE__, __L    215   else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::DecayPt: decay side UNdefined!");
                                                   >> 216   return 0;
283 }                                                 217 }
284                                                   218 
285 //--------------------------------------------    219 //---------------------------------------------------------------------------------
286                                                   220 
287 G4LorentzVector G4FragmentingString::Get4Momen    221 G4LorentzVector G4FragmentingString::Get4Momentum() const
288 {                                                 222 {
289         return Pstring;                        << 223         G4LorentzVector momentum(Ptleft+Ptright,0);
                                                   >> 224   momentum.setPz(0.5*(Pplus-Pminus));
                                                   >> 225   momentum.setE(0.5*(Pplus+Pminus));
                                                   >> 226   return momentum;
290 }                                                 227 }
291                                                   228 
292 G4double G4FragmentingString::Mass2() const       229 G4double G4FragmentingString::Mass2() const
293 {                                                 230 {
294   return Pstring.mag2();                       << 231   return Pplus*Pminus - (Ptleft+Ptright).mag2();
295 }                                                 232 }
296                                                   233 
297 G4double G4FragmentingString::Mass() const        234 G4double G4FragmentingString::Mass() const
298 {                                                 235 {
299   return Pstring.mag();                        << 236   return std::sqrt(this->Mass2());
300 }                                                 237 }
301                                                   238 
302 G4double G4FragmentingString::MassT2() const      239 G4double G4FragmentingString::MassT2() const
303 {                                                 240 {
304   return Pplus*Pminus;                         << 241   return Pplus*Pminus;
305 }                                              << 
306                                                << 
307 G4LorentzVector G4FragmentingString::GetPstrin << 
308 {                                              << 
309   return Pstring;                              << 
310 }                                              << 
311                                                << 
312 G4LorentzVector G4FragmentingString::GetPleft( << 
313 {                                              << 
314   return Pleft;                                << 
315 }                                              << 
316                                                << 
317 G4LorentzVector G4FragmentingString::GetPright << 
318 {                                              << 
319   return Pright;                               << 
320 }                                              << 
321                                                << 
322 G4LorentzRotation G4FragmentingString::Transfo << 
323 {                                              << 
324      G4LorentzVector momentum = Pstring;       << 
325      G4LorentzRotation toAlignedCms(-1*momentu << 
326      momentum = toAlignedCms * Pleft;          << 
327                                                << 
328      toAlignedCms.rotateZ(-1*momentum.phi());  << 
329      toAlignedCms.rotateY(-1*momentum.theta()) << 
330                                                << 
331      Pleft   *= toAlignedCms;                  << 
332      Pright  *= toAlignedCms;                  << 
333      Pstring *= toAlignedCms;                  << 
334                                                << 
335      Ptleft  = G4ThreeVector(Pleft.vect());    << 
336      Ptleft.setZ(0.);                          << 
337      Ptright = G4ThreeVector(Pright.vect());   << 
338      Pplus  = Pstring.plus();                  << 
339      Pminus = Pstring.minus();                 << 
340                                                << 
341      return toAlignedCms;                      << 
342 }                                                 242 }
343                                                   243