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