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 // >> 27 // $Id: G4ExcitedNucleonConstructor.cc 83749 2014-09-12 12:14:59Z gcosmo $ >> 28 // >> 29 // 26 // ------------------------------------------- 30 // -------------------------------------------------------------- 27 // GEANT 4 class implementation file << 31 // GEANT 4 class implementation file 28 // History: first implementation, based o 32 // History: first implementation, based on object model of 29 // 10 oct 1998 H.Kurashige 33 // 10 oct 1998 H.Kurashige 30 // << 31 // Update mass and width following PDG 20 << 32 // 4 nov 2023 S.Okada << 33 // ------------------------------------------- 34 // --------------------------------------------------------------- 34 35 >> 36 35 #include "G4ExcitedNucleonConstructor.hh" 37 #include "G4ExcitedNucleonConstructor.hh" 36 38 37 #include "G4DecayTable.hh" << 38 #include "G4PhaseSpaceDecayChannel.hh" << 39 #include "G4SystemOfUnits.hh" 39 #include "G4SystemOfUnits.hh" >> 40 #include "G4ParticleDefinition.hh" >> 41 #include "G4ParticleTable.hh" >> 42 #include "G4PhaseSpaceDecayChannel.hh" 40 #include "G4VDecayChannel.hh" 43 #include "G4VDecayChannel.hh" >> 44 #include "G4DecayTable.hh" 41 45 42 G4ExcitedNucleonConstructor::G4ExcitedNucleonC << 46 43 : G4ExcitedBaryonConstructor(NStates, Nucleo << 47 G4ExcitedNucleonConstructor::G4ExcitedNucleonConstructor(): 44 {} << 48 G4ExcitedBaryonConstructor(NStates, NucleonIsoSpin) >> 49 { >> 50 >> 51 } >> 52 >> 53 G4ExcitedNucleonConstructor::~G4ExcitedNucleonConstructor() >> 54 { >> 55 } 45 56 46 G4int G4ExcitedNucleonConstructor::GetEncoding 57 G4int G4ExcitedNucleonConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState) 47 { 58 { 48 G4int encoding; 59 G4int encoding; 49 // Delta has exceptinal encoding 60 // Delta has exceptinal encoding 50 if ((idxState == 1) // N(1520) << 61 if ((idxState==1)||(idxState==6)||(idxState==8)||(idxState==9)||(idxState==12) ) { 51 || (idxState == 6) // N(1700) << 52 || (idxState == 8) // N(1720) << 53 || (idxState == 9) // N(1900) << 54 || (idxState == 12)) // N(2190) << 55 { << 56 encoding = GetEncodingOffset(idxState); 62 encoding = GetEncodingOffset(idxState); 57 if ((iIsoSpin3 == 3) || (iIsoSpin3 == -3)) << 63 if ((iIsoSpin3==3)||(iIsoSpin3==-3)) { 58 // normal encoding << 64 // normal encoding 59 encoding += 1000 * GetQuarkContents(0, i << 65 encoding += 1000*GetQuarkContents(0, iIsoSpin3); 60 encoding += 100 * GetQuarkContents(1, iI << 66 encoding += 100*GetQuarkContents(1, iIsoSpin3); 61 encoding += 10 * GetQuarkContents(2, iIs << 67 encoding += 10*GetQuarkContents(2, iIsoSpin3); 62 } << 68 } else if (iIsoSpin3== +1){ 63 else if (iIsoSpin3 == +1) { << 69 // 1st <--> 2nd quark 64 // 1st <--> 2nd quark << 70 encoding += 1000*GetQuarkContents(0, iIsoSpin3); 65 encoding += 1000 * GetQuarkContents(0, i << 71 encoding += 10*GetQuarkContents(1, iIsoSpin3); 66 encoding += 10 * GetQuarkContents(1, iIs << 72 encoding += 100*GetQuarkContents(2, iIsoSpin3); 67 encoding += 100 * GetQuarkContents(2, iI << 73 } else if (iIsoSpin3== -1){ 68 } << 74 // 1st <--> 0th quark 69 else if (iIsoSpin3 == -1) { << 75 encoding += 100*GetQuarkContents(0, iIsoSpin3); 70 // 1st <--> 0th quark << 76 encoding += 1000*GetQuarkContents(1, iIsoSpin3); 71 encoding += 100 * GetQuarkContents(0, iI << 77 encoding += 10*GetQuarkContents(2, iIsoSpin3); 72 encoding += 1000 * GetQuarkContents(1, i << 73 encoding += 10 * GetQuarkContents(2, iIs << 74 } 78 } 75 encoding += GetiSpin(idxState) + 1; << 79 encoding += GetiSpin(idxState) +1; 76 } << 80 } else { 77 else << 78 { << 79 encoding = G4ExcitedBaryonConstructor::Get 81 encoding = G4ExcitedBaryonConstructor::GetEncoding(iIsoSpin3, idxState); 80 } 82 } 81 return encoding; 83 return encoding; 82 } 84 } 83 85 84 G4DecayTable* G4ExcitedNucleonConstructor::Cre << 86 G4DecayTable* G4ExcitedNucleonConstructor::CreateDecayTable( 85 << 87 const G4String& parentName, >> 88 G4int iIso3, >> 89 G4int iState, >> 90 G4bool fAnti) 86 { 91 { 87 // create decay table 92 // create decay table 88 auto decayTable = new G4DecayTable(); << 93 G4DecayTable* decayTable = new G4DecayTable(); 89 94 90 G4double br; 95 G4double br; 91 if ((br = bRatio[iState][NGamma]) > 0.0) { << 96 if ( (br=bRatio[iState][NGamma]) >0.0) { 92 AddNGammaMode(decayTable, parentName, br, << 97 AddNGammaMode( decayTable, parentName, br, iIso3, fAnti); 93 } 98 } 94 99 95 if ((br = bRatio[iState][NPi]) > 0.0) { << 100 if ( (br=bRatio[iState][NPi]) >0.0) { 96 AddNPiMode(decayTable, parentName, br, iIs << 101 AddNPiMode( decayTable, parentName, br, iIso3, fAnti); 97 } 102 } 98 103 99 if ((br = bRatio[iState][NEta]) > 0.0) { << 104 if ( (br=bRatio[iState][NEta]) >0.0) { 100 AddNEtaMode(decayTable, parentName, br, iI << 105 AddNEtaMode( decayTable, parentName, br, iIso3, fAnti); 101 } 106 } 102 107 103 if ((br = bRatio[iState][NOmega]) > 0.0) { << 108 if ( (br=bRatio[iState][NOmega]) >0.0) { 104 AddNOmegaMode(decayTable, parentName, br, << 109 AddNOmegaMode( decayTable, parentName, br, iIso3, fAnti); 105 } 110 } 106 111 107 if ((br = bRatio[iState][NRho]) > 0.0) { << 112 if ( (br=bRatio[iState][NRho]) >0.0) { 108 AddNRhoMode(decayTable, parentName, br, iI << 113 AddNRhoMode( decayTable, parentName, br, iIso3, fAnti); 109 } 114 } 110 115 111 if ((br = bRatio[iState][N2Pi]) > 0.0) { << 116 if ( (br=bRatio[iState][N2Pi]) >0.0) { 112 AddN2PiMode(decayTable, parentName, br, iI << 117 AddN2PiMode( decayTable, parentName, br, iIso3, fAnti); 113 } 118 } 114 119 115 if ((br = bRatio[iState][DeltaPi]) > 0.0) { << 120 if ( (br=bRatio[iState][DeltaPi]) >0.0) { 116 AddDeltaPiMode(decayTable, parentName, br, << 121 AddDeltaPiMode( decayTable, parentName, br, iIso3, fAnti); 117 } 122 } 118 123 119 if ((br = bRatio[iState][NStarPi]) > 0.0) { << 124 if ( (br=bRatio[iState][NStarPi]) >0.0) { 120 AddNStarPiMode(decayTable, parentName, br, << 125 AddNStarPiMode( decayTable, parentName, br, iIso3, fAnti); 121 } 126 } 122 127 123 if ((br = bRatio[iState][LambdaK]) > 0.0) { << 128 if ( (br=bRatio[iState][LambdaK]) >0.0) { 124 AddLambdaKMode(decayTable, parentName, br, << 129 AddLambdaKMode( decayTable, parentName, br, iIso3, fAnti); 125 } 130 } 126 131 127 return decayTable; << 132 return decayTable; 128 } 133 } 129 134 130 G4DecayTable* G4ExcitedNucleonConstructor::Add << 135 G4DecayTable* G4ExcitedNucleonConstructor::AddNGammaMode( 131 << 136 G4DecayTable* decayTable, const G4String& nameParent, 132 << 137 G4double br, G4int iIso3, G4bool fAnti) 133 { 138 { 134 G4VDecayChannel* mode; 139 G4VDecayChannel* mode; 135 140 136 // << 141 // 137 G4String daughterN; 142 G4String daughterN; 138 if (iIso3 == +1) { << 143 if (iIso3 == +1) { 139 daughterN = "proton"; << 144 daughterN = "proton"; 140 } << 145 } else { 141 else { << 146 daughterN = "neutron"; 142 daughterN = "neutron"; << 147 } 143 } << 144 if (fAnti) daughterN = "anti_" + daughterN; 148 if (fAnti) daughterN = "anti_" + daughterN; 145 149 146 // create decay channel [parent BR # 150 // create decay channel [parent BR #daughters] 147 mode = new G4PhaseSpaceDecayChannel(namePare << 151 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, >> 152 daughterN,"gamma"); 148 // add decay table 153 // add decay table 149 decayTable->Insert(mode); 154 decayTable->Insert(mode); 150 155 151 return decayTable; 156 return decayTable; 152 } 157 } 153 158 154 G4DecayTable* G4ExcitedNucleonConstructor::Add << 159 G4DecayTable* G4ExcitedNucleonConstructor::AddNPiMode( 155 << 160 G4DecayTable* decayTable, const G4String& nameParent, 156 << 161 G4double br, G4int iIso3, G4bool fAnti) 157 { 162 { 158 G4VDecayChannel* mode; 163 G4VDecayChannel* mode; 159 164 160 G4String daughterN; 165 G4String daughterN; 161 G4String daughterPi; 166 G4String daughterPi; 162 167 163 // ------------ N pi0 ------------ << 168 // ------------ N pi0 ------------ 164 // determine daughters 169 // determine daughters 165 if (iIso3 == +1) { 170 if (iIso3 == +1) { 166 daughterN = "proton"; << 171 daughterN = "proton"; 167 daughterPi = "pi0"; 172 daughterPi = "pi0"; 168 } << 173 } else { 169 else { << 174 daughterN = "neutron"; 170 daughterN = "neutron"; << 171 daughterPi = "pi0"; 175 daughterPi = "pi0"; 172 } 176 } 173 if (fAnti) daughterN = "anti_" + daughterN; 177 if (fAnti) daughterN = "anti_" + daughterN; 174 // create decay channel [parent BR # 178 // create decay channel [parent BR #daughters] 175 mode = new G4PhaseSpaceDecayChannel(namePare << 179 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2, >> 180 daughterN,daughterPi); 176 // add decay table 181 // add decay table 177 decayTable->Insert(mode); 182 decayTable->Insert(mode); 178 183 179 // -------------N pi +/- -------------- << 184 // -------------N pi +/- -------------- 180 // determine daughters 185 // determine daughters 181 if (iIso3 == +1) { 186 if (iIso3 == +1) { 182 daughterN = "neutron"; << 187 daughterN = "neutron"; 183 if (!fAnti) { 188 if (!fAnti) { 184 daughterPi = "pi+"; 189 daughterPi = "pi+"; 185 } << 190 } else { 186 else { << 187 daughterPi = "pi-"; 191 daughterPi = "pi-"; 188 } 192 } 189 } << 193 } else { 190 else { << 194 daughterN = "proton"; 191 daughterN = "proton"; << 192 if (!fAnti) { 195 if (!fAnti) { 193 daughterPi = "pi-"; 196 daughterPi = "pi-"; 194 } << 197 } else { 195 else { << 196 daughterPi = "pi+"; 198 daughterPi = "pi+"; 197 } 199 } 198 } 200 } 199 if (fAnti) daughterN = "anti_" + daughterN; 201 if (fAnti) daughterN = "anti_" + daughterN; 200 202 201 // create decay channel [parent BR # 203 // create decay channel [parent BR #daughters] 202 mode = new G4PhaseSpaceDecayChannel(namePare << 204 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2, >> 205 daughterN,daughterPi); 203 // add decay table 206 // add decay table 204 decayTable->Insert(mode); 207 decayTable->Insert(mode); 205 208 206 return decayTable; 209 return decayTable; 207 } 210 } 208 211 209 G4DecayTable* G4ExcitedNucleonConstructor::Add << 212 G4DecayTable* G4ExcitedNucleonConstructor::AddNEtaMode( 210 << 213 G4DecayTable* decayTable, const G4String& nameParent, 211 << 214 G4double br, G4int iIso3, G4bool fAnti) 212 { 215 { 213 G4VDecayChannel* mode; 216 G4VDecayChannel* mode; 214 217 215 G4String daughterN; 218 G4String daughterN; 216 219 217 // ------------ N eta------------ << 220 // ------------ N eta------------ 218 // determine daughters 221 // determine daughters 219 if (iIso3 == +1) { 222 if (iIso3 == +1) { 220 daughterN = "proton"; << 223 daughterN = "proton"; 221 } << 224 } else { 222 else { << 225 daughterN = "neutron"; 223 daughterN = "neutron"; << 224 } 226 } 225 if (fAnti) daughterN = "anti_" + daughterN; 227 if (fAnti) daughterN = "anti_" + daughterN; 226 // create decay channel [parent BR # 228 // create decay channel [parent BR #daughters] 227 mode = new G4PhaseSpaceDecayChannel(namePare << 229 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, >> 230 daughterN, "eta"); 228 // add decay table 231 // add decay table 229 decayTable->Insert(mode); 232 decayTable->Insert(mode); 230 233 231 return decayTable; 234 return decayTable; 232 } 235 } 233 236 234 G4DecayTable* G4ExcitedNucleonConstructor::Add << 237 G4DecayTable* G4ExcitedNucleonConstructor::AddNOmegaMode( 235 << 238 G4DecayTable* decayTable, const G4String& nameParent, 236 << 239 G4double br, G4int iIso3, G4bool fAnti) 237 { 240 { 238 G4VDecayChannel* mode; 241 G4VDecayChannel* mode; 239 242 240 G4String daughterN; 243 G4String daughterN; 241 244 242 // ------------ N omega------------ << 245 // ------------ N omega------------ 243 // determine daughters 246 // determine daughters 244 if (iIso3 == +1) { 247 if (iIso3 == +1) { 245 daughterN = "proton"; << 248 daughterN = "proton"; 246 } << 249 } else { 247 else { << 250 daughterN = "neutron"; 248 daughterN = "neutron"; << 249 } 251 } 250 if (fAnti) daughterN = "anti_" + daughterN; 252 if (fAnti) daughterN = "anti_" + daughterN; 251 // create decay channel [parent BR # 253 // create decay channel [parent BR #daughters] 252 mode = new G4PhaseSpaceDecayChannel(namePare << 254 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, >> 255 daughterN, "omega"); 253 // add decay table 256 // add decay table 254 decayTable->Insert(mode); 257 decayTable->Insert(mode); 255 258 256 return decayTable; 259 return decayTable; 257 } 260 } 258 261 259 G4DecayTable* G4ExcitedNucleonConstructor::Add << 262 G4DecayTable* G4ExcitedNucleonConstructor::AddNRhoMode( 260 << 263 G4DecayTable* decayTable, const G4String& nameParent, 261 << 264 G4double br, G4int iIso3, G4bool fAnti) 262 { 265 { 263 G4VDecayChannel* mode; 266 G4VDecayChannel* mode; 264 267 265 G4String daughterN; 268 G4String daughterN; 266 G4String daughterRho; 269 G4String daughterRho; 267 270 268 // ------------ N rho0 ------------ << 271 // ------------ N rho0 ------------ 269 // determine daughters 272 // determine daughters 270 if (iIso3 == +1) { 273 if (iIso3 == +1) { 271 daughterN = "proton"; << 274 daughterN = "proton"; 272 daughterRho = "rho0"; 275 daughterRho = "rho0"; 273 } << 276 } else { 274 else { << 277 daughterN = "neutron"; 275 daughterN = "neutron"; << 276 daughterRho = "rho0"; 278 daughterRho = "rho0"; 277 } 279 } 278 if (fAnti) daughterN = "anti_" + daughterN; 280 if (fAnti) daughterN = "anti_" + daughterN; 279 // create decay channel [parent BR # 281 // create decay channel [parent BR #daughters] 280 mode = new G4PhaseSpaceDecayChannel(namePare << 282 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2, >> 283 daughterN,daughterRho); 281 // add decay table 284 // add decay table 282 decayTable->Insert(mode); 285 decayTable->Insert(mode); 283 286 284 // -------------N rho+/- -------------- << 287 // -------------N rho+/- -------------- 285 // determine daughters 288 // determine daughters 286 if (iIso3 == +1) { 289 if (iIso3 == +1) { 287 daughterN = "neutron"; << 290 daughterN = "neutron"; 288 if (!fAnti) { 291 if (!fAnti) { 289 daughterRho = "rho+"; 292 daughterRho = "rho+"; 290 } << 293 } else { 291 else { << 292 daughterRho = "rho-"; 294 daughterRho = "rho-"; 293 } 295 } 294 } << 296 } else { 295 else { << 297 daughterN = "proton"; 296 daughterN = "proton"; << 297 if (!fAnti) { 298 if (!fAnti) { 298 daughterRho = "rho-"; 299 daughterRho = "rho-"; 299 } << 300 } else { 300 else { << 301 daughterRho = "rho+"; 301 daughterRho = "rho+"; 302 } 302 } 303 } 303 } 304 if (fAnti) daughterN = "anti_" + daughterN; 304 if (fAnti) daughterN = "anti_" + daughterN; 305 305 306 // create decay channel [parent BR # 306 // create decay channel [parent BR #daughters] 307 mode = new G4PhaseSpaceDecayChannel(namePare << 307 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2, >> 308 daughterN,daughterRho); 308 // add decay table 309 // add decay table 309 decayTable->Insert(mode); 310 decayTable->Insert(mode); 310 311 311 return decayTable; 312 return decayTable; 312 } 313 } 313 314 314 G4DecayTable* G4ExcitedNucleonConstructor::Add << 315 G4DecayTable* G4ExcitedNucleonConstructor::AddN2PiMode( 315 << 316 G4DecayTable* decayTable, const G4String& nameParent, 316 << 317 G4double br, G4int iIso3, G4bool fAnti) 317 { 318 { 318 // Decay Modes 319 // Decay Modes 319 // N* --> N + pi + pi 320 // N* --> N + pi + pi 320 // Only I=0 states are included for 2-pi << 321 // Only I=0 states are included for 2-pi system 321 << 322 322 G4VDecayChannel* mode; 323 G4VDecayChannel* mode; 323 324 324 G4String daughterN; 325 G4String daughterN; 325 G4String daughterPi1; 326 G4String daughterPi1; 326 G4String daughterPi2; 327 G4String daughterPi2; 327 328 328 // -------------N pi+ pi- -------------- << 329 // -------------N pi+ pi- -------------- 329 // determine daughters 330 // determine daughters 330 if (iIso3 == +1) { 331 if (iIso3 == +1) { 331 daughterN = "proton"; << 332 daughterN = "proton"; 332 daughterPi1 = "pi+"; 333 daughterPi1 = "pi+"; 333 daughterPi2 = "pi-"; 334 daughterPi2 = "pi-"; 334 } << 335 } else { 335 else { << 336 daughterN = "neutron"; 336 daughterN = "neutron"; << 337 daughterPi1 = "pi+"; 337 daughterPi1 = "pi+"; 338 daughterPi2 = "pi-"; 338 daughterPi2 = "pi-"; 339 } 339 } 340 if (fAnti) daughterN = "anti_" + daughterN; 340 if (fAnti) daughterN = "anti_" + daughterN; 341 341 342 // create decay channel [parent BR # 342 // create decay channel [parent BR #daughters] 343 mode = new G4PhaseSpaceDecayChannel(namePare << 343 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 3, >> 344 daughterN,daughterPi1,daughterPi2); 344 // add decay table 345 // add decay table 345 decayTable->Insert(mode); 346 decayTable->Insert(mode); 346 347 347 // -------------N pi0 pi0 -------------- << 348 // -------------N pi0 pi0 -------------- 348 // determine daughters 349 // determine daughters 349 if (iIso3 == +1) { 350 if (iIso3 == +1) { 350 daughterN = "proton"; << 351 daughterN = "proton"; 351 daughterPi1 = "pi0"; 352 daughterPi1 = "pi0"; 352 daughterPi2 = "pi0"; 353 daughterPi2 = "pi0"; 353 } << 354 } else { 354 else { << 355 daughterN = "neutron"; 355 daughterN = "neutron"; << 356 daughterPi1 = "pi0"; 356 daughterPi1 = "pi0"; 357 daughterPi2 = "pi0"; 357 daughterPi2 = "pi0"; 358 } 358 } 359 if (fAnti) daughterN = "anti_" + daughterN; 359 if (fAnti) daughterN = "anti_" + daughterN; 360 360 361 // create decay channel [parent BR # 361 // create decay channel [parent BR #daughters] 362 mode = new G4PhaseSpaceDecayChannel(namePare << 362 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 3, >> 363 daughterN,daughterPi1,daughterPi2); 363 // add decay table 364 // add decay table 364 decayTable->Insert(mode); 365 decayTable->Insert(mode); 365 366 366 return decayTable; 367 return decayTable; 367 } 368 } 368 369 369 G4DecayTable* G4ExcitedNucleonConstructor::Add << 370 G4DecayTable* G4ExcitedNucleonConstructor::AddNStarPiMode( 370 << 371 G4DecayTable* decayTable, const G4String& nameParent, 371 << 372 G4double br, G4int iIso3, G4bool fAnti) 372 { 373 { 373 G4VDecayChannel* mode; 374 G4VDecayChannel* mode; 374 375 375 G4String daughterN; 376 G4String daughterN; 376 G4String daughterPi; 377 G4String daughterPi; 377 378 378 // ------------ N pi0 ------------ << 379 // ------------ N pi0 ------------ 379 // determine daughters 380 // determine daughters 380 if (iIso3 == +1) { 381 if (iIso3 == +1) { 381 daughterN = "N(1440)+"; << 382 daughterN = "N(1440)+"; 382 daughterPi = "pi0"; 383 daughterPi = "pi0"; 383 } << 384 } else { 384 else { << 385 daughterN = "N(1440)0"; 385 daughterN = "N(1440)0"; << 386 daughterPi = "pi0"; 386 daughterPi = "pi0"; 387 } 387 } 388 if (fAnti) daughterN = "anti_" + daughterN; 388 if (fAnti) daughterN = "anti_" + daughterN; 389 // create decay channel [parent BR # 389 // create decay channel [parent BR #daughters] 390 mode = new G4PhaseSpaceDecayChannel(namePare << 390 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2, >> 391 daughterN,daughterPi); 391 // add decay table 392 // add decay table 392 decayTable->Insert(mode); 393 decayTable->Insert(mode); 393 394 394 // -------------N pi +/- -------------- << 395 // -------------N pi +/- -------------- 395 // determine daughters 396 // determine daughters 396 if (iIso3 == +1) { 397 if (iIso3 == +1) { 397 daughterN = "N(1440)0"; << 398 daughterN = "N(1440)0"; 398 if (!fAnti) { 399 if (!fAnti) { 399 daughterPi = "pi+"; 400 daughterPi = "pi+"; 400 } << 401 } else { 401 else { << 402 daughterPi = "pi-"; 402 daughterPi = "pi-"; 403 } 403 } 404 } << 404 } else { 405 else { << 405 daughterN = "N(1440)+"; 406 daughterN = "N(1440)+"; << 407 if (!fAnti) { 406 if (!fAnti) { 408 daughterPi = "pi-"; 407 daughterPi = "pi-"; 409 } << 408 } else { 410 else { << 411 daughterPi = "pi+"; 409 daughterPi = "pi+"; 412 } 410 } 413 } 411 } 414 if (fAnti) daughterN = "anti_" + daughterN; 412 if (fAnti) daughterN = "anti_" + daughterN; 415 413 416 // create decay channel [parent BR # 414 // create decay channel [parent BR #daughters] 417 mode = new G4PhaseSpaceDecayChannel(namePare << 415 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2, >> 416 daughterN,daughterPi); 418 // add decay table 417 // add decay table 419 decayTable->Insert(mode); 418 decayTable->Insert(mode); 420 419 421 return decayTable; 420 return decayTable; 422 } 421 } 423 422 424 G4DecayTable* G4ExcitedNucleonConstructor::Add << 423 G4DecayTable* G4ExcitedNucleonConstructor::AddDeltaPiMode( 425 << 424 G4DecayTable* decayTable, const G4String& nameParent, 426 << 425 G4double br, G4int iIso3, G4bool fAnti) 427 { 426 { 428 G4VDecayChannel* mode; 427 G4VDecayChannel* mode; 429 428 430 G4String daughterDelta; 429 G4String daughterDelta; 431 G4String daughterPi; 430 G4String daughterPi; 432 G4double r; 431 G4double r; 433 432 434 // ------------ Delta pi+/- ------------ << 433 // ------------ Delta pi+/- ------------ 435 // determine daughters 434 // determine daughters 436 if (iIso3 == +1) { 435 if (iIso3 == +1) { 437 daughterDelta = "delta0"; << 436 daughterDelta = "delta0"; 438 if (!fAnti) { 437 if (!fAnti) { 439 daughterPi = "pi+"; 438 daughterPi = "pi+"; 440 } << 439 } else { 441 else { << 442 daughterPi = "pi-"; 440 daughterPi = "pi-"; 443 } 441 } 444 r = br / 6.0; << 442 r = br/6.0; 445 } << 443 } else { 446 else { << 444 daughterDelta = "delta+"; 447 daughterDelta = "delta+"; << 448 if (!fAnti) { 445 if (!fAnti) { 449 daughterPi = "pi-"; 446 daughterPi = "pi-"; 450 } << 447 } else { 451 else { << 452 daughterPi = "pi+"; 448 daughterPi = "pi+"; 453 } 449 } 454 r = br / 6.0; << 450 r = br/6.0; 455 } 451 } 456 if (fAnti) daughterDelta = "anti_" + daughte 452 if (fAnti) daughterDelta = "anti_" + daughterDelta; 457 // create decay channel [parent BR # 453 // create decay channel [parent BR #daughters] 458 mode = new G4PhaseSpaceDecayChannel(namePare << 454 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, >> 455 daughterDelta,daughterPi); 459 // add decay table 456 // add decay table 460 decayTable->Insert(mode); 457 decayTable->Insert(mode); 461 458 462 // ------------ Delta pi+/- ------------ << 459 // ------------ Delta pi+/- ------------ 463 // determine daughters 460 // determine daughters 464 if (iIso3 == +1) { 461 if (iIso3 == +1) { 465 daughterDelta = "delta++"; << 462 daughterDelta = "delta++"; 466 if (!fAnti) { 463 if (!fAnti) { 467 daughterPi = "pi-"; 464 daughterPi = "pi-"; 468 } << 465 } else { 469 else { << 470 daughterPi = "pi+"; 466 daughterPi = "pi+"; 471 } 467 } 472 r = br / 2.0; << 468 r = br/2.0; 473 } << 469 } else { 474 else { << 470 daughterDelta = "delta-"; 475 daughterDelta = "delta-"; << 476 if (!fAnti) { 471 if (!fAnti) { 477 daughterPi = "pi+"; 472 daughterPi = "pi+"; 478 } << 473 } else { 479 else { << 480 daughterPi = "pi-"; 474 daughterPi = "pi-"; 481 } 475 } 482 r = br / 2.0; << 476 r = br/2.0; 483 } 477 } 484 if (fAnti) daughterDelta = "anti_" + daughte 478 if (fAnti) daughterDelta = "anti_" + daughterDelta; 485 // create decay channel [parent BR # 479 // create decay channel [parent BR #daughters] 486 mode = new G4PhaseSpaceDecayChannel(namePare << 480 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, >> 481 daughterDelta,daughterPi); 487 // add decay table 482 // add decay table 488 decayTable->Insert(mode); 483 decayTable->Insert(mode); 489 484 490 // ------------ Delta pi0 ------------ << 485 // ------------ Delta pi0 ------------ 491 // determine daughters 486 // determine daughters 492 if (iIso3 == +1) { 487 if (iIso3 == +1) { 493 daughterDelta = "delta+"; << 488 daughterDelta = "delta+"; 494 daughterPi = "pi0"; 489 daughterPi = "pi0"; 495 r = br / 3.0; << 490 r = br/3.0; 496 } << 491 } else { 497 else { << 492 daughterDelta = "delta0"; 498 daughterDelta = "delta0"; << 499 daughterPi = "pi0"; 493 daughterPi = "pi0"; 500 r = br / 3.0; << 494 r = br/3.0; 501 } 495 } 502 if (fAnti) daughterDelta = "anti_" + daughte 496 if (fAnti) daughterDelta = "anti_" + daughterDelta; 503 // create decay channel [parent BR # 497 // create decay channel [parent BR #daughters] 504 mode = new G4PhaseSpaceDecayChannel(namePare << 498 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, >> 499 daughterDelta,daughterPi); 505 // add decay table 500 // add decay table 506 decayTable->Insert(mode); 501 decayTable->Insert(mode); 507 502 >> 503 508 return decayTable; 504 return decayTable; 509 } 505 } 510 506 511 G4DecayTable* G4ExcitedNucleonConstructor::Add << 507 G4DecayTable* G4ExcitedNucleonConstructor::AddLambdaKMode( 512 << 508 G4DecayTable* decayTable, const G4String& nameParent, 513 << 509 G4double br, G4int iIso3, G4bool fAnti) 514 { 510 { 515 G4VDecayChannel* mode; 511 G4VDecayChannel* mode; 516 512 517 G4String lambda = "lambda"; 513 G4String lambda = "lambda"; 518 G4String daughterK; 514 G4String daughterK; 519 515 520 // ------------ N pi0 ------------ << 516 // ------------ N pi0 ------------ 521 // determine daughters 517 // determine daughters 522 if (iIso3 == +1) { 518 if (iIso3 == +1) { 523 if (!fAnti) { 519 if (!fAnti) { 524 daughterK = "kaon+"; 520 daughterK = "kaon+"; 525 } << 521 } else { 526 else { << 527 daughterK = "kaon-"; 522 daughterK = "kaon-"; 528 } 523 } 529 } << 524 } else { 530 else { << 531 if (!fAnti) { 525 if (!fAnti) { 532 daughterK = "kaon0"; 526 daughterK = "kaon0"; 533 } << 527 } else { 534 else { << 535 daughterK = "anti_kaon0"; 528 daughterK = "anti_kaon0"; 536 } 529 } 537 } 530 } 538 if (fAnti) lambda = "anti_" + lambda; 531 if (fAnti) lambda = "anti_" + lambda; 539 // create decay channel [parent BR # 532 // create decay channel [parent BR #daughters] 540 mode = new G4PhaseSpaceDecayChannel(namePare << 533 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, >> 534 lambda, daughterK); 541 // add decay table 535 // add decay table 542 decayTable->Insert(mode); 536 decayTable->Insert(mode); 543 537 544 return decayTable; 538 return decayTable; 545 } 539 } 546 540 547 // clang-format off << 548 << 549 // PDG2005 541 // PDG2005 550 // N(2090) is renamed to N(2080) << 542 // N(2090) is renamed to N(2080) 551 // but keep unchanged temporalily Apr 06 543 // but keep unchanged temporalily Apr 06 552 // << 553 // -> PDG2023: N(2090) is removed by S.Okada 4 << 554 544 555 const char* G4ExcitedNucleonConstructor::name[ 545 const char* G4ExcitedNucleonConstructor::name[] = { 556 "N(1440)", "N(1520)", "N(1535)", "N(1650)", 546 "N(1440)", "N(1520)", "N(1535)", "N(1650)", "N(1675)", 557 "N(1680)", "N(1700)", "N(1710)", "N(1720)", << 547 "N(1680)", "N(1700)", "N(1710)", "N(1720)", "N(1900)", 558 "N(1990)", "N(2090)", "N(2190)", "N(2220)", 548 "N(1990)", "N(2090)", "N(2190)", "N(2220)", "N(2250)" 559 }; 549 }; 560 550 561 const G4double G4ExcitedNucleonConstructor::ma 551 const G4double G4ExcitedNucleonConstructor::mass[] = { 562 1.440*GeV, 1.515*GeV, 1.535*GeV, 1.650*GeV, << 552 1.430*GeV, 1.515*GeV, 1.535*GeV, 1.655*GeV, 1.675*GeV, 563 1.685*GeV, 1.720*GeV, 1.710*GeV, 1.720*GeV, << 553 1.685*GeV, 1.700*GeV, 1.710*GeV, 1.720*GeV, 1.900*GeV, 564 2.020*GeV, 2.080*GeV, 2.180*GeV, 2.250*GeV, << 554 1.950*GeV, 2.080*GeV, 2.190*GeV, 2.250*GeV, 2.275*GeV 565 }; 555 }; 566 556 567 const G4double G4ExcitedNucleonConstructor::wi 557 const G4double G4ExcitedNucleonConstructor::width[] = { 568 350.0*MeV, 110.0*MeV, 150.0*MeV, 125.0*MeV, << 558 350.0*MeV, 115.0*MeV, 150.0*MeV, 140.0*MeV, 150.0*MeV, 569 120.0*MeV, 200.0*MeV, 140.0*MeV, 250.0*MeV, << 559 130.0*MeV, 150.0*MeV, 100.0*MeV, 250.0*MeV, 500.0*MeV, 570 300.0*MeV, 350.0*MeV, 400.0*MeV, 400.0*MeV, << 560 555.0*MeV, 350.0*MeV, 500.0*MeV, 400.0*MeV, 500.0*MeV 571 }; 561 }; 572 562 573 const G4int G4ExcitedNucleonConstructor::iSpin 563 const G4int G4ExcitedNucleonConstructor::iSpin[] = { 574 1, 3, 1, 1, 5, 564 1, 3, 1, 1, 5, 575 5, 3, 1, 3, 3, 565 5, 3, 1, 3, 3, 576 7, 3, 7, 9, 9 566 7, 3, 7, 9, 9 577 }; 567 }; 578 568 579 const G4int G4ExcitedNucleonConstructor::iPari 569 const G4int G4ExcitedNucleonConstructor::iParity[] = { 580 +1, -1, -1, -1, -1, 570 +1, -1, -1, -1, -1, 581 +1, -1, +1, +1, +1, 571 +1, -1, +1, +1, +1, 582 +1, -1, +1, -1, -1 << 572 +1, -1, +1, -1, -1 583 }; 573 }; 584 574 585 const G4int G4ExcitedNucleonConstructor::encod 575 const G4int G4ExcitedNucleonConstructor::encodingOffset[] = { 586 10000, 0, 20000, 30000, 0, 576 10000, 0, 20000, 30000, 0, 587 10000, 20000, 40000, 30000, 40000, << 577 10000, 20000, 40000, 30000, 40000, 588 10000, 50000, 0, 0, 10000 << 578 10000, 50000, 0, 0, 10000 589 }; 579 }; 590 580 591 const G4double G4ExcitedNucleonConstructor::bR << 581 const G4double G4ExcitedNucleonConstructor::bRatio[ G4ExcitedNucleonConstructor::NStates ][ G4ExcitedNucleonConstructor::NumberOfDecayModes] = 592 { 582 { 593 { 0.0, 0.70, 0.0, 0.0, 0.0, 0.05, 0.2 << 583 { 0.0, 0.70, 0.0, 0.0, 0.0, 0.05, 0.25, 0.0, 0.0}, 594 { 0.0, 0.60, 0.0, 0.0, 0.0, 0.15, 0.2 << 584 { 0.0, 0.60, 0.0, 0.0, 0.0, 0.15, 0.25, 0.0, 0.0}, 595 {0.001, 0.55, 0.35, 0.0, 0.0, 0.05, 0.0 585 {0.001, 0.55, 0.35, 0.0, 0.0, 0.05, 0.00, 0.05, 0.0}, 596 { 0.0, 0.65, 0.05, 0.0, 0.0, 0.05, 0.1 586 { 0.0, 0.65, 0.05, 0.0, 0.0, 0.05, 0.10, 0.05, 0.10}, 597 { 0.0, 0.45, 0.0, 0.0, 0.0, 0.00, 0.5 587 { 0.0, 0.45, 0.0, 0.0, 0.0, 0.00, 0.55, 0.0, 0.0}, 598 { 0.0, 0.65, 0.0, 0.0, 0.0, 0.20, 0.1 588 { 0.0, 0.65, 0.0, 0.0, 0.0, 0.20, 0.15, 0.0, 0.0}, 599 { 0.0, 0.10, 0.05, 0.0, 0.05, 0.45, 0.3 589 { 0.0, 0.10, 0.05, 0.0, 0.05, 0.45, 0.35, 0.0, 0.0}, 600 { 0.0, 0.15, 0.20, 0.0, 0.05, 0.20, 0.2 590 { 0.0, 0.15, 0.20, 0.0, 0.05, 0.20, 0.20, 0.10, 0.10}, 601 { 0.0, 0.15, 0.00, 0.0, 0.25, 0.45, 0.1 591 { 0.0, 0.15, 0.00, 0.0, 0.25, 0.45, 0.10, 0.00, 0.05}, 602 { 0.0, 0.35, 0.0, 0.55, 0.05, 0.00, 0.0 592 { 0.0, 0.35, 0.0, 0.55, 0.05, 0.00, 0.05, 0.0, 0.0}, 603 { 0.0, 0.05, 0.0, 0.0, 0.15, 0.25, 0.3 593 { 0.0, 0.05, 0.0, 0.0, 0.15, 0.25, 0.30, 0.15, 0.10}, 604 { 0.0, 0.60, 0.05, 0.0, 0.25, 0.05, 0.0 594 { 0.0, 0.60, 0.05, 0.0, 0.25, 0.05, 0.05, 0.0, 0.0}, 605 { 0.0, 0.35, 0.0, 0.00, 0.30, 0.15, 0.1 595 { 0.0, 0.35, 0.0, 0.00, 0.30, 0.15, 0.15, 0.05, 0.0}, 606 { 0.0, 0.35, 0.0, 0.0, 0.25, 0.20, 0.2 596 { 0.0, 0.35, 0.0, 0.0, 0.25, 0.20, 0.20, 0.0, 0.0}, 607 { 0.0, 0.30, 0.0, 0.00, 0.25, 0.20, 0.2 597 { 0.0, 0.30, 0.0, 0.00, 0.25, 0.20, 0.20, 0.05, 0.0} 608 }; 598 }; >> 599 >> 600 >> 601 >> 602 >> 603 >> 604 >> 605 >> 606 >> 607 >> 608 >> 609 >> 610 >> 611 >> 612 >> 613 >> 614 609 615