Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer 3 // * License and Disclaimer * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. 9 // * include a list of copyright holders. * 10 // * 10 // * * 11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. * 17 // * 17 // * * 18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************* 24 // ******************************************************************** 25 // 25 // 26 // 26 // 27 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 //G4cout<<" Left "<<G4endl; 116 if ( old.decaying == Left ) << 83 //G4cout<<"Pt right "<<Ptright<<G4endl; 117 { << 84 //G4cout<<"Pt left "<<Ptleft <<G4endl; 118 RightParton= old.RightParton; << 85 RightParton= old.RightParton; 119 Ptright = old.Ptright; << 86 Ptright = old.Ptright; 120 Pright = old.Pright; << 87 LeftParton = newdecay; 121 << 88 Ptleft = old.Ptleft - momentum->vect(); 122 LeftParton = newdecay; << 89 Ptleft.setZ(0.); 123 Ptleft = old.Ptleft - mome << 90 //G4cout<<"Pt right "<<Ptright<<G4endl; 124 Ptleft.setZ(0.); << 91 //G4cout<<"Pt left "<<Ptleft <<G4endl; 125 Pleft = old.Pleft - Momentum; << 92 } else if ( old.decaying == Right ) 126 << 93 { 127 Pstring = Pleft + Pright; << 94 //G4cout<<" Right "<<G4endl; 128 Pplus = Pstring.plus(); << 95 //G4cout<<"Pt right "<<Ptright<<G4endl; 129 Pminus = Pstring.minus(); << 96 //G4cout<<"Pt left "<<Ptleft <<G4endl; 130 << 97 RightParton = newdecay; 131 theDecayParton=GetLeftParton() << 98 Ptright = old.Ptright - momentum->vect(); 132 theStableParton=GetRightParton << 99 Ptright.setZ(0.); 133 decaying = Left; << 100 LeftParton = old.LeftParton; 134 } else if ( old.decaying == Right ) << 101 Ptleft = old.Ptleft; 135 { << 102 //G4cout<<"Pt right "<<Ptright<<G4endl; 136 RightParton = newdecay; << 103 //G4cout<<"Pt left "<<Ptleft <<G4endl; 137 Ptright = old.Ptright - mo << 104 } else 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 { 105 { 154 throw G4HadronicException(__FILE__, __LINE << 106 throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::G4FragmentingString: no decay Direction defined"); 155 "G4FragmentingString::G4Frag << 156 } 107 } >> 108 Pplus = old.Pplus - (momentum->e() + momentum->pz()); >> 109 Pminus = old.Pminus - (momentum->e() - momentum->pz()); >> 110 >> 111 //G4double Eold=0.5 * (old.Pplus + old.Pminus); >> 112 //G4double Enew=0.5 * (Pplus + Pminus); 157 } 113 } 158 114 159 115 160 //-------------------------------------------- 116 //--------------------------------------------------------------------------------- 161 117 162 G4FragmentingString::G4FragmentingString(const << 118 G4FragmentingString::G4FragmentingString(const G4FragmentingString &old, // Uzhi 163 G4ParticleDefinition * newdecay) << 119 G4ParticleDefinition * newdecay) // Uzhi 164 { << 120 { // Uzhi 165 decaying=None; << 121 decaying=None; // Uzhi 166 << 122 if ( old.decaying == Left ) // Uzhi 167 Ptleft.setX(0.); Ptleft.setY(0.); Pt << 123 { // Uzhi 168 Ptright.setX(0.); Ptright.setY(0.); Pt << 124 RightParton= old.RightParton; // Uzhi 169 Pplus=0.; Pminus=0.; << 125 LeftParton = newdecay; // Uzhi 170 theStableParton=0; theDecayParton=0; << 126 } else if ( old.decaying == Right ) // Uzhi 171 << 127 { // Uzhi 172 Pstring=G4LorentzVector(0.,0.,0.,0.); << 128 RightParton = newdecay; // Uzhi 173 Pleft =G4LorentzVector(0.,0.,0.,0.); << 129 LeftParton = old.LeftParton; // Uzhi 174 Pright =G4LorentzVector(0.,0.,0.,0.); << 130 } else // Uzhi 175 << 176 if ( old.decaying == Left ) << 177 { << 178 RightParton= old.RightParton; << 179 LeftParton = newdecay; << 180 decaying=Left; << 181 } else if ( old.decaying == Right ) << 182 { << 183 RightParton = newdecay; << 184 LeftParton = old.LeftParton; << 185 decaying=Right; << 186 } else << 187 { 131 { 188 throw G4HadronicException(__FILE__, __LINE << 132 throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::G4FragmentingString: no decay Direction defined"); 189 "G4FragmentingString::G4Frag << 190 } 133 } 191 } 134 } 192 135 193 136 194 //-------------------------------------------- 137 //--------------------------------------------------------------------------------- 195 138 196 G4FragmentingString::~G4FragmentingString() 139 G4FragmentingString::~G4FragmentingString() 197 {} 140 {} 198 141 >> 142 199 //-------------------------------------------- 143 //--------------------------------------------------------------------------------- 200 144 201 void G4FragmentingString::SetLeftPartonStable( 145 void G4FragmentingString::SetLeftPartonStable() 202 { 146 { 203 theStableParton=GetLeftParton(); 147 theStableParton=GetLeftParton(); 204 theDecayParton=GetRightParton(); 148 theDecayParton=GetRightParton(); 205 decaying=Right; 149 decaying=Right; 206 } 150 } 207 151 208 //-------------------------------------------- 152 //--------------------------------------------------------------------------------- 209 153 210 void G4FragmentingString::SetRightPartonStable 154 void G4FragmentingString::SetRightPartonStable() 211 { 155 { 212 theStableParton=GetRightParton(); 156 theStableParton=GetRightParton(); 213 theDecayParton=GetLeftParton(); 157 theDecayParton=GetLeftParton(); 214 decaying=Left; 158 decaying=Left; 215 } 159 } 216 160 217 //-------------------------------------------- 161 //--------------------------------------------------------------------------------- 218 162 219 G4int G4FragmentingString::GetDecayDirection() 163 G4int G4FragmentingString::GetDecayDirection() const 220 { 164 { 221 if (decaying == Left ) return +1; 165 if (decaying == Left ) return +1; 222 else if (decaying == Right) return -1; 166 else if (decaying == Right) return -1; 223 else throw G4HadronicException(__FILE__, __L << 167 else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::GetDecayDirection: decay side UNdefined!"); 224 "G4FragmentingString::GetDecayD << 225 return 0; 168 return 0; 226 } 169 } 227 170 228 //-------------------------------------------- 171 //--------------------------------------------------------------------------------- 229 172 230 G4bool G4FragmentingString::IsAFourQuarkString << 173 G4bool G4FragmentingString::FourQuarkString() const 231 { 174 { 232 return LeftParton->GetParticleSubType()== 175 return LeftParton->GetParticleSubType()== "di_quark" 233 && RightParton->GetParticleSubType()== 176 && RightParton->GetParticleSubType()== "di_quark"; 234 } 177 } 235 178 236 //-------------------------------------------- 179 //--------------------------------------------------------------------------------- 237 180 238 G4bool G4FragmentingString::DecayIsQuark() 181 G4bool G4FragmentingString::DecayIsQuark() 239 { 182 { 240 return theDecayParton->GetParticleSubType()= 183 return theDecayParton->GetParticleSubType()== "quark"; 241 } 184 } 242 185 243 G4bool G4FragmentingString::StableIsQuark() 186 G4bool G4FragmentingString::StableIsQuark() 244 { 187 { 245 return theStableParton->GetParticleSubType() 188 return theStableParton->GetParticleSubType()== "quark"; 246 } 189 } 247 190 248 //-------------------------------------------- 191 //--------------------------------------------------------------------------------- 249 192 250 G4ThreeVector G4FragmentingString::StablePt() 193 G4ThreeVector G4FragmentingString::StablePt() 251 { 194 { 252 if (decaying == Left ) return Ptright; 195 if (decaying == Left ) return Ptright; 253 else if (decaying == Right ) return Ptleft; 196 else if (decaying == Right ) return Ptleft; 254 else throw G4HadronicException(__FILE__, __L 197 else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::DecayPt: decay side UNdefined!"); 255 return G4ThreeVector(); 198 return G4ThreeVector(); 256 } 199 } 257 200 258 G4ThreeVector G4FragmentingString::DecayPt() 201 G4ThreeVector G4FragmentingString::DecayPt() 259 { 202 { 260 if (decaying == Left ) return Ptleft; 203 if (decaying == Left ) return Ptleft; 261 else if (decaying == Right ) return Ptright; 204 else if (decaying == Right ) return Ptright; 262 else throw G4HadronicException(__FILE__, __L 205 else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::DecayPt: decay side UNdefined!"); 263 return G4ThreeVector(); 206 return G4ThreeVector(); 264 } 207 } 265 208 266 //-------------------------------------------- 209 //--------------------------------------------------------------------------------- 267 210 268 G4double G4FragmentingString::LightConePlus() 211 G4double G4FragmentingString::LightConePlus() 269 { 212 { 270 return Pplus; 213 return Pplus; 271 } 214 } 272 215 273 G4double G4FragmentingString::LightConeMinus() 216 G4double G4FragmentingString::LightConeMinus() 274 { 217 { 275 return Pminus; 218 return Pminus; 276 } 219 } 277 220 278 G4double G4FragmentingString::LightConeDecay() 221 G4double G4FragmentingString::LightConeDecay() 279 { 222 { 280 if (decaying == Left ) return Pplus; 223 if (decaying == Left ) return Pplus; 281 else if (decaying == Right ) return Pminus; 224 else if (decaying == Right ) return Pminus; 282 else throw G4HadronicException(__FILE__, __L 225 else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::DecayPt: decay side UNdefined!"); >> 226 return 0; 283 } 227 } 284 228 285 //-------------------------------------------- 229 //--------------------------------------------------------------------------------- 286 230 287 G4LorentzVector G4FragmentingString::Get4Momen 231 G4LorentzVector G4FragmentingString::Get4Momentum() const 288 { 232 { 289 return Pstring; << 233 G4LorentzVector momentum(Ptleft+Ptright,0); >> 234 momentum.setPz(0.5*(Pplus-Pminus)); >> 235 momentum.setE(0.5*(Pplus+Pminus)); >> 236 return momentum; 290 } 237 } 291 238 292 G4double G4FragmentingString::Mass2() const 239 G4double G4FragmentingString::Mass2() const 293 { 240 { 294 return Pstring.mag2(); << 241 return Pplus*Pminus - (Ptleft+Ptright).mag2(); 295 } 242 } 296 243 297 G4double G4FragmentingString::Mass() const 244 G4double G4FragmentingString::Mass() const 298 { 245 { 299 return Pstring.mag(); << 246 return std::sqrt(this->Mass2()); 300 } 247 } 301 248 302 G4double G4FragmentingString::MassT2() const 249 G4double G4FragmentingString::MassT2() const 303 { 250 { 304 return Pplus*Pminus; << 251 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 } 252 } 343 253