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 // Geant4 class G4HadronicBuilder 27 // Geant4 class G4HadronicBuilder 28 // 28 // 29 // Author V.Ivanchenko 14.05.2020 29 // Author V.Ivanchenko 14.05.2020 30 // 30 // 31 31 32 #include "G4HadronicBuilder.hh" 32 #include "G4HadronicBuilder.hh" 33 #include "G4HadParticles.hh" 33 #include "G4HadParticles.hh" 34 #include "G4HadProcesses.hh" 34 #include "G4HadProcesses.hh" 35 35 36 #include "G4ParticleDefinition.hh" 36 #include "G4ParticleDefinition.hh" 37 #include "G4ParticleTable.hh" 37 #include "G4ParticleTable.hh" 38 #include "G4PhysicsListHelper.hh" 38 #include "G4PhysicsListHelper.hh" 39 #include "G4SystemOfUnits.hh" << 40 39 41 #include "G4HadronicParameters.hh" 40 #include "G4HadronicParameters.hh" 42 41 43 #include "G4TheoFSGenerator.hh" 42 #include "G4TheoFSGenerator.hh" 44 #include "G4FTFModel.hh" 43 #include "G4FTFModel.hh" 45 #include "G4ExcitedStringDecay.hh" 44 #include "G4ExcitedStringDecay.hh" 46 #include "G4GeneratorPrecompoundInterface.hh" 45 #include "G4GeneratorPrecompoundInterface.hh" 47 46 48 #include "G4QGSModel.hh" 47 #include "G4QGSModel.hh" 49 #include "G4QGSParticipants.hh" 48 #include "G4QGSParticipants.hh" 50 #include "G4QGSMFragmentation.hh" 49 #include "G4QGSMFragmentation.hh" 51 #include "G4QuasiElasticChannel.hh" 50 #include "G4QuasiElasticChannel.hh" 52 51 53 #include "G4CascadeInterface.hh" 52 #include "G4CascadeInterface.hh" 54 #include "G4CrossSectionDataSetRegistry.hh" 53 #include "G4CrossSectionDataSetRegistry.hh" 55 #include "G4CrossSectionInelastic.hh" 54 #include "G4CrossSectionInelastic.hh" 56 #include "G4CrossSectionElastic.hh" 55 #include "G4CrossSectionElastic.hh" 57 #include "G4HadronElastic.hh" 56 #include "G4HadronElastic.hh" 58 #include "G4CrossSectionDataSetRegistry.hh" 57 #include "G4CrossSectionDataSetRegistry.hh" 59 58 60 #include "G4HadronElasticProcess.hh" 59 #include "G4HadronElasticProcess.hh" 61 #include "G4HadronInelasticProcess.hh" 60 #include "G4HadronInelasticProcess.hh" 62 61 63 #include "G4DecayTable.hh" 62 #include "G4DecayTable.hh" 64 #include "G4VDecayChannel.hh" 63 #include "G4VDecayChannel.hh" 65 #include "G4PhaseSpaceDecayChannel.hh" 64 #include "G4PhaseSpaceDecayChannel.hh" 66 65 67 #include "G4PreCompoundModel.hh" << 68 #include "G4INCLXXInterface.hh" << 69 #include "G4ComponentAntiNuclNuclearXS.hh" << 70 << 71 << 72 << 73 void G4HadronicBuilder::BuildFTFP_BERT(const s 66 void G4HadronicBuilder::BuildFTFP_BERT(const std::vector<G4int>& partList, 74 G4bool 67 G4bool bert, const G4String& xsName) { 75 68 76 G4HadronicParameters* param = G4HadronicPara 69 G4HadronicParameters* param = G4HadronicParameters::Instance(); 77 G4PhysicsListHelper* ph = G4PhysicsListHelpe 70 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper(); 78 71 79 auto theModel = new G4TheoFSGenerator("FTFP" 72 auto theModel = new G4TheoFSGenerator("FTFP"); 80 auto theStringModel = new G4FTFModel(); 73 auto theStringModel = new G4FTFModel(); 81 theStringModel->SetFragmentationModel(new G4 74 theStringModel->SetFragmentationModel(new G4ExcitedStringDecay()); 82 theModel->SetHighEnergyGenerator( theStringM 75 theModel->SetHighEnergyGenerator( theStringModel ); 83 theModel->SetTransport( new G4GeneratorPreco 76 theModel->SetTransport( new G4GeneratorPrecompoundInterface() ); 84 theModel->SetMaxEnergy( param->GetMaxEnergy( 77 theModel->SetMaxEnergy( param->GetMaxEnergy() ); 85 78 86 G4CascadeInterface* theCascade = nullptr; 79 G4CascadeInterface* theCascade = nullptr; 87 if(bert) { 80 if(bert) { 88 theCascade = new G4CascadeInterface(); 81 theCascade = new G4CascadeInterface(); 89 theCascade->SetMaxEnergy( param->GetMaxEne 82 theCascade->SetMaxEnergy( param->GetMaxEnergyTransitionFTF_Cascade() ); 90 theModel->SetMinEnergy( param->GetMinEnerg 83 theModel->SetMinEnergy( param->GetMinEnergyTransitionFTF_Cascade() ); 91 } 84 } 92 85 93 auto xsinel = G4HadProcesses::InelasticXS( x 86 auto xsinel = G4HadProcesses::InelasticXS( xsName ); 94 87 95 G4ParticleTable* table = G4ParticleTable::Ge 88 G4ParticleTable* table = G4ParticleTable::GetParticleTable(); 96 for( auto & pdg : partList ) { 89 for( auto & pdg : partList ) { 97 90 98 auto part = table->FindParticle( pdg ); 91 auto part = table->FindParticle( pdg ); 99 if ( part == nullptr ) { continue; } 92 if ( part == nullptr ) { continue; } 100 93 101 auto hadi = new G4HadronInelasticProcess( 94 auto hadi = new G4HadronInelasticProcess( part->GetParticleName()+"Inelastic", part ); 102 hadi->AddDataSet( xsinel ); 95 hadi->AddDataSet( xsinel ); 103 hadi->RegisterMe( theModel ); 96 hadi->RegisterMe( theModel ); 104 if( theCascade != nullptr ) hadi->Register 97 if( theCascade != nullptr ) hadi->RegisterMe( theCascade ); 105 if( param->ApplyFactorXS() ) hadi->Multipl 98 if( param->ApplyFactorXS() ) hadi->MultiplyCrossSectionBy( param->XSFactorHadronInelastic() ); 106 ph->RegisterProcess(hadi, part); 99 ph->RegisterProcess(hadi, part); 107 } 100 } 108 } 101 } 109 102 110 void G4HadronicBuilder::BuildFTFQGSP_BERT(cons 103 void G4HadronicBuilder::BuildFTFQGSP_BERT(const std::vector<G4int>& partList, 111 G4bo 104 G4bool bert, const G4String& xsName) { 112 105 113 G4HadronicParameters* param = G4HadronicPara 106 G4HadronicParameters* param = G4HadronicParameters::Instance(); 114 G4PhysicsListHelper* ph = G4PhysicsListHelpe 107 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper(); 115 108 116 auto theModel = new G4TheoFSGenerator("FTFQG 109 auto theModel = new G4TheoFSGenerator("FTFQGSP"); 117 auto theStringModel = new G4FTFModel(); 110 auto theStringModel = new G4FTFModel(); 118 theStringModel->SetFragmentationModel(new G4 111 theStringModel->SetFragmentationModel(new G4ExcitedStringDecay( new G4QGSMFragmentation() ) ); 119 theModel->SetHighEnergyGenerator( theStringM 112 theModel->SetHighEnergyGenerator( theStringModel ); 120 theModel->SetTransport( new G4GeneratorPreco 113 theModel->SetTransport( new G4GeneratorPrecompoundInterface() ); 121 theModel->SetMaxEnergy( param->GetMaxEnergy( 114 theModel->SetMaxEnergy( param->GetMaxEnergy() ); 122 115 123 G4CascadeInterface* theCascade = nullptr; 116 G4CascadeInterface* theCascade = nullptr; 124 if(bert) { 117 if(bert) { 125 theCascade = new G4CascadeInterface(); 118 theCascade = new G4CascadeInterface(); 126 theCascade->SetMaxEnergy( param->GetMaxEne 119 theCascade->SetMaxEnergy( param->GetMaxEnergyTransitionFTF_Cascade() ); 127 theModel->SetMinEnergy( param->GetMinEnerg 120 theModel->SetMinEnergy( param->GetMinEnergyTransitionFTF_Cascade() ); 128 } 121 } 129 122 130 auto xsinel = G4HadProcesses::InelasticXS( x 123 auto xsinel = G4HadProcesses::InelasticXS( xsName ); 131 124 132 G4ParticleTable* table = G4ParticleTable::Ge 125 G4ParticleTable* table = G4ParticleTable::GetParticleTable(); 133 for( auto & pdg : partList ) { 126 for( auto & pdg : partList ) { 134 127 135 auto part = table->FindParticle( pdg ); 128 auto part = table->FindParticle( pdg ); 136 if ( part == nullptr ) { continue; } 129 if ( part == nullptr ) { continue; } 137 130 138 auto hadi = new G4HadronInelasticProcess( 131 auto hadi = new G4HadronInelasticProcess( part->GetParticleName()+"Inelastic", part ); 139 hadi->AddDataSet( xsinel ); 132 hadi->AddDataSet( xsinel ); 140 hadi->RegisterMe( theModel ); 133 hadi->RegisterMe( theModel ); 141 if( theCascade != nullptr ) hadi->Register 134 if( theCascade != nullptr ) hadi->RegisterMe( theCascade ); 142 if( param->ApplyFactorXS() ) hadi->Multipl 135 if( param->ApplyFactorXS() ) hadi->MultiplyCrossSectionBy( param->XSFactorHadronInelastic() ); 143 ph->RegisterProcess(hadi, part); 136 ph->RegisterProcess(hadi, part); 144 } 137 } 145 } 138 } 146 139 147 void G4HadronicBuilder::BuildQGSP_FTFP_BERT(co 140 void G4HadronicBuilder::BuildQGSP_FTFP_BERT(const std::vector<G4int>& partList, 148 G4 141 G4bool bert, G4bool quasiElastic, 149 co 142 const G4String& xsName) { 150 143 151 G4HadronicParameters* param = G4HadronicPara 144 G4HadronicParameters* param = G4HadronicParameters::Instance(); 152 G4PhysicsListHelper* ph = G4PhysicsListHelpe 145 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper(); 153 146 154 auto theTransport = new G4GeneratorPrecompou 147 auto theTransport = new G4GeneratorPrecompoundInterface(); 155 148 156 auto theHEModel = new G4TheoFSGenerator("QGS 149 auto theHEModel = new G4TheoFSGenerator("QGSP"); 157 G4QGSModel< G4QGSParticipants >* theQGSModel 150 G4QGSModel< G4QGSParticipants >* theQGSModel = new G4QGSModel< G4QGSParticipants >; 158 theQGSModel->SetFragmentationModel( new G4Ex 151 theQGSModel->SetFragmentationModel( new G4ExcitedStringDecay( new G4QGSMFragmentation() ) ); 159 theHEModel->SetTransport( theTransport ); 152 theHEModel->SetTransport( theTransport ); 160 theHEModel->SetHighEnergyGenerator( theQGSMo 153 theHEModel->SetHighEnergyGenerator( theQGSModel ); 161 if (quasiElastic) { 154 if (quasiElastic) { 162 theHEModel->SetQuasiElasticChannel(new G4Q 155 theHEModel->SetQuasiElasticChannel(new G4QuasiElasticChannel()); 163 } 156 } 164 theHEModel->SetMinEnergy( param->GetMinEnerg 157 theHEModel->SetMinEnergy( param->GetMinEnergyTransitionQGS_FTF() ); 165 theHEModel->SetMaxEnergy( param->GetMaxEnerg 158 theHEModel->SetMaxEnergy( param->GetMaxEnergy() ); 166 159 167 auto theLEModel = new G4TheoFSGenerator("FTF 160 auto theLEModel = new G4TheoFSGenerator("FTFP"); 168 auto theFTFModel = new G4FTFModel(); 161 auto theFTFModel = new G4FTFModel(); 169 theFTFModel->SetFragmentationModel(new G4Exc 162 theFTFModel->SetFragmentationModel(new G4ExcitedStringDecay()); 170 theLEModel->SetHighEnergyGenerator( theFTFMo 163 theLEModel->SetHighEnergyGenerator( theFTFModel ); 171 theLEModel->SetTransport( theTransport ); 164 theLEModel->SetTransport( theTransport ); 172 theLEModel->SetMaxEnergy( param->GetMaxEnerg 165 theLEModel->SetMaxEnergy( param->GetMaxEnergyTransitionQGS_FTF() ); 173 166 174 G4CascadeInterface* theCascade = nullptr; 167 G4CascadeInterface* theCascade = nullptr; 175 if(bert) { 168 if(bert) { 176 theCascade = new G4CascadeInterface(); 169 theCascade = new G4CascadeInterface(); 177 theCascade->SetMaxEnergy( param->GetMaxEne 170 theCascade->SetMaxEnergy( param->GetMaxEnergyTransitionFTF_Cascade() ); 178 theLEModel->SetMinEnergy( param->GetMinEne 171 theLEModel->SetMinEnergy( param->GetMinEnergyTransitionFTF_Cascade() ); 179 } 172 } 180 173 181 auto xsinel = G4HadProcesses::InelasticXS( x 174 auto xsinel = G4HadProcesses::InelasticXS( xsName ); 182 175 183 G4ParticleTable* table = G4ParticleTable::Ge 176 G4ParticleTable* table = G4ParticleTable::GetParticleTable(); 184 for( auto & pdg : partList ) { 177 for( auto & pdg : partList ) { 185 178 186 auto part = table->FindParticle( pdg ); 179 auto part = table->FindParticle( pdg ); 187 if ( part == nullptr ) { continue; } 180 if ( part == nullptr ) { continue; } 188 181 189 auto hadi = new G4HadronInelasticProcess( 182 auto hadi = new G4HadronInelasticProcess( part->GetParticleName()+"Inelastic", part ); 190 hadi->AddDataSet( xsinel ); 183 hadi->AddDataSet( xsinel ); 191 hadi->RegisterMe( theHEModel ); 184 hadi->RegisterMe( theHEModel ); 192 hadi->RegisterMe( theLEModel ); 185 hadi->RegisterMe( theLEModel ); 193 if(theCascade != nullptr) hadi->RegisterMe 186 if(theCascade != nullptr) hadi->RegisterMe( theCascade ); 194 if( param->ApplyFactorXS() ) hadi->Multipl 187 if( param->ApplyFactorXS() ) hadi->MultiplyCrossSectionBy( param->XSFactorHadronInelastic() ); 195 ph->RegisterProcess(hadi, part); 188 ph->RegisterProcess(hadi, part); 196 } 189 } 197 } 190 } 198 191 199 void G4HadronicBuilder::BuildINCLXX(const std: << 200 G4bool << 201 << 202 // FTF << 203 G4HadronicParameters* param = G4HadronicPara << 204 G4PhysicsListHelper* ph = G4PhysicsListHelpe << 205 << 206 auto theModel = new G4TheoFSGenerator("FTFP" << 207 auto theStringModel = new G4FTFModel(); << 208 theStringModel->SetFragmentationModel(new G4 << 209 theModel->SetHighEnergyGenerator( theStringM << 210 theModel->SetTransport( new G4GeneratorPreco << 211 theModel->SetMaxEnergy( param->GetMaxEnergy( << 212 << 213 G4CascadeInterface* theCascade = nullptr; << 214 if(bert) { << 215 theCascade = new G4CascadeInterface(); << 216 theCascade->SetMaxEnergy( param->GetMaxEne << 217 theModel->SetMinEnergy( param->GetMinEnerg << 218 } << 219 << 220 // INCLXX << 221 auto theModelINCLXX = new G4INCLXXInterface( << 222 theModelINCLXX->SetMinEnergy( param->GetMinE << 223 theModelINCLXX->SetMaxEnergy( param->GetMaxE << 224 << 225 // << 226 auto xsinel = G4HadProcesses::InelasticXS( x << 227 << 228 G4ParticleTable* table = G4ParticleTable::Ge << 229 for( auto & pdg : partList ) { << 230 << 231 auto part = table->FindParticle( pdg ); << 232 if ( part == nullptr ) { continue; } << 233 << 234 auto hadi = new G4HadronInelasticProcess( << 235 if( pdg == -2212 ) { // pbar use INCLXX << 236 hadi->AddDataSet( xsinel ); << 237 hadi->RegisterMe( theModelINCLXX ); << 238 if( param->ApplyFactorXS() ) hadi->Multi << 239 ph->RegisterProcess(hadi, part); << 240 } else { // other anti-X use FTF << 241 hadi->AddDataSet( xsinel ); << 242 hadi->RegisterMe( theModel ); << 243 if( theCascade != nullptr ) hadi->Register << 244 if( param->ApplyFactorXS() ) hadi->Multipl << 245 ph->RegisterProcess(hadi, part); << 246 } << 247 } << 248 } << 249 << 250 void G4HadronicBuilder::BuildElastic(const std 192 void G4HadronicBuilder::BuildElastic(const std::vector<G4int>& partList) { 251 193 252 G4HadronicParameters* param = G4HadronicPara 194 G4HadronicParameters* param = G4HadronicParameters::Instance(); 253 G4PhysicsListHelper* ph = G4PhysicsListHelpe 195 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper(); 254 196 255 auto xsel = G4HadProcesses::ElasticXS("Glaub 197 auto xsel = G4HadProcesses::ElasticXS("Glauber-Gribov"); 256 198 257 auto elModel = new G4HadronElastic(); 199 auto elModel = new G4HadronElastic(); 258 elModel->SetMaxEnergy( param->GetMaxEnergy() 200 elModel->SetMaxEnergy( param->GetMaxEnergy() ); 259 201 260 G4ParticleTable* table = G4ParticleTable::Ge 202 G4ParticleTable* table = G4ParticleTable::GetParticleTable(); 261 for( auto & pdg : partList ) { 203 for( auto & pdg : partList ) { 262 204 263 auto part = table->FindParticle( pdg ); 205 auto part = table->FindParticle( pdg ); 264 if ( part == nullptr ) { continue; } 206 if ( part == nullptr ) { continue; } 265 207 266 auto hade = new G4HadronElasticProcess(); 208 auto hade = new G4HadronElasticProcess(); 267 hade->AddDataSet( xsel ); 209 hade->AddDataSet( xsel ); 268 hade->RegisterMe( elModel ); 210 hade->RegisterMe( elModel ); 269 if( param->ApplyFactorXS() ) hade->Multipl 211 if( param->ApplyFactorXS() ) hade->MultiplyCrossSectionBy( param->XSFactorHadronElastic() ); 270 ph->RegisterProcess(hade, part); 212 ph->RegisterProcess(hade, part); 271 } 213 } 272 } 214 } 273 215 274 void G4HadronicBuilder::BuildHyperonsFTFP_BERT 216 void G4HadronicBuilder::BuildHyperonsFTFP_BERT() { 275 // For hyperons, Bertini is used at low ener 217 // For hyperons, Bertini is used at low energies; 276 // for anti-hyperons, FTFP can be used down 218 // for anti-hyperons, FTFP can be used down to zero kinetic energy. 277 BuildFTFP_BERT(G4HadParticles::GetHyperons() 219 BuildFTFP_BERT(G4HadParticles::GetHyperons(), true, "Glauber-Gribov"); 278 BuildFTFP_BERT(G4HadParticles::GetAntiHypero 220 BuildFTFP_BERT(G4HadParticles::GetAntiHyperons(), false, "Glauber-Gribov"); 279 } 221 } 280 222 281 void G4HadronicBuilder::BuildHyperonsFTFQGSP_B 223 void G4HadronicBuilder::BuildHyperonsFTFQGSP_BERT() { 282 // For hyperons, Bertini is used at low ener 224 // For hyperons, Bertini is used at low energies; 283 // for anti-hyperons, FTFP can be used down 225 // for anti-hyperons, FTFP can be used down to zero kinetic energy. 284 BuildFTFQGSP_BERT(G4HadParticles::GetHyperon 226 BuildFTFQGSP_BERT(G4HadParticles::GetHyperons(), true, "Glauber-Gribov"); 285 BuildFTFQGSP_BERT(G4HadParticles::GetAntiHyp 227 BuildFTFQGSP_BERT(G4HadParticles::GetAntiHyperons(), false, "Glauber-Gribov"); 286 } 228 } 287 229 288 void G4HadronicBuilder::BuildHyperonsQGSP_FTFP 230 void G4HadronicBuilder::BuildHyperonsQGSP_FTFP_BERT(G4bool qElastic) { 289 // For hyperons, Bertini is used at low ener 231 // For hyperons, Bertini is used at low energies; 290 // for anti-hyperons, FTFP can be used down 232 // for anti-hyperons, FTFP can be used down to zero kinetic energy. 291 // QGSP is used at high energies in all case 233 // QGSP is used at high energies in all cases. 292 BuildQGSP_FTFP_BERT(G4HadParticles::GetHyper 234 BuildQGSP_FTFP_BERT(G4HadParticles::GetHyperons(), true, qElastic, "Glauber-Gribov"); 293 BuildQGSP_FTFP_BERT(G4HadParticles::GetAntiH 235 BuildQGSP_FTFP_BERT(G4HadParticles::GetAntiHyperons(), false, qElastic, "Glauber-Gribov"); 294 } 236 } 295 237 296 void G4HadronicBuilder::BuildKaonsFTFP_BERT() 238 void G4HadronicBuilder::BuildKaonsFTFP_BERT() { 297 BuildFTFP_BERT(G4HadParticles::GetKaons(), t 239 BuildFTFP_BERT(G4HadParticles::GetKaons(), true, "Glauber-Gribov"); 298 } 240 } 299 241 300 void G4HadronicBuilder::BuildKaonsFTFQGSP_BERT 242 void G4HadronicBuilder::BuildKaonsFTFQGSP_BERT() { 301 BuildFTFQGSP_BERT(G4HadParticles::GetKaons() << 243 BuildFTFP_BERT(G4HadParticles::GetKaons(), true, "Glauber-Gribov"); 302 } 244 } 303 245 304 void G4HadronicBuilder::BuildKaonsQGSP_FTFP_BE 246 void G4HadronicBuilder::BuildKaonsQGSP_FTFP_BERT(G4bool qElastic) { 305 BuildQGSP_FTFP_BERT(G4HadParticles::GetKaons 247 BuildQGSP_FTFP_BERT(G4HadParticles::GetKaons(), true, qElastic, "Glauber-Gribov"); 306 } 248 } 307 249 308 void G4HadronicBuilder::BuildAntiLightIonsFTFP 250 void G4HadronicBuilder::BuildAntiLightIonsFTFP() { 309 BuildFTFP_BERT(G4HadParticles::GetLightAntiI 251 BuildFTFP_BERT(G4HadParticles::GetLightAntiIons(), false, "AntiAGlauber"); 310 } 252 } 311 253 312 //void G4HadronicBuilder::BuildAntiLightIonsQG 254 //void G4HadronicBuilder::BuildAntiLightIonsQGSP_FTFP(G4bool qElastic) { 313 // Note: currently QGSP cannot be applied for 255 // Note: currently QGSP cannot be applied for any ion or anti-ion! 314 // BuildQGSP_FTFP_BERT(G4HadParticles::GetLig 256 // BuildQGSP_FTFP_BERT(G4HadParticles::GetLightAntiIons(), false, qElastic, "AntiAGlauber"); 315 //} 257 //} 316 258 317 void G4HadronicBuilder::BuildAntiLightIonsINCL << 318 BuildINCLXX(G4HadParticles::GetLightAntiIons << 319 } << 320 << 321 void G4HadronicBuilder::BuildBCHadronsFTFP_BER 259 void G4HadronicBuilder::BuildBCHadronsFTFP_BERT() { 322 if( G4HadronicParameters::Instance()->Enable 260 if( G4HadronicParameters::Instance()->EnableBCParticles() ) { 323 // Bertini is not applicable for charm and 261 // Bertini is not applicable for charm and bottom hadrons, therefore FTFP is used 324 // down to zero kinetic energy (but at ver 262 // down to zero kinetic energy (but at very low energies, a dummy model is used 325 // that returns the projectile heavy hadro 263 // that returns the projectile heavy hadron in the final state). 326 BuildFTFP_BERT(G4HadParticles::GetBCHadron 264 BuildFTFP_BERT(G4HadParticles::GetBCHadrons(), false, "Glauber-Gribov"); 327 BuildDecayTableForBCHadrons(); 265 BuildDecayTableForBCHadrons(); 328 } 266 } 329 } 267 } 330 268 331 void G4HadronicBuilder::BuildBCHadronsFTFQGSP_ 269 void G4HadronicBuilder::BuildBCHadronsFTFQGSP_BERT() { 332 if( G4HadronicParameters::Instance()->Enable 270 if( G4HadronicParameters::Instance()->EnableBCParticles() ) { 333 // Bertini is not applicable for charm and 271 // Bertini is not applicable for charm and bottom hadrons, therefore FTFP is used 334 // down to zero kinetic energy (but at ver 272 // down to zero kinetic energy (but at very low energies, a dummy model is used 335 // that returns the projectile heavy hadro 273 // that returns the projectile heavy hadron in the final state). 336 BuildFTFQGSP_BERT(G4HadParticles::GetBCHad 274 BuildFTFQGSP_BERT(G4HadParticles::GetBCHadrons(), false, "Glauber-Gribov"); 337 BuildDecayTableForBCHadrons(); 275 BuildDecayTableForBCHadrons(); 338 } 276 } 339 } 277 } 340 278 341 void G4HadronicBuilder::BuildBCHadronsQGSP_FTF 279 void G4HadronicBuilder::BuildBCHadronsQGSP_FTFP_BERT(G4bool qElastic) { 342 if( G4HadronicParameters::Instance()->Enable 280 if( G4HadronicParameters::Instance()->EnableBCParticles() ) { 343 // Bertini is not applicable for charm and 281 // Bertini is not applicable for charm and bottom hadrons, therefore FTFP is used 344 // down to zero kinetic energy (but at ver 282 // down to zero kinetic energy (but at very low energies, a dummy model is used 345 // that returns the projectile heavy hadro 283 // that returns the projectile heavy hadron in the final state). 346 // QGSP is used at high energies in all ca 284 // QGSP is used at high energies in all cases. 347 BuildQGSP_FTFP_BERT(G4HadParticles::GetBCH 285 BuildQGSP_FTFP_BERT(G4HadParticles::GetBCHadrons(), false, qElastic, "Glauber-Gribov"); 348 BuildDecayTableForBCHadrons(); 286 BuildDecayTableForBCHadrons(); 349 } 287 } 350 } 288 } 351 289 352 void G4HadronicBuilder::BuildDecayTableForBCHa 290 void G4HadronicBuilder::BuildDecayTableForBCHadrons() { 353 // Geant4 does not define the decay of most 291 // Geant4 does not define the decay of most of charmed and bottom hadrons. 354 // The reason is that most of these heavy ha 292 // The reason is that most of these heavy hadrons have many different 355 // decay channels, with a complex dynamics, 293 // decay channels, with a complex dynamics, quite different from the flat 356 // phase space kinematical treatment used in 294 // phase space kinematical treatment used in Geant4 for most of hadronic decays. 357 // High-energy experiments usually use dedic 295 // High-energy experiments usually use dedicated Monte Carlo Event Generators 358 // for the decays of charmed and bottom hadr 296 // for the decays of charmed and bottom hadrons; therefore, these heavy 359 // hadrons, which are passed to Geant4 as pr 297 // hadrons, which are passed to Geant4 as primary tracks, have pre-assigned 360 // decays. Moreover, no charmed or bottom se 298 // decays. Moreover, no charmed or bottom secondary hadrons were created 361 // in Geant4 hadronic interactions before Ge 299 // in Geant4 hadronic interactions before Geant4 10.7. 362 // With the extension of Geant4 hadronic int 300 // With the extension of Geant4 hadronic interactions to charmed and bottom 363 // hadrons, in version Geant4 10.7, we do ne 301 // hadrons, in version Geant4 10.7, we do need to define decays in Geant4 364 // for these heavy hadrons, for two reasons: 302 // for these heavy hadrons, for two reasons: 365 // 1. For testing purposes, unless we pre-as 303 // 1. For testing purposes, unless we pre-assign decays of heavy hadrons 366 // (as the HEP experiments normally do by 304 // (as the HEP experiments normally do by using MC Event Generators); 367 // 2. To avoid crashes (due to missing decay 305 // 2. To avoid crashes (due to missing decay channels) whenever charmed or 368 // bottom secondary hadrons are produced 306 // bottom secondary hadrons are produced by Geant4 hadronic interactions, 369 // even with ordinary (i.e. not heavy) ha 307 // even with ordinary (i.e. not heavy) hadron projectiles, because in 370 // this case we cannot (easily!) pre-assi 308 // this case we cannot (easily!) pre-assign decays to them. 371 // Given that 1. is just a convenience for t 309 // Given that 1. is just a convenience for testing, and 2. happens rather 372 // rarely in practice - because very few pri 310 // rarely in practice - because very few primary energetic (i.e. boosted) 373 // heavy hadrons fly enough to reach the bea 311 // heavy hadrons fly enough to reach the beam pipe or the tracker and 374 // having an inelastic interaction there, an 312 // having an inelastic interaction there, and the very low probability 375 // to create a heavy hadrons from the string 313 // to create a heavy hadrons from the string fragmentation in ordinary 376 // (i.e. not heavy) hadronic interactions - 314 // (i.e. not heavy) hadronic interactions - there is no need in practice 377 // to define accurately the decays of heavy 315 // to define accurately the decays of heavy hadrons in Geant4. 378 // So, for our practical purposes, it is eno 316 // So, for our practical purposes, it is enough to define very simple, 379 // "dummy" decays of charmed and bottom hadr 317 // "dummy" decays of charmed and bottom hadrons. 380 // Here we use a single, fully hadronic chan 318 // Here we use a single, fully hadronic channel, with 2 or 3 or 4 381 // daughters, for each of these heavy hadron 319 // daughters, for each of these heavy hadrons, assigning to this single 382 // decay channel a 100% branching ratio, alt 320 // decay channel a 100% branching ratio, although in reality such a 383 // channel is one between hundreds of possib 321 // channel is one between hundreds of possible ones (and therefore its 384 // real branching ratio is typical of a few 322 // real branching ratio is typical of a few per-cent); moreover, we treat 385 // the decay without any dynamics, i.e. with 323 // the decay without any dynamics, i.e. with a flat phase space kinematical 386 // treatment. 324 // treatment. 387 // Note that some of the charmed and bottom 325 // Note that some of the charmed and bottom hadrons such as SigmaC++, 388 // SigmaC+, SigmaC0, SigmaB+, SigmaB0 and Si 326 // SigmaC+, SigmaC0, SigmaB+, SigmaB0 and SigmaB- have one dominant 389 // decay channel (to LambdaC/B + Pion) which 327 // decay channel (to LambdaC/B + Pion) which is already defined in Geant4. 390 // This is not the case for EtaC, JPsi and U 328 // This is not the case for EtaC, JPsi and Upsilon, whose decays need to 391 // be defined here (although they decay so q 329 // be defined here (although they decay so quickly that their hadronic 392 // interactions can be neglected, as we do f 330 // interactions can be neglected, as we do for Pi0 and Sigma0). 393 // Note that our definition of the decay tab 331 // Note that our definition of the decay tables for these heavy hadrons 394 // do not interfere with the pre-assign deca 332 // do not interfere with the pre-assign decays of primary charmed and 395 // bottom tracks made by the HEP experiments 333 // bottom tracks made by the HEP experiments. In fact, pre-assign decays 396 // have priority over (i.e. override) decay 334 // have priority over (i.e. override) decay tables. 397 static G4bool isFirstCall = true; 335 static G4bool isFirstCall = true; 398 if ( ! isFirstCall ) return; 336 if ( ! isFirstCall ) return; 399 isFirstCall = false; 337 isFirstCall = false; 400 G4ParticleTable* particleTable = G4ParticleT 338 G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable(); 401 for ( auto & pdg : G4HadParticles::GetBCHadr 339 for ( auto & pdg : G4HadParticles::GetBCHadrons() ) { 402 auto part = particleTable->FindParticle( p 340 auto part = particleTable->FindParticle( pdg ); 403 if ( part == nullptr ) { 341 if ( part == nullptr ) { 404 G4cout << "G4HadronicBuilder::BuildDecay 342 G4cout << "G4HadronicBuilder::BuildDecayTableForBCHadrons : ERROR ! particlePDG=" 405 << pdg << " is not defined !" << 343 << pdg << " is not defined !" << G4endl; 406 continue; 344 continue; 407 } 345 } 408 if ( part->GetDecayTable() ) { 346 if ( part->GetDecayTable() ) { 409 G4cout << "G4HadronicBuilder::BuildDecay 347 G4cout << "G4HadronicBuilder::BuildDecayTableForBCHadrons : WARNING ! particlePDG=" 410 << pdg << " has already a decay t 348 << pdg << " has already a decay table defined !" << G4endl; 411 continue; 349 continue; 412 } 350 } 413 G4DecayTable* decayTable = new G4DecayTabl 351 G4DecayTable* decayTable = new G4DecayTable; 414 const G4int numberDecayChannels = 1; 352 const G4int numberDecayChannels = 1; 415 G4VDecayChannel** mode = new G4VDecayChann 353 G4VDecayChannel** mode = new G4VDecayChannel*[ numberDecayChannels ]; 416 for ( G4int i = 0; i < numberDecayChannels << 417 switch ( pdg ) { 354 switch ( pdg ) { 418 // Charmed mesons 355 // Charmed mesons 419 case 411 : // D+ 356 case 411 : // D+ 420 mode[0] = new G4PhaseSpaceDecayChannel 357 mode[0] = new G4PhaseSpaceDecayChannel( "D+", 1.0, 3, "kaon-", "pi+", "pi+" ); 421 break; 358 break; 422 case -411 : // D- 359 case -411 : // D- 423 mode[0] = new G4PhaseSpaceDecayChannel 360 mode[0] = new G4PhaseSpaceDecayChannel( "D-", 1.0, 3, "kaon+", "pi-", "pi-" ); 424 break; 361 break; 425 case 421 : // D0 362 case 421 : // D0 426 mode[0] = new G4PhaseSpaceDecayChannel 363 mode[0] = new G4PhaseSpaceDecayChannel( "D0", 1.0, 3, "kaon-", "pi+", "pi0" ); 427 break; 364 break; 428 case -421 : // anti_D0 365 case -421 : // anti_D0 429 mode[0] = new G4PhaseSpaceDecayChannel 366 mode[0] = new G4PhaseSpaceDecayChannel( "anti_D0", 1.0, 3, "kaon+", "pi-", "pi0" ); 430 break; 367 break; 431 case 431 : // Ds+ 368 case 431 : // Ds+ 432 mode[0] = new G4PhaseSpaceDecayChannel 369 mode[0] = new G4PhaseSpaceDecayChannel( "Ds+", 1.0, 3, "kaon+", "kaon-", "pi+" ); 433 break; 370 break; 434 case -431 : // Ds- 371 case -431 : // Ds- 435 mode[0] = new G4PhaseSpaceDecayChannel 372 mode[0] = new G4PhaseSpaceDecayChannel( "Ds-", 1.0, 3, "kaon-", "kaon+", "pi-" ); 436 break; 373 break; 437 // Bottom mesons 374 // Bottom mesons 438 case 521 : // B+ 375 case 521 : // B+ 439 mode[0] = new G4PhaseSpaceDecayChannel 376 mode[0] = new G4PhaseSpaceDecayChannel( "B+", 1.0, 3, "anti_D0", "pi+", "pi0" ); 440 break; 377 break; 441 case -521 : // B- 378 case -521 : // B- 442 mode[0] = new G4PhaseSpaceDecayChannel 379 mode[0] = new G4PhaseSpaceDecayChannel( "B-", 1.0, 3, "D0", "pi-", "pi0" ); 443 break; 380 break; 444 case 511 : // B0 381 case 511 : // B0 445 mode[0] = new G4PhaseSpaceDecayChannel 382 mode[0] = new G4PhaseSpaceDecayChannel( "B0", 1.0, 3, "D-", "pi+", "pi0" ); 446 break; 383 break; 447 case -511 : // anti_B0 384 case -511 : // anti_B0 448 mode[0] = new G4PhaseSpaceDecayChannel 385 mode[0] = new G4PhaseSpaceDecayChannel( "anti_B0", 1.0, 3, "D+", "pi-", "pi0" ); 449 break; 386 break; 450 case 531 : // Bs0 387 case 531 : // Bs0 451 mode[0] = new G4PhaseSpaceDecayChannel 388 mode[0] = new G4PhaseSpaceDecayChannel( "Bs0", 1.0, 3, "Ds-", "pi+", "pi0" ); 452 break; 389 break; 453 case -531 : // anti_Bs0 390 case -531 : // anti_Bs0 454 mode[0] = new G4PhaseSpaceDecayChannel 391 mode[0] = new G4PhaseSpaceDecayChannel( "anti_Bs0", 1.0, 3, "Ds+", "pi-", "pi0" ); 455 break; 392 break; 456 case 541 : // Bc+ 393 case 541 : // Bc+ 457 mode[0] = new G4PhaseSpaceDecayChannel 394 mode[0] = new G4PhaseSpaceDecayChannel( "Bc+", 1.0, 2, "J/psi", "pi+" ); 458 break; 395 break; 459 case -541 : // Bc- 396 case -541 : // Bc- 460 mode[0] = new G4PhaseSpaceDecayChannel 397 mode[0] = new G4PhaseSpaceDecayChannel( "Bc-", 1.0, 2, "J/psi", "pi-" ); 461 break; 398 break; 462 // Charmed baryons (and anti-baryons) 399 // Charmed baryons (and anti-baryons) 463 case 4122 : // lambda_c+ 400 case 4122 : // lambda_c+ 464 mode[0] = new G4PhaseSpaceDecayChannel 401 mode[0] = new G4PhaseSpaceDecayChannel( "lambda_c+", 1.0, 3, "proton", "kaon-", "pi+" ); 465 break; 402 break; 466 case -4122 : // anti_lambda_c+ 403 case -4122 : // anti_lambda_c+ 467 mode[0] = new G4PhaseSpaceDecayChannel 404 mode[0] = new G4PhaseSpaceDecayChannel( "anti_lambda_c+", 1.0, 3, "anti_proton", "kaon+", "pi-" ); 468 break; 405 break; 469 case 4232 : // xi_c+ 406 case 4232 : // xi_c+ 470 mode[0] = new G4PhaseSpaceDecayChannel 407 mode[0] = new G4PhaseSpaceDecayChannel( "xi_c+", 1.0, 3, "sigma+", "kaon-", "pi+" ); 471 break; 408 break; 472 case -4232 : // anti_xi_c+ 409 case -4232 : // anti_xi_c+ 473 mode[0] = new G4PhaseSpaceDecayChannel 410 mode[0] = new G4PhaseSpaceDecayChannel( "anti_xi_c+", 1.0, 3, "anti_sigma+", "kaon+", "pi-" ); 474 break; 411 break; 475 case 4132 : // xi_c0 412 case 4132 : // xi_c0 476 mode[0] = new G4PhaseSpaceDecayChannel 413 mode[0] = new G4PhaseSpaceDecayChannel( "xi_c0", 1.0, 3, "lambda", "kaon-", "pi+" ); 477 break; 414 break; 478 case -4132 : // anti_xi_c0 415 case -4132 : // anti_xi_c0 479 mode[0] = new G4PhaseSpaceDecayChannel 416 mode[0] = new G4PhaseSpaceDecayChannel( "anti_xi_c0", 1.0, 3, "anti_lambda", "kaon+", "pi-" ); 480 break; 417 break; 481 case 4332 : // omega_c0 418 case 4332 : // omega_c0 482 mode[0] = new G4PhaseSpaceDecayChannel 419 mode[0] = new G4PhaseSpaceDecayChannel( "omega_c0", 1.0, 3, "xi0", "kaon-", "pi+" ); 483 break; 420 break; 484 case -4332 : // anti_omega_c0 421 case -4332 : // anti_omega_c0 485 mode[0] = new G4PhaseSpaceDecayChannel 422 mode[0] = new G4PhaseSpaceDecayChannel( "anti_omega_c0", 1.0, 3, "anti_xi0", "kaon+", "pi-" ); 486 break; 423 break; 487 // Bottom baryons (and anti-baryons) 424 // Bottom baryons (and anti-baryons) 488 case 5122 : // lambda_b 425 case 5122 : // lambda_b 489 mode[0] = new G4PhaseSpaceDecayChannel 426 mode[0] = new G4PhaseSpaceDecayChannel( "lambda_b", 1.0, 4, "lambda_c+", "pi+", "pi-", "pi-" ); 490 break; 427 break; 491 case -5122 : // anti_lambda_b 428 case -5122 : // anti_lambda_b 492 mode[0] = new G4PhaseSpaceDecayChannel 429 mode[0] = new G4PhaseSpaceDecayChannel( "anti_lambda_b", 1.0, 4, "anti_lambda_c+", "pi-", "pi+", "pi+" ); 493 break; 430 break; 494 case 5232 : // xi_b0 431 case 5232 : // xi_b0 495 mode[0] = new G4PhaseSpaceDecayChannel 432 mode[0] = new G4PhaseSpaceDecayChannel( "xi_b0", 1.0, 3, "lambda_c+", "kaon-", "pi0" ); 496 break; 433 break; 497 case -5232 : // anti_xi_b0 434 case -5232 : // anti_xi_b0 498 mode[0] = new G4PhaseSpaceDecayChannel 435 mode[0] = new G4PhaseSpaceDecayChannel( "anti_xi_b0", 1.0, 3, "anti_lambda_c+", "kaon+", "pi0" ); 499 break; 436 break; 500 case 5132 : // xi_b- 437 case 5132 : // xi_b- 501 mode[0] = new G4PhaseSpaceDecayChannel 438 mode[0] = new G4PhaseSpaceDecayChannel( "xi_b-", 1.0, 3, "lambda_c+", "kaon-", "pi-" ); 502 break; 439 break; 503 case -5132 : // anti_xi_b- 440 case -5132 : // anti_xi_b- 504 mode[0] = new G4PhaseSpaceDecayChannel 441 mode[0] = new G4PhaseSpaceDecayChannel( "anti_xi_b-", 1.0, 3, "anti_lambda_c+", "kaon+", "pi+" ); 505 break; 442 break; 506 case 5332 : // omega_b- 443 case 5332 : // omega_b- 507 mode[0] = new G4PhaseSpaceDecayChannel 444 mode[0] = new G4PhaseSpaceDecayChannel( "omega_b-", 1.0, 3, "xi_c+", "kaon-", "pi-" ); 508 break; 445 break; 509 case -5332 : // anti_omega_b- 446 case -5332 : // anti_omega_b- 510 mode[0] = new G4PhaseSpaceDecayChannel 447 mode[0] = new G4PhaseSpaceDecayChannel( "anti_omega_b-", 1.0, 3, "anti_xi_c+", "kaon+", "pi+" ); 511 break; 448 break; 512 default : 449 default : 513 G4cout << "G4HadronicBuilder::BuildDec 450 G4cout << "G4HadronicBuilder::BuildDecayTableForBCHadrons : UNKNOWN particlePDG=" << pdg << G4endl; 514 } // End of the switch 451 } // End of the switch 515 452 516 for ( G4int index = 0; index < numberDecay 453 for ( G4int index = 0; index < numberDecayChannels; ++index ) decayTable->Insert( mode[index] ); 517 delete [] mode; 454 delete [] mode; 518 part->SetDecayTable( decayTable ); 455 part->SetDecayTable( decayTable ); 519 } // End of the for loop over heavy hadrons 456 } // End of the for loop over heavy hadrons 520 // Add now the decay for etac, JPsi and Upsi 457 // Add now the decay for etac, JPsi and Upsilon because these can be produced as 521 // secondaries in hadronic interactions, whi 458 // secondaries in hadronic interactions, while they are not part of the heavy 522 // hadrons included in G4HadParticles::GetBC 459 // hadrons included in G4HadParticles::GetBCHadrons() because they live too shortly 523 // and therefore their hadronic interactions 460 // and therefore their hadronic interactions can be neglected (as we do for pi0 and sigma0). 524 if ( ! G4Etac::Definition()->GetDecayTable() 461 if ( ! G4Etac::Definition()->GetDecayTable() ) { 525 G4DecayTable* decayTable = new G4DecayTabl 462 G4DecayTable* decayTable = new G4DecayTable; 526 const G4int numberDecayChannels = 1; 463 const G4int numberDecayChannels = 1; 527 G4VDecayChannel** mode = new G4VDecayChann 464 G4VDecayChannel** mode = new G4VDecayChannel*[ numberDecayChannels ]; 528 for ( G4int i = 0; i < numberDecayChannels << 529 mode[0] = new G4PhaseSpaceDecayChannel( "e 465 mode[0] = new G4PhaseSpaceDecayChannel( "etac", 1.0, 3, "eta", "pi+", "pi-" ); 530 for ( G4int index = 0; index < numberDecay 466 for ( G4int index = 0; index < numberDecayChannels; ++index ) decayTable->Insert( mode[index] ); 531 delete [] mode; 467 delete [] mode; 532 G4Etac::Definition()->SetDecayTable( decay 468 G4Etac::Definition()->SetDecayTable( decayTable ); 533 } 469 } 534 if ( ! G4JPsi::Definition()->GetDecayTable() 470 if ( ! G4JPsi::Definition()->GetDecayTable() ) { 535 G4DecayTable* decayTable = new G4DecayTabl 471 G4DecayTable* decayTable = new G4DecayTable; 536 const G4int numberDecayChannels = 1; 472 const G4int numberDecayChannels = 1; 537 G4VDecayChannel** mode = new G4VDecayChann 473 G4VDecayChannel** mode = new G4VDecayChannel*[ numberDecayChannels ]; 538 for ( G4int i = 0; i < numberDecayChannels << 539 mode[0] = new G4PhaseSpaceDecayChannel( "J 474 mode[0] = new G4PhaseSpaceDecayChannel( "J/psi", 1.0, 3, "pi0", "pi+", "pi-" ); 540 for ( G4int index = 0; index < numberDecay 475 for ( G4int index = 0; index < numberDecayChannels; ++index ) decayTable->Insert( mode[index] ); 541 delete [] mode; 476 delete [] mode; 542 G4JPsi::Definition()->SetDecayTable( decay 477 G4JPsi::Definition()->SetDecayTable( decayTable ); 543 } 478 } 544 if ( ! G4Upsilon::Definition()->GetDecayTabl 479 if ( ! G4Upsilon::Definition()->GetDecayTable() ) { 545 G4DecayTable* decayTable = new G4DecayTabl 480 G4DecayTable* decayTable = new G4DecayTable; 546 const G4int numberDecayChannels = 1; 481 const G4int numberDecayChannels = 1; 547 G4VDecayChannel** mode = new G4VDecayChann 482 G4VDecayChannel** mode = new G4VDecayChannel*[ numberDecayChannels ]; 548 for ( G4int i = 0; i < numberDecayChannels << 549 mode[0] = new G4PhaseSpaceDecayChannel( "U 483 mode[0] = new G4PhaseSpaceDecayChannel( "Upsilon", 1.0, 3, "eta_prime", "pi+", "pi-" ); 550 for ( G4int index = 0; index < numberDecay 484 for ( G4int index = 0; index < numberDecayChannels; ++index ) decayTable->Insert( mode[index] ); 551 delete [] mode; 485 delete [] mode; 552 G4Upsilon::Definition()->SetDecayTable( de 486 G4Upsilon::Definition()->SetDecayTable( decayTable ); 553 } 487 } 554 } << 555 << 556 << 557 void G4HadronicBuilder::BuildHyperNucleiFTFP_B << 558 if ( G4HadronicParameters::Instance()->Enabl << 559 // Bertini intra-nuclear cascade model is << 560 // hypernuclei, therefore FTFP is used dow << 561 // very low energies, a dummy model is use << 562 // hypernucleus in the final state). << 563 BuildFTFP_BERT( G4HadParticles::GetHyperNu << 564 } << 565 } << 566 << 567 << 568 void G4HadronicBuilder::BuildHyperAntiNucleiFT << 569 if ( G4HadronicParameters::Instance()->Enabl << 570 // FTFP can be used down to zero kinetic e << 571 BuildFTFP_BERT( G4HadParticles::GetHyperAn << 572 } << 573 } << 574 << 575 << 576 void G4HadronicBuilder::BuildHyperNucleiFTFP_I << 577 if ( G4HadronicParameters::Instance()->Enabl << 578 BuildFTFP_INCLXX( G4HadParticles::GetHyper << 579 } << 580 } << 581 << 582 << 583 void G4HadronicBuilder::BuildFTFP_INCLXX( cons << 584 G4HadronicParameters* param = G4HadronicPara << 585 G4PhysicsListHelper* ph = G4PhysicsListHelpe << 586 auto theTheoFSModel = new G4TheoFSGenerator( << 587 auto theStringModel = new G4FTFModel; << 588 theStringModel->SetFragmentationModel( new G << 589 theTheoFSModel->SetHighEnergyGenerator( theS << 590 theTheoFSModel->SetTransport( new G4Generato << 591 theTheoFSModel->SetMaxEnergy( param->GetMaxE << 592 theTheoFSModel->SetMinEnergy( 15.0*CLHEP::Ge << 593 G4VPreCompoundModel* thePrecoModel = new G4P << 594 thePrecoModel->SetMinEnergy( 0.0 ); << 595 thePrecoModel->SetMaxEnergy( 2.0*CLHEP::MeV << 596 G4INCLXXInterface* theINCLXXModel = new G4IN << 597 theINCLXXModel->SetMinEnergy( 1.0*CLHEP::MeV << 598 theINCLXXModel->SetMaxEnergy( 20.0*CLHEP::Ge << 599 auto xsinel = G4HadProcesses::InelasticXS( x << 600 G4ParticleTable* table = G4ParticleTable::Ge << 601 for ( auto & pdg : partList ) { << 602 auto part = table->FindParticle( pdg ); << 603 if ( part == nullptr ) continue; << 604 auto hadi = new G4HadronInelasticProcess( << 605 hadi->AddDataSet( xsinel ); << 606 hadi->RegisterMe( theTheoFSModel ); << 607 hadi->RegisterMe( theINCLXXModel ); << 608 if ( param->ApplyFactorXS() ) hadi->Multip << 609 ph->RegisterProcess( hadi, part ); << 610 } << 611 } 488 } 612 489