Geant4 Cross Reference |
1 // 1 2 // ******************************************* 3 // * License and Disclaimer 4 // * 5 // * The Geant4 software is copyright of th 6 // * the Geant4 Collaboration. It is provided 7 // * conditions of the Geant4 Software License 8 // * LICENSE and available at http://cern.ch/ 9 // * include a list of copyright holders. 10 // * 11 // * Neither the authors of this software syst 12 // * institutes,nor the agencies providing fin 13 // * work make any representation or warran 14 // * regarding this software system or assum 15 // * use. Please see the license in the file 16 // * for the full disclaimer and the limitatio 17 // * 18 // * This code implementation is the result 19 // * technical work of the GEANT4 collaboratio 20 // * By using, copying, modifying or distri 21 // * any work based on the software) you ag 22 // * use in resulting scientific publicati 23 // * acceptance of all terms of the Geant4 Sof 24 // ******************************************* 25 // 26 // 27 // Geant4 class G4HadronicBuilder 28 // 29 // Author V.Ivanchenko 14.05.2020 30 // 31 32 #include "G4HadronicBuilder.hh" 33 #include "G4HadParticles.hh" 34 #include "G4HadProcesses.hh" 35 36 #include "G4ParticleDefinition.hh" 37 #include "G4ParticleTable.hh" 38 #include "G4PhysicsListHelper.hh" 39 #include "G4SystemOfUnits.hh" 40 41 #include "G4HadronicParameters.hh" 42 43 #include "G4TheoFSGenerator.hh" 44 #include "G4FTFModel.hh" 45 #include "G4ExcitedStringDecay.hh" 46 #include "G4GeneratorPrecompoundInterface.hh" 47 48 #include "G4QGSModel.hh" 49 #include "G4QGSParticipants.hh" 50 #include "G4QGSMFragmentation.hh" 51 #include "G4QuasiElasticChannel.hh" 52 53 #include "G4CascadeInterface.hh" 54 #include "G4CrossSectionDataSetRegistry.hh" 55 #include "G4CrossSectionInelastic.hh" 56 #include "G4CrossSectionElastic.hh" 57 #include "G4HadronElastic.hh" 58 #include "G4CrossSectionDataSetRegistry.hh" 59 60 #include "G4HadronElasticProcess.hh" 61 #include "G4HadronInelasticProcess.hh" 62 63 #include "G4DecayTable.hh" 64 #include "G4VDecayChannel.hh" 65 #include "G4PhaseSpaceDecayChannel.hh" 66 67 #include "G4PreCompoundModel.hh" 68 #include "G4INCLXXInterface.hh" 69 #include "G4ComponentAntiNuclNuclearXS.hh" 70 71 72 73 void G4HadronicBuilder::BuildFTFP_BERT(const s 74 G4bool 75 76 G4HadronicParameters* param = G4HadronicPara 77 G4PhysicsListHelper* ph = G4PhysicsListHelpe 78 79 auto theModel = new G4TheoFSGenerator("FTFP" 80 auto theStringModel = new G4FTFModel(); 81 theStringModel->SetFragmentationModel(new G4 82 theModel->SetHighEnergyGenerator( theStringM 83 theModel->SetTransport( new G4GeneratorPreco 84 theModel->SetMaxEnergy( param->GetMaxEnergy( 85 86 G4CascadeInterface* theCascade = nullptr; 87 if(bert) { 88 theCascade = new G4CascadeInterface(); 89 theCascade->SetMaxEnergy( param->GetMaxEne 90 theModel->SetMinEnergy( param->GetMinEnerg 91 } 92 93 auto xsinel = G4HadProcesses::InelasticXS( x 94 95 G4ParticleTable* table = G4ParticleTable::Ge 96 for( auto & pdg : partList ) { 97 98 auto part = table->FindParticle( pdg ); 99 if ( part == nullptr ) { continue; } 100 101 auto hadi = new G4HadronInelasticProcess( 102 hadi->AddDataSet( xsinel ); 103 hadi->RegisterMe( theModel ); 104 if( theCascade != nullptr ) hadi->Register 105 if( param->ApplyFactorXS() ) hadi->Multipl 106 ph->RegisterProcess(hadi, part); 107 } 108 } 109 110 void G4HadronicBuilder::BuildFTFQGSP_BERT(cons 111 G4bo 112 113 G4HadronicParameters* param = G4HadronicPara 114 G4PhysicsListHelper* ph = G4PhysicsListHelpe 115 116 auto theModel = new G4TheoFSGenerator("FTFQG 117 auto theStringModel = new G4FTFModel(); 118 theStringModel->SetFragmentationModel(new G4 119 theModel->SetHighEnergyGenerator( theStringM 120 theModel->SetTransport( new G4GeneratorPreco 121 theModel->SetMaxEnergy( param->GetMaxEnergy( 122 123 G4CascadeInterface* theCascade = nullptr; 124 if(bert) { 125 theCascade = new G4CascadeInterface(); 126 theCascade->SetMaxEnergy( param->GetMaxEne 127 theModel->SetMinEnergy( param->GetMinEnerg 128 } 129 130 auto xsinel = G4HadProcesses::InelasticXS( x 131 132 G4ParticleTable* table = G4ParticleTable::Ge 133 for( auto & pdg : partList ) { 134 135 auto part = table->FindParticle( pdg ); 136 if ( part == nullptr ) { continue; } 137 138 auto hadi = new G4HadronInelasticProcess( 139 hadi->AddDataSet( xsinel ); 140 hadi->RegisterMe( theModel ); 141 if( theCascade != nullptr ) hadi->Register 142 if( param->ApplyFactorXS() ) hadi->Multipl 143 ph->RegisterProcess(hadi, part); 144 } 145 } 146 147 void G4HadronicBuilder::BuildQGSP_FTFP_BERT(co 148 G4 149 co 150 151 G4HadronicParameters* param = G4HadronicPara 152 G4PhysicsListHelper* ph = G4PhysicsListHelpe 153 154 auto theTransport = new G4GeneratorPrecompou 155 156 auto theHEModel = new G4TheoFSGenerator("QGS 157 G4QGSModel< G4QGSParticipants >* theQGSModel 158 theQGSModel->SetFragmentationModel( new G4Ex 159 theHEModel->SetTransport( theTransport ); 160 theHEModel->SetHighEnergyGenerator( theQGSMo 161 if (quasiElastic) { 162 theHEModel->SetQuasiElasticChannel(new G4Q 163 } 164 theHEModel->SetMinEnergy( param->GetMinEnerg 165 theHEModel->SetMaxEnergy( param->GetMaxEnerg 166 167 auto theLEModel = new G4TheoFSGenerator("FTF 168 auto theFTFModel = new G4FTFModel(); 169 theFTFModel->SetFragmentationModel(new G4Exc 170 theLEModel->SetHighEnergyGenerator( theFTFMo 171 theLEModel->SetTransport( theTransport ); 172 theLEModel->SetMaxEnergy( param->GetMaxEnerg 173 174 G4CascadeInterface* theCascade = nullptr; 175 if(bert) { 176 theCascade = new G4CascadeInterface(); 177 theCascade->SetMaxEnergy( param->GetMaxEne 178 theLEModel->SetMinEnergy( param->GetMinEne 179 } 180 181 auto xsinel = G4HadProcesses::InelasticXS( x 182 183 G4ParticleTable* table = G4ParticleTable::Ge 184 for( auto & pdg : partList ) { 185 186 auto part = table->FindParticle( pdg ); 187 if ( part == nullptr ) { continue; } 188 189 auto hadi = new G4HadronInelasticProcess( 190 hadi->AddDataSet( xsinel ); 191 hadi->RegisterMe( theHEModel ); 192 hadi->RegisterMe( theLEModel ); 193 if(theCascade != nullptr) hadi->RegisterMe 194 if( param->ApplyFactorXS() ) hadi->Multipl 195 ph->RegisterProcess(hadi, part); 196 } 197 } 198 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 251 252 G4HadronicParameters* param = G4HadronicPara 253 G4PhysicsListHelper* ph = G4PhysicsListHelpe 254 255 auto xsel = G4HadProcesses::ElasticXS("Glaub 256 257 auto elModel = new G4HadronElastic(); 258 elModel->SetMaxEnergy( param->GetMaxEnergy() 259 260 G4ParticleTable* table = G4ParticleTable::Ge 261 for( auto & pdg : partList ) { 262 263 auto part = table->FindParticle( pdg ); 264 if ( part == nullptr ) { continue; } 265 266 auto hade = new G4HadronElasticProcess(); 267 hade->AddDataSet( xsel ); 268 hade->RegisterMe( elModel ); 269 if( param->ApplyFactorXS() ) hade->Multipl 270 ph->RegisterProcess(hade, part); 271 } 272 } 273 274 void G4HadronicBuilder::BuildHyperonsFTFP_BERT 275 // For hyperons, Bertini is used at low ener 276 // for anti-hyperons, FTFP can be used down 277 BuildFTFP_BERT(G4HadParticles::GetHyperons() 278 BuildFTFP_BERT(G4HadParticles::GetAntiHypero 279 } 280 281 void G4HadronicBuilder::BuildHyperonsFTFQGSP_B 282 // For hyperons, Bertini is used at low ener 283 // for anti-hyperons, FTFP can be used down 284 BuildFTFQGSP_BERT(G4HadParticles::GetHyperon 285 BuildFTFQGSP_BERT(G4HadParticles::GetAntiHyp 286 } 287 288 void G4HadronicBuilder::BuildHyperonsQGSP_FTFP 289 // For hyperons, Bertini is used at low ener 290 // for anti-hyperons, FTFP can be used down 291 // QGSP is used at high energies in all case 292 BuildQGSP_FTFP_BERT(G4HadParticles::GetHyper 293 BuildQGSP_FTFP_BERT(G4HadParticles::GetAntiH 294 } 295 296 void G4HadronicBuilder::BuildKaonsFTFP_BERT() 297 BuildFTFP_BERT(G4HadParticles::GetKaons(), t 298 } 299 300 void G4HadronicBuilder::BuildKaonsFTFQGSP_BERT 301 BuildFTFQGSP_BERT(G4HadParticles::GetKaons() 302 } 303 304 void G4HadronicBuilder::BuildKaonsQGSP_FTFP_BE 305 BuildQGSP_FTFP_BERT(G4HadParticles::GetKaons 306 } 307 308 void G4HadronicBuilder::BuildAntiLightIonsFTFP 309 BuildFTFP_BERT(G4HadParticles::GetLightAntiI 310 } 311 312 //void G4HadronicBuilder::BuildAntiLightIonsQG 313 // Note: currently QGSP cannot be applied for 314 // BuildQGSP_FTFP_BERT(G4HadParticles::GetLig 315 //} 316 317 void G4HadronicBuilder::BuildAntiLightIonsINCL 318 BuildINCLXX(G4HadParticles::GetLightAntiIons 319 } 320 321 void G4HadronicBuilder::BuildBCHadronsFTFP_BER 322 if( G4HadronicParameters::Instance()->Enable 323 // Bertini is not applicable for charm and 324 // down to zero kinetic energy (but at ver 325 // that returns the projectile heavy hadro 326 BuildFTFP_BERT(G4HadParticles::GetBCHadron 327 BuildDecayTableForBCHadrons(); 328 } 329 } 330 331 void G4HadronicBuilder::BuildBCHadronsFTFQGSP_ 332 if( G4HadronicParameters::Instance()->Enable 333 // Bertini is not applicable for charm and 334 // down to zero kinetic energy (but at ver 335 // that returns the projectile heavy hadro 336 BuildFTFQGSP_BERT(G4HadParticles::GetBCHad 337 BuildDecayTableForBCHadrons(); 338 } 339 } 340 341 void G4HadronicBuilder::BuildBCHadronsQGSP_FTF 342 if( G4HadronicParameters::Instance()->Enable 343 // Bertini is not applicable for charm and 344 // down to zero kinetic energy (but at ver 345 // that returns the projectile heavy hadro 346 // QGSP is used at high energies in all ca 347 BuildQGSP_FTFP_BERT(G4HadParticles::GetBCH 348 BuildDecayTableForBCHadrons(); 349 } 350 } 351 352 void G4HadronicBuilder::BuildDecayTableForBCHa 353 // Geant4 does not define the decay of most 354 // The reason is that most of these heavy ha 355 // decay channels, with a complex dynamics, 356 // phase space kinematical treatment used in 357 // High-energy experiments usually use dedic 358 // for the decays of charmed and bottom hadr 359 // hadrons, which are passed to Geant4 as pr 360 // decays. Moreover, no charmed or bottom se 361 // in Geant4 hadronic interactions before Ge 362 // With the extension of Geant4 hadronic int 363 // hadrons, in version Geant4 10.7, we do ne 364 // for these heavy hadrons, for two reasons: 365 // 1. For testing purposes, unless we pre-as 366 // (as the HEP experiments normally do by 367 // 2. To avoid crashes (due to missing decay 368 // bottom secondary hadrons are produced 369 // even with ordinary (i.e. not heavy) ha 370 // this case we cannot (easily!) pre-assi 371 // Given that 1. is just a convenience for t 372 // rarely in practice - because very few pri 373 // heavy hadrons fly enough to reach the bea 374 // having an inelastic interaction there, an 375 // to create a heavy hadrons from the string 376 // (i.e. not heavy) hadronic interactions - 377 // to define accurately the decays of heavy 378 // So, for our practical purposes, it is eno 379 // "dummy" decays of charmed and bottom hadr 380 // Here we use a single, fully hadronic chan 381 // daughters, for each of these heavy hadron 382 // decay channel a 100% branching ratio, alt 383 // channel is one between hundreds of possib 384 // real branching ratio is typical of a few 385 // the decay without any dynamics, i.e. with 386 // treatment. 387 // Note that some of the charmed and bottom 388 // SigmaC+, SigmaC0, SigmaB+, SigmaB0 and Si 389 // decay channel (to LambdaC/B + Pion) which 390 // This is not the case for EtaC, JPsi and U 391 // be defined here (although they decay so q 392 // interactions can be neglected, as we do f 393 // Note that our definition of the decay tab 394 // do not interfere with the pre-assign deca 395 // bottom tracks made by the HEP experiments 396 // have priority over (i.e. override) decay 397 static G4bool isFirstCall = true; 398 if ( ! isFirstCall ) return; 399 isFirstCall = false; 400 G4ParticleTable* particleTable = G4ParticleT 401 for ( auto & pdg : G4HadParticles::GetBCHadr 402 auto part = particleTable->FindParticle( p 403 if ( part == nullptr ) { 404 G4cout << "G4HadronicBuilder::BuildDecay 405 << pdg << " is not defined !" << 406 continue; 407 } 408 if ( part->GetDecayTable() ) { 409 G4cout << "G4HadronicBuilder::BuildDecay 410 << pdg << " has already a decay t 411 continue; 412 } 413 G4DecayTable* decayTable = new G4DecayTabl 414 const G4int numberDecayChannels = 1; 415 G4VDecayChannel** mode = new G4VDecayChann 416 for ( G4int i = 0; i < numberDecayChannels 417 switch ( pdg ) { 418 // Charmed mesons 419 case 411 : // D+ 420 mode[0] = new G4PhaseSpaceDecayChannel 421 break; 422 case -411 : // D- 423 mode[0] = new G4PhaseSpaceDecayChannel 424 break; 425 case 421 : // D0 426 mode[0] = new G4PhaseSpaceDecayChannel 427 break; 428 case -421 : // anti_D0 429 mode[0] = new G4PhaseSpaceDecayChannel 430 break; 431 case 431 : // Ds+ 432 mode[0] = new G4PhaseSpaceDecayChannel 433 break; 434 case -431 : // Ds- 435 mode[0] = new G4PhaseSpaceDecayChannel 436 break; 437 // Bottom mesons 438 case 521 : // B+ 439 mode[0] = new G4PhaseSpaceDecayChannel 440 break; 441 case -521 : // B- 442 mode[0] = new G4PhaseSpaceDecayChannel 443 break; 444 case 511 : // B0 445 mode[0] = new G4PhaseSpaceDecayChannel 446 break; 447 case -511 : // anti_B0 448 mode[0] = new G4PhaseSpaceDecayChannel 449 break; 450 case 531 : // Bs0 451 mode[0] = new G4PhaseSpaceDecayChannel 452 break; 453 case -531 : // anti_Bs0 454 mode[0] = new G4PhaseSpaceDecayChannel 455 break; 456 case 541 : // Bc+ 457 mode[0] = new G4PhaseSpaceDecayChannel 458 break; 459 case -541 : // Bc- 460 mode[0] = new G4PhaseSpaceDecayChannel 461 break; 462 // Charmed baryons (and anti-baryons) 463 case 4122 : // lambda_c+ 464 mode[0] = new G4PhaseSpaceDecayChannel 465 break; 466 case -4122 : // anti_lambda_c+ 467 mode[0] = new G4PhaseSpaceDecayChannel 468 break; 469 case 4232 : // xi_c+ 470 mode[0] = new G4PhaseSpaceDecayChannel 471 break; 472 case -4232 : // anti_xi_c+ 473 mode[0] = new G4PhaseSpaceDecayChannel 474 break; 475 case 4132 : // xi_c0 476 mode[0] = new G4PhaseSpaceDecayChannel 477 break; 478 case -4132 : // anti_xi_c0 479 mode[0] = new G4PhaseSpaceDecayChannel 480 break; 481 case 4332 : // omega_c0 482 mode[0] = new G4PhaseSpaceDecayChannel 483 break; 484 case -4332 : // anti_omega_c0 485 mode[0] = new G4PhaseSpaceDecayChannel 486 break; 487 // Bottom baryons (and anti-baryons) 488 case 5122 : // lambda_b 489 mode[0] = new G4PhaseSpaceDecayChannel 490 break; 491 case -5122 : // anti_lambda_b 492 mode[0] = new G4PhaseSpaceDecayChannel 493 break; 494 case 5232 : // xi_b0 495 mode[0] = new G4PhaseSpaceDecayChannel 496 break; 497 case -5232 : // anti_xi_b0 498 mode[0] = new G4PhaseSpaceDecayChannel 499 break; 500 case 5132 : // xi_b- 501 mode[0] = new G4PhaseSpaceDecayChannel 502 break; 503 case -5132 : // anti_xi_b- 504 mode[0] = new G4PhaseSpaceDecayChannel 505 break; 506 case 5332 : // omega_b- 507 mode[0] = new G4PhaseSpaceDecayChannel 508 break; 509 case -5332 : // anti_omega_b- 510 mode[0] = new G4PhaseSpaceDecayChannel 511 break; 512 default : 513 G4cout << "G4HadronicBuilder::BuildDec 514 } // End of the switch 515 516 for ( G4int index = 0; index < numberDecay 517 delete [] mode; 518 part->SetDecayTable( decayTable ); 519 } // End of the for loop over heavy hadrons 520 // Add now the decay for etac, JPsi and Upsi 521 // secondaries in hadronic interactions, whi 522 // hadrons included in G4HadParticles::GetBC 523 // and therefore their hadronic interactions 524 if ( ! G4Etac::Definition()->GetDecayTable() 525 G4DecayTable* decayTable = new G4DecayTabl 526 const G4int numberDecayChannels = 1; 527 G4VDecayChannel** mode = new G4VDecayChann 528 for ( G4int i = 0; i < numberDecayChannels 529 mode[0] = new G4PhaseSpaceDecayChannel( "e 530 for ( G4int index = 0; index < numberDecay 531 delete [] mode; 532 G4Etac::Definition()->SetDecayTable( decay 533 } 534 if ( ! G4JPsi::Definition()->GetDecayTable() 535 G4DecayTable* decayTable = new G4DecayTabl 536 const G4int numberDecayChannels = 1; 537 G4VDecayChannel** mode = new G4VDecayChann 538 for ( G4int i = 0; i < numberDecayChannels 539 mode[0] = new G4PhaseSpaceDecayChannel( "J 540 for ( G4int index = 0; index < numberDecay 541 delete [] mode; 542 G4JPsi::Definition()->SetDecayTable( decay 543 } 544 if ( ! G4Upsilon::Definition()->GetDecayTabl 545 G4DecayTable* decayTable = new G4DecayTabl 546 const G4int numberDecayChannels = 1; 547 G4VDecayChannel** mode = new G4VDecayChann 548 for ( G4int i = 0; i < numberDecayChannels 549 mode[0] = new G4PhaseSpaceDecayChannel( "U 550 for ( G4int index = 0; index < numberDecay 551 delete [] mode; 552 G4Upsilon::Definition()->SetDecayTable( de 553 } 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 } 612