Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of >> 2 // the GEANT4 collaboration. 1 // 3 // 2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work 3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement, 4 // * << 6 // and all its terms. 5 // * The Geant4 software is copyright of th << 6 // * the Geant4 Collaboration. It is provided << 7 // * conditions of the Geant4 Software License << 8 // * LICENSE and available at http://cern.ch/ << 9 // * include a list of copyright holders. << 10 // * << 11 // * Neither the authors of this software syst << 12 // * institutes,nor the agencies providing fin << 13 // * work make any representation or warran << 14 // * regarding this software system or assum << 15 // * use. Please see the license in the file << 16 // * for the full disclaimer and the limitatio << 17 // * << 18 // * This code implementation is the result << 19 // * technical work of the GEANT4 collaboratio << 20 // * By using, copying, modifying or distri << 21 // * any work based on the software) you ag << 22 // * use in resulting scientific publicati << 23 // * acceptance of all terms of the Geant4 Sof << 24 // ******************************************* << 25 // 7 // >> 8 // $Id: G4ExcitedLambdaConstructor.cc,v 1.2.6.1 1999/12/07 20:50:04 gunter Exp $ >> 9 // GEANT4 tag $Name: geant4-01-00 $ >> 10 // >> 11 // 26 // ------------------------------------------- 12 // -------------------------------------------------------------- 27 // GEANT 4 class implementation file << 13 // GEANT 4 class implementation file >> 14 // For information related to this code contact: >> 15 // CERN, IT Division, ASD Group 28 // History: first implementation, based o 16 // History: first implementation, based on object model of 29 // 10 oct 1998 H.Kurashige 17 // 10 oct 1998 H.Kurashige 30 // << 31 // Update mass and width following PDG 20 << 32 // 4 nov 2023 S.Okada << 33 // ------------------------------------------- 18 // --------------------------------------------------------------- 34 19 >> 20 35 #include "G4ExcitedLambdaConstructor.hh" 21 #include "G4ExcitedLambdaConstructor.hh" 36 22 37 #include "G4DecayTable.hh" << 23 #include "G4ParticleDefinition.hh" >> 24 #include "G4ParticleTable.hh" >> 25 #include "G4ShortLivedTable.hh" 38 #include "G4PhaseSpaceDecayChannel.hh" 26 #include "G4PhaseSpaceDecayChannel.hh" 39 #include "G4SystemOfUnits.hh" << 40 #include "G4VDecayChannel.hh" 27 #include "G4VDecayChannel.hh" >> 28 #include "G4DecayTable.hh" 41 29 42 G4ExcitedLambdaConstructor::G4ExcitedLambdaCon << 43 : G4ExcitedBaryonConstructor(NStates, Lambda << 44 {} << 45 30 46 G4DecayTable* G4ExcitedLambdaConstructor::Crea << 31 G4ExcitedLambdaConstructor::G4ExcitedLambdaConstructor(): 47 << 32 G4ExcitedBaryonConstructor(NStates, LambdaIsoSpin) >> 33 { >> 34 >> 35 } >> 36 >> 37 G4ExcitedLambdaConstructor::~G4ExcitedLambdaConstructor() >> 38 { >> 39 } >> 40 >> 41 G4DecayTable* G4ExcitedLambdaConstructor::CreateDecayTable( >> 42 const G4String& parentName, >> 43 G4int iIso3, >> 44 G4int iState, >> 45 G4bool fAnti) 48 { 46 { 49 // create decay table 47 // create decay table 50 auto decayTable = new G4DecayTable(); << 48 G4DecayTable* decayTable = new G4DecayTable(); 51 49 52 G4double br; 50 G4double br; 53 if ((br = bRatio[iState][NK]) > 0.0) { << 51 if ( (br=bRatio[iState][NK]) >0.0) { 54 AddNKMode(decayTable, parentName, br, iIso << 52 AddNKMode( decayTable, parentName, br, iIso3, fAnti); 55 } 53 } 56 54 57 if ((br = bRatio[iState][NKStar]) > 0.0) { << 55 if ( (br=bRatio[iState][NKStar]) >0.0) { 58 AddNKStarMode(decayTable, parentName, br, << 56 AddNKStarMode( decayTable, parentName, br, iIso3, fAnti); 59 } 57 } 60 58 61 if ((br = bRatio[iState][SigmaPi]) > 0.0) { << 59 if ( (br=bRatio[iState][SigmaPi]) >0.0) { 62 AddSigmaPiMode(decayTable, parentName, br, << 60 AddSigmaPiMode( decayTable, parentName, br, iIso3, fAnti); 63 } 61 } 64 62 65 if ((br = bRatio[iState][SigmaStarPi]) > 0.0 << 63 if ( (br=bRatio[iState][SigmaStarPi]) >0.0) { 66 AddSigmaStarPiMode(decayTable, parentName, << 64 AddSigmaStarPiMode( decayTable, parentName, br, iIso3, fAnti); 67 } 65 } 68 66 69 if ((br = bRatio[iState][LambdaGamma]) > 0.0 << 67 if ( (br=bRatio[iState][LambdaGamma]) >0.0) { 70 AddLambdaGammaMode(decayTable, parentName, << 68 AddLambdaGammaMode( decayTable, parentName, br, iIso3, fAnti); 71 } 69 } 72 70 73 if ((br = bRatio[iState][LambdaEta]) > 0.0) << 71 if ( (br=bRatio[iState][LambdaEta]) >0.0) { 74 AddLambdaEtaMode(decayTable, parentName, b << 72 AddLambdaEtaMode( decayTable, parentName, br, iIso3, fAnti); 75 } 73 } 76 74 77 if ((br = bRatio[iState][LambdaOmega]) > 0.0 << 75 if ( (br=bRatio[iState][LambdaOmega]) >0.0) { 78 AddLambdaOmegaMode(decayTable, parentName, << 76 AddLambdaOmegaMode( decayTable, parentName, br, iIso3, fAnti); 79 } 77 } 80 78 81 return decayTable; << 79 return decayTable; 82 } 80 } 83 81 84 G4DecayTable* G4ExcitedLambdaConstructor::AddL << 82 G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaGammaMode( 85 << 83 G4DecayTable* decayTable, const G4String& nameParent, 86 << 84 G4double br, G4int iIso3, G4bool fAnti) 87 { 85 { 88 G4VDecayChannel* mode; 86 G4VDecayChannel* mode; 89 87 90 // << 88 // 91 G4String lambda = "lambda"; << 89 G4String lambda = "lambda"; 92 if (fAnti) lambda = "anti_" + lambda; 90 if (fAnti) lambda = "anti_" + lambda; 93 91 94 // create decay channel [parent BR # 92 // create decay channel [parent BR #daughters] 95 mode = new G4PhaseSpaceDecayChannel(namePare << 93 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, >> 94 lambda,"gamma"); 96 // add decay table 95 // add decay table 97 decayTable->Insert(mode); 96 decayTable->Insert(mode); 98 97 99 return decayTable; 98 return decayTable; 100 } 99 } 101 G4DecayTable* G4ExcitedLambdaConstructor::AddL << 100 G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaEtaMode( 102 << 101 G4DecayTable* decayTable, const G4String& nameParent, 103 << 102 G4double br, G4int iIso3, G4bool fAnti) 104 { 103 { 105 G4VDecayChannel* mode; 104 G4VDecayChannel* mode; 106 105 107 // << 106 // 108 G4String lambda = "lambda"; << 107 G4String lambda = "lambda"; 109 if (fAnti) lambda = "anti_" + lambda; 108 if (fAnti) lambda = "anti_" + lambda; 110 109 111 // create decay channel [parent BR # 110 // create decay channel [parent BR #daughters] 112 mode = new G4PhaseSpaceDecayChannel(namePare << 111 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, >> 112 lambda,"eta"); 113 // add decay table 113 // add decay table 114 decayTable->Insert(mode); 114 decayTable->Insert(mode); 115 115 116 return decayTable; 116 return decayTable; 117 } 117 } 118 118 119 G4DecayTable* G4ExcitedLambdaConstructor::AddL << 119 G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaOmegaMode( 120 << 120 G4DecayTable* decayTable, const G4String& nameParent, 121 << 121 G4double br, G4int iIso3, G4bool fAnti) 122 { 122 { 123 G4VDecayChannel* mode; 123 G4VDecayChannel* mode; 124 124 125 // << 125 // 126 G4String lambda = "lambda"; << 126 G4String lambda = "lambda"; 127 if (fAnti) lambda = "anti_" + lambda; 127 if (fAnti) lambda = "anti_" + lambda; 128 128 129 // create decay channel [parent BR # 129 // create decay channel [parent BR #daughters] 130 mode = new G4PhaseSpaceDecayChannel(namePare << 130 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, >> 131 lambda,"omega"); 131 // add decay table 132 // add decay table 132 decayTable->Insert(mode); 133 decayTable->Insert(mode); 133 134 134 return decayTable; 135 return decayTable; 135 } 136 } 136 137 137 G4DecayTable* G4ExcitedLambdaConstructor::AddN << 138 G4DecayTable* G4ExcitedLambdaConstructor::AddNKMode( 138 << 139 G4DecayTable* decayTable, const G4String& nameParent, 139 << 140 G4double br, G4int iIso3, G4bool fAnti) 140 { 141 { 141 G4VDecayChannel* mode; 142 G4VDecayChannel* mode; 142 143 143 G4String daughterN; 144 G4String daughterN; 144 G4String daughterK; 145 G4String daughterK; 145 146 146 // ------------ N K- ------------ << 147 // ------------ N K- ------------ 147 // determine daughters 148 // determine daughters 148 daughterN = "proton"; << 149 daughterN = "proton"; 149 if (!fAnti) { 150 if (!fAnti) { 150 daughterK = "kaon-"; 151 daughterK = "kaon-"; 151 } << 152 } else { 152 else { << 153 daughterK = "kaon+"; 153 daughterK = "kaon+"; 154 } 154 } 155 if (fAnti) daughterN = "anti_" + daughterN; 155 if (fAnti) daughterN = "anti_" + daughterN; 156 // create decay channel [parent BR # 156 // create decay channel [parent BR #daughters] 157 mode = new G4PhaseSpaceDecayChannel(namePare << 157 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2, >> 158 daughterN,daughterK); 158 // add decay table 159 // add decay table 159 decayTable->Insert(mode); 160 decayTable->Insert(mode); 160 161 161 // ------------ N K0 ------------ << 162 // ------------ N K0 ------------ 162 // determine daughters 163 // determine daughters 163 daughterN = "neutron"; << 164 daughterN = "neutron"; 164 if (!fAnti) { 165 if (!fAnti) { 165 daughterK = "anti_kaon0"; 166 daughterK = "anti_kaon0"; 166 } << 167 } else { 167 else { << 168 daughterK = "kaon0"; 168 daughterK = "kaon0"; 169 } 169 } 170 if (fAnti) daughterN = "anti_" + daughterN; 170 if (fAnti) daughterN = "anti_" + daughterN; 171 // create decay channel [parent BR # 171 // create decay channel [parent BR #daughters] 172 mode = new G4PhaseSpaceDecayChannel(namePare << 172 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2, >> 173 daughterN,daughterK); 173 // add decay table 174 // add decay table 174 decayTable->Insert(mode); 175 decayTable->Insert(mode); 175 176 >> 177 176 return decayTable; 178 return decayTable; 177 } 179 } 178 180 179 G4DecayTable* G4ExcitedLambdaConstructor::AddN << 181 G4DecayTable* G4ExcitedLambdaConstructor::AddNKStarMode( 180 << 182 G4DecayTable* decayTable, const G4String& nameParent, 181 << 183 G4double br, G4int iIso3, G4bool fAnti) 182 { 184 { 183 G4VDecayChannel* mode; 185 G4VDecayChannel* mode; 184 186 185 G4String daughterN; 187 G4String daughterN; 186 G4String daughterK; 188 G4String daughterK; 187 189 188 // ------------ N K- ------------ << 190 // ------------ N K- ------------ 189 // determine daughters 191 // determine daughters 190 daughterN = "proton"; << 192 daughterN = "proton"; 191 if (!fAnti) { 193 if (!fAnti) { 192 daughterK = "k_star-"; 194 daughterK = "k_star-"; 193 } << 195 } else { 194 else { << 195 daughterK = "k_star+"; 196 daughterK = "k_star+"; 196 } 197 } 197 if (fAnti) daughterN = "anti_" + daughterN; 198 if (fAnti) daughterN = "anti_" + daughterN; 198 // create decay channel [parent BR # 199 // create decay channel [parent BR #daughters] 199 mode = new G4PhaseSpaceDecayChannel(namePare << 200 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2, >> 201 daughterN,daughterK); 200 // add decay table 202 // add decay table 201 decayTable->Insert(mode); 203 decayTable->Insert(mode); 202 204 203 // ------------ N K0 ------------ << 205 // ------------ N K0 ------------ 204 // determine daughters 206 // determine daughters 205 daughterN = "neutron"; << 207 daughterN = "neutron"; 206 if (!fAnti) { 208 if (!fAnti) { 207 daughterK = "anti_k_star0"; 209 daughterK = "anti_k_star0"; 208 } << 210 } else { 209 else { << 210 daughterK = "k_star0"; 211 daughterK = "k_star0"; 211 } 212 } 212 if (fAnti) daughterN = "anti_" + daughterN; 213 if (fAnti) daughterN = "anti_" + daughterN; 213 // create decay channel [parent BR # 214 // create decay channel [parent BR #daughters] 214 mode = new G4PhaseSpaceDecayChannel(namePare << 215 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2, >> 216 daughterN,daughterK); 215 // add decay table 217 // add decay table 216 decayTable->Insert(mode); 218 decayTable->Insert(mode); 217 219 >> 220 218 return decayTable; 221 return decayTable; 219 } 222 } 220 223 221 G4DecayTable* G4ExcitedLambdaConstructor::AddS << 224 G4DecayTable* G4ExcitedLambdaConstructor::AddSigmaPiMode( 222 << 225 G4DecayTable* decayTable, const G4String& nameParent, 223 << 226 G4double br, G4int iIso3, G4bool fAnti) 224 { 227 { 225 G4VDecayChannel* mode; 228 G4VDecayChannel* mode; 226 229 227 G4String daughterSigma; 230 G4String daughterSigma; 228 G4String daughterPi; 231 G4String daughterPi; 229 232 230 // ------------ Sigma+ pi - ------------ << 233 // ------------ Sigma+ pi - ------------ 231 // determine daughters 234 // determine daughters 232 daughterSigma = "sigma+"; 235 daughterSigma = "sigma+"; 233 if (!fAnti) { 236 if (!fAnti) { 234 daughterPi = "pi-"; 237 daughterPi = "pi-"; 235 } << 238 } else { 236 else { << 237 daughterPi = "pi+"; 239 daughterPi = "pi+"; 238 } 240 } 239 if (fAnti) daughterSigma = "anti_" + daughte 241 if (fAnti) daughterSigma = "anti_" + daughterSigma; 240 // create decay channel [parent BR # 242 // create decay channel [parent BR #daughters] 241 mode = new G4PhaseSpaceDecayChannel(namePare << 243 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2, >> 244 daughterSigma,daughterPi); 242 // add decay table 245 // add decay table 243 decayTable->Insert(mode); 246 decayTable->Insert(mode); 244 247 245 // ------------ Sigma0 Pi0 ------------ << 248 // ------------ Sigma0 Pi0 ------------ 246 // determine daughters 249 // determine daughters 247 daughterSigma = "sigma0"; << 250 daughterSigma = "sigma0"; 248 daughterPi = "pi0"; 251 daughterPi = "pi0"; 249 252 250 if (fAnti) daughterSigma = "anti_" + daughte 253 if (fAnti) daughterSigma = "anti_" + daughterSigma; 251 // create decay channel [parent BR # 254 // create decay channel [parent BR #daughters] 252 mode = new G4PhaseSpaceDecayChannel(namePare << 255 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2, >> 256 daughterSigma,daughterPi); 253 257 254 // add decay table 258 // add decay table 255 decayTable->Insert(mode); 259 decayTable->Insert(mode); 256 260 257 // ------------ Sigma- pi + ------------ << 261 // ------------ Sigma- pi + ------------ 258 // determine daughters 262 // determine daughters 259 daughterSigma = "sigma-"; 263 daughterSigma = "sigma-"; 260 if (!fAnti) { 264 if (!fAnti) { 261 daughterPi = "pi+"; 265 daughterPi = "pi+"; 262 } << 266 } else { 263 else { << 264 daughterPi = "pi-"; 267 daughterPi = "pi-"; 265 } 268 } 266 if (fAnti) daughterSigma = "anti_" + daughte 269 if (fAnti) daughterSigma = "anti_" + daughterSigma; 267 // create decay channel [parent BR # 270 // create decay channel [parent BR #daughters] 268 mode = new G4PhaseSpaceDecayChannel(namePare << 271 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2, >> 272 daughterSigma,daughterPi); 269 // add decay table 273 // add decay table 270 decayTable->Insert(mode); 274 decayTable->Insert(mode); 271 275 272 return decayTable; 276 return decayTable; 273 } 277 } 274 278 275 G4DecayTable* G4ExcitedLambdaConstructor::AddS << 279 276 << 280 G4DecayTable* G4ExcitedLambdaConstructor::AddSigmaStarPiMode( 277 << 281 G4DecayTable* decayTable, const G4String& nameParent, >> 282 G4double br, G4int iIso3, G4bool fAnti) 278 { 283 { 279 G4VDecayChannel* mode; 284 G4VDecayChannel* mode; 280 285 281 G4String daughterSigma; 286 G4String daughterSigma; 282 G4String daughterPi; 287 G4String daughterPi; 283 288 284 // ------------ Sigma+ pi - ------------ << 289 // ------------ Sigma+ pi - ------------ 285 // determine daughters 290 // determine daughters 286 daughterSigma = "sigma(1385)+"; 291 daughterSigma = "sigma(1385)+"; 287 if (!fAnti) { 292 if (!fAnti) { 288 daughterPi = "pi-"; 293 daughterPi = "pi-"; 289 } << 294 } else { 290 else { << 291 daughterPi = "pi+"; 295 daughterPi = "pi+"; 292 } 296 } 293 if (fAnti) daughterSigma = "anti_" + daughte 297 if (fAnti) daughterSigma = "anti_" + daughterSigma; 294 // create decay channel [parent BR # 298 // create decay channel [parent BR #daughters] 295 mode = new G4PhaseSpaceDecayChannel(namePare << 299 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2, >> 300 daughterSigma,daughterPi); 296 // add decay table 301 // add decay table 297 decayTable->Insert(mode); 302 decayTable->Insert(mode); 298 303 299 // ------------ Sigma0 Pi0 ------------ << 304 // ------------ Sigma0 Pi0 ------------ 300 // determine daughters 305 // determine daughters 301 daughterSigma = "sigma(1385)0"; << 306 daughterSigma = "sigma(1385)0"; 302 daughterPi = "pi0"; 307 daughterPi = "pi0"; 303 308 304 if (fAnti) daughterSigma = "anti_" + daughte 309 if (fAnti) daughterSigma = "anti_" + daughterSigma; 305 // create decay channel [parent BR # 310 // create decay channel [parent BR #daughters] 306 mode = new G4PhaseSpaceDecayChannel(namePare << 311 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2, >> 312 daughterSigma,daughterPi); 307 313 308 // add decay table 314 // add decay table 309 decayTable->Insert(mode); 315 decayTable->Insert(mode); 310 316 311 // ------------ Sigma- pi + ------------ << 317 // ------------ Sigma- pi + ------------ 312 // determine daughters 318 // determine daughters 313 daughterSigma = "sigma(1385)-"; 319 daughterSigma = "sigma(1385)-"; 314 if (!fAnti) { 320 if (!fAnti) { 315 daughterPi = "pi+"; 321 daughterPi = "pi+"; 316 } << 322 } else { 317 else { << 318 daughterPi = "pi-"; 323 daughterPi = "pi-"; 319 } 324 } 320 if (fAnti) daughterSigma = "anti_" + daughte 325 if (fAnti) daughterSigma = "anti_" + daughterSigma; 321 // create decay channel [parent BR # 326 // create decay channel [parent BR #daughters] 322 mode = new G4PhaseSpaceDecayChannel(namePare << 327 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2, >> 328 daughterSigma,daughterPi); 323 // add decay table 329 // add decay table 324 decayTable->Insert(mode); 330 decayTable->Insert(mode); 325 331 326 return decayTable; 332 return decayTable; 327 } 333 } 328 334 329 // clang-format off << 330 << 331 const char* G4ExcitedLambdaConstructor::name[] 335 const char* G4ExcitedLambdaConstructor::name[] = { 332 "lambda(1405)","lambda(1520)","lambda(1600)" << 336 "lambda(1405)","lambda(1520)","lambda(1600)","lambda(1670)","lambda(1690)", 333 "lambda(1800)","lambda(1810)","lambda(1820)" 337 "lambda(1800)","lambda(1810)","lambda(1820)","lambda(1830)","lambda(1890)", 334 "lambda(2100)","lambda(2110)" 338 "lambda(2100)","lambda(2110)" 335 }; 339 }; 336 340 337 const G4double G4ExcitedLambdaConstructor::mas 341 const G4double G4ExcitedLambdaConstructor::mass[] = { 338 1.4051*GeV,1.5194*GeV, 1.600*GeV, 1.674*GeV, << 342 1.407*GeV, 1.520*GeV, 1.600*GeV, 1.670*GeV, 1.690*GeV, 339 1.800*GeV, 1.790*GeV, 1.820*GeV, 1.825*GeV, << 343 1.800*GeV, 1.810*GeV, 1.820*GeV, 1.830*GeV, 1.890*GeV, 340 2.100*GeV, 2.090*GeV << 344 2.100*GeV, 2.110*GeV 341 }; 345 }; 342 346 343 const G4double G4ExcitedLambdaConstructor::wid 347 const G4double G4ExcitedLambdaConstructor::width[] = { 344 50.5*MeV, 15.7*MeV, 2000.0*MeV, 30.0*MeV, << 348 50.0*MeV, 16.0*MeV, 150.0*MeV, 35.0*MeV, 60.0*MeV, 345 200.0*MeV, 110.0*MeV, 80.0*MeV, 90.0*MeV, << 349 300.0*MeV, 150.0*MeV, 80.0*MeV, 95.0*MeV, 100.0*MeV, 346 200.0*MeV, 250.0*MeV << 350 200.0*MeV, 200.0*MeV 347 }; 351 }; 348 352 349 const G4int G4ExcitedLambdaConstructor::iSpin[ 353 const G4int G4ExcitedLambdaConstructor::iSpin[] = { 350 1, 3, 1, 1, 3, 354 1, 3, 1, 1, 3, 351 1, 1, 5, 5, 3, 355 1, 1, 5, 5, 3, 352 7, 5 356 7, 5 353 }; 357 }; 354 358 355 const G4int G4ExcitedLambdaConstructor::iParit 359 const G4int G4ExcitedLambdaConstructor::iParity[] = { 356 -1, -1, +1, -1, -1, 360 -1, -1, +1, -1, -1, 357 -1, +1, +1, -1, +1, 361 -1, +1, +1, -1, +1, 358 -1, +1 << 362 -1, +1 359 }; 363 }; 360 364 361 const G4int G4ExcitedLambdaConstructor::encodi 365 const G4int G4ExcitedLambdaConstructor::encodingOffset[] = { 362 10000, 0, 20000, 30000, 10000, 366 10000, 0, 20000, 30000, 10000, 363 40000, 50000, 0, 10000, 20000, << 367 40000, 50000, 0, 10000, 20000, 364 0, 20000 368 0, 20000 365 }; 369 }; 366 370 367 const G4double G4ExcitedLambdaConstructor::bRa << 371 const G4double G4ExcitedLambdaConstructor::bRatio[ G4ExcitedLambdaConstructor::NStates ][ G4ExcitedLambdaConstructor::NumberOfDecayModes] = 368 { 372 { 369 { 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0 << 373 { 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0}, 370 { 0.45, 0.0, 0.43, 0.11, 0.01, 0.0, 0 << 374 { 0.45, 0.0, 0.43, 0.11, 0.01, 0.0, 0.0}, 371 { 0.35, 0.0, 0.65, 0.0, 0.0, 0.0, 0 << 375 { 0.35, 0.0, 0.65, 0.0, 0.0, 0.0, 0.0}, 372 { 0.20, 0.0, 0.50, 0.0, 0.0, 0.30, 0 << 376 { 0.20, 0.0, 0.50, 0.0, 0.0, 0.30, 0.0}, 373 { 0.25, 0.0, 0.45, 0.30, 0.0, 0.0, 0 << 377 { 0.25, 0.0, 0.45, 0.30, 0.0, 0.0, 0.0}, 374 { 0.40, 0.20, 0.20, 0.20, 0.0, 0.0, 0 << 378 { 0.40, 0.20, 0.20, 0.20, 0.0, 0.0, 0.0}, 375 { 0.35, 0.45, 0.15, 0.05, 0.0, 0.0, 0 << 379 { 0.35, 0.45, 0.15, 0.05, 0.0, 0.0, 0.0}, 376 { 0.73, 0.0, 0.16, 0.11, 0.0, 0.0, 0 << 380 { 0.73, 0.0, 0.16, 0.11, 0.0, 0.0, 0.0}, 377 { 0.10, 0.0, 0.70, 0.20, 0.0, 0.0, 0 << 381 { 0.10, 0.0, 0.70, 0.20, 0.0, 0.0, 0.0}, 378 { 0.37, 0.21, 0.11, 0.31, 0.0, 0.0, 0 << 382 { 0.37, 0.21, 0.11, 0.31, 0.0, 0.0, 0.0}, 379 { 0.35, 0.20, 0.05, 0.30, 0.0, 0.02, 0. << 383 { 0.35, 0.20, 0.05, 0.30, 0.0, 0.02, 0.08}, 380 { 0.25, 0.45, 0.30, 0.0, 0.0, 0.0, 0 384 { 0.25, 0.45, 0.30, 0.0, 0.0, 0.0, 0.0} 381 }; 385 }; >> 386 >> 387 >> 388 >> 389 >> 390 >> 391 >> 392 >> 393 >> 394 >> 395 >> 396 >> 397 >> 398 >> 399 >> 400 >> 401 382 402