// // ******************************************************************** // * License and Disclaimer * // * * // * The Geant4 software is copyright of the Copyright Holders of * // * the Geant4 Collaboration. It is provided under the terms and * // * conditions of the Geant4 Software License, included in the file * // * LICENSE and available at http://cern.ch/geant4/license . These * // * include a list of copyright holders. * // * * // * Neither the authors of this software system, nor their employing * // * institutes,nor the agencies providing financial support for this * // * work make any representation or warranty, express or implied, * // * regarding this software system or assume any liability for its * // * use. Please see the license in the file LICENSE and URL above * // * for the full disclaimer and the limitation of liability. * // * * // * This code implementation is the result of the scientific and * // * technical work of the GEANT4 collaboration. * // * By using, copying, modifying or distributing the software (or * // * any work based on the software) you agree to acknowledge its * // * use in resulting scientific publications, and indicate your * // * acceptance of all terms of the Geant4 Software license. * // ******************************************************************** // // ************************************** // * * // * RemSimHadronicBertini.cc * // * * // ************************************** // // $Id: RemSimHadronicBertini.cc,v 1.4 2006/06/29 16:23:47 gunter Exp $ // GEANT4 tag $Name: $ // // Author : Susanna Guatelli, guatelli@ge.infn.it // #include "RemSimHadronicBertini.hh" #include "G4BinaryLightIonReaction.hh" #include "G4TripathiCrossSection.hh" #include "G4IonsShenCrossSection.hh" #include "G4ParticleDefinition.hh" #include "G4ProcessManager.hh" #include "G4ProcessVector.hh" #include "G4ParticleTypes.hh" #include "G4ParticleTable.hh" #include "G4Material.hh" #include "G4ios.hh" #include "G4ProtonInelasticCrossSection.hh" #include "G4NeutronInelasticCrossSection.hh" #include "G4PiNuclearCrossSection.hh" #include "G4LElastic.hh" #include "G4CascadeInterface.hh" #include "G4LEProtonInelastic.hh" #include "G4LENeutronInelastic.hh" #include "G4LEPionPlusInelastic.hh" #include "G4LEPionMinusInelastic.hh" #include "G4LEAlphaInelastic.hh" #include "G4LFission.hh" #include "G4LCapture.hh" #include "G4TheoFSGenerator.hh" #include "G4GeneratorPrecompoundInterface.hh" #include "G4ExcitationHandler.hh" #include "G4PreCompoundModel.hh" #include "G4QGSMFragmentation.hh" #include "G4ExcitedStringDecay.hh" RemSimHadronicBertini::RemSimHadronicBertini(const G4String& name): G4VPhysicsConstructor(name) { // Hadronic cross sections for proton, neutrons and pions protonCrossSection = new G4ProtonInelasticCrossSection(); neutronCrossSection = new G4NeutronInelasticCrossSection(); pionCrossSection = new G4PiNuclearCrossSection(); // Hadronic cross sections for alpha particles tripathi = new G4TripathiCrossSection(); shen = new G4IonsShenCrossSection(); // Hadronic models // Elastic scattering model elasticModel = new G4LElastic(); // Inelastic scattering model for protons, pions and neutrons: // Bertini model bertiniModel = new G4CascadeInterface(); // LEP LEPProtonModel = new G4LEProtonInelastic(); LEPNeutronModel = new G4LENeutronInelastic(); LEPPionPlusModel = new G4LEPionPlusInelastic(); LEPPionMinusModel = new G4LEPionMinusInelastic(); LEPAlphaModel = new G4LEAlphaInelastic(); // High energy model for inelastic scattering of protons, pions // and neutrons QGSPModel = new G4TheoFSGenerator(); theCascade = new G4GeneratorPrecompoundInterface(); thePreEquilib = new G4PreCompoundModel(&theHandler); theCascade -> SetDeExcitation(thePreEquilib); QGSPModel -> SetTransport(theCascade); theFragmentation = new G4QGSMFragmentation(); theStringDecay = new G4ExcitedStringDecay(theFragmentation); theStringModel.SetFragmentationModel(theStringDecay); QGSPModel -> SetHighEnergyGenerator(&theStringModel); // Inelastic scattering model for alpha particles: BinaryIon model binaryIonModel = new G4BinaryLightIonReaction(); fissionModel = new G4LFission(); captureModel = new G4LCapture(); } RemSimHadronicBertini::~RemSimHadronicBertini() {} #include "G4HadronElasticProcess.hh" #include "G4HadronFissionProcess.hh" #include "G4HadronCaptureProcess.hh" #include "G4ProtonInelasticProcess.hh" #include "G4NeutronInelasticProcess.hh" #include "G4PionPlusInelasticProcess.hh" #include "G4PionMinusInelasticProcess.hh" #include "G4AlphaInelasticProcess.hh" void RemSimHadronicBertini::ConstructProcess() { // Set model energy regions // 0 - 3.2 GeV: Bertini cascade model for p, n, pi+, pi- G4double bertiniHighEnergyLimit = 3.2 * GeV; bertiniModel -> SetMaxEnergy(bertiniHighEnergyLimit); // 2.8 GeV - 25 GeV: LEP for p, n, pi+, pi- G4double LEPLowEnergyLimit = 2.8 * GeV; G4double LEPHighEnergyLimit = 25. * GeV; LEPProtonModel -> SetMinEnergy(LEPLowEnergyLimit); LEPProtonModel -> SetMaxEnergy(LEPHighEnergyLimit); LEPNeutronModel -> SetMinEnergy(LEPLowEnergyLimit); LEPNeutronModel -> SetMaxEnergy(LEPHighEnergyLimit); LEPPionPlusModel -> SetMinEnergy(LEPLowEnergyLimit); LEPPionPlusModel -> SetMaxEnergy(LEPHighEnergyLimit); LEPPionMinusModel -> SetMinEnergy(LEPLowEnergyLimit); LEPPionMinusModel -> SetMaxEnergy(LEPHighEnergyLimit); // 20 GeV - 100 TeV: QGSP model for p, n, pi+, pi- G4double QGSPLowEnergyLimit = 20.* GeV; G4double QGSPHighEnergyLimit = 100.* GeV; QGSPModel -> SetMinEnergy(QGSPLowEnergyLimit); QGSPModel -> SetMaxEnergy(QGSPHighEnergyLimit); // Energy limits for fission and neutron capture G4double lowLimit = 0. * TeV; G4double highLimit = 100 * TeV; fissionModel -> SetMinEnergy(lowLimit); fissionModel -> SetMaxEnergy(highLimit); captureModel -> SetMinEnergy(lowLimit); captureModel -> SetMaxEnergy(highLimit); // LEP model, up to 100 MeV for alpha particles G4double LEPAlphaHighLimit = 100* MeV; LEPAlphaModel -> SetMaxEnergy(LEPAlphaHighLimit); // 80 MeV - 400 GeV: binary ion model for alpha particles G4double binaryIonLowLimit = 80. * MeV; G4double binaryIonHighLimit = 400. * MeV; binaryIonModel -> SetMinEnergy(binaryIonLowLimit); binaryIonModel -> SetMaxEnergy(binaryIonHighLimit); // ****************************************** // * register models, processes to proton * // ****************************************** G4ParticleDefinition* proton = G4Proton::ProtonDefinition(); G4ProcessManager* protonProcessManager = proton -> GetProcessManager(); // Elastic process G4HadronElasticProcess* protonElasticProcess = new G4HadronElasticProcess(); protonElasticProcess -> RegisterMe(elasticModel); // Activate elastic scattering protonProcessManager -> AddDiscreteProcess(protonElasticProcess); // Inelastic process G4ProtonInelasticProcess* protonInelasticProcess = new G4ProtonInelasticProcess(); // Set the cross section protonInelasticProcess -> AddDataSet(protonCrossSection); // Set the models protonInelasticProcess -> RegisterMe(bertiniModel); protonInelasticProcess -> RegisterMe(LEPProtonModel); protonInelasticProcess -> RegisterMe(QGSPModel); // Activate inelastic scattering protonProcessManager -> AddDiscreteProcess(protonInelasticProcess); // ****************************************** // * register models, processes to neutron * // ****************************************** G4ParticleDefinition* neutron = G4Neutron::NeutronDefinition(); G4ProcessManager* neutronProcessManager = neutron->GetProcessManager(); // Elastic process G4HadronElasticProcess* neutronElasticProcess = new G4HadronElasticProcess(); neutronElasticProcess -> RegisterMe(elasticModel); // Activate the elastic scattering neutronProcessManager -> AddDiscreteProcess(neutronElasticProcess); // Inelastic process G4NeutronInelasticProcess* neutronInelasticProcess = new G4NeutronInelasticProcess(); // Set the cross section neutronInelasticProcess -> AddDataSet(neutronCrossSection); // Set the models neutronInelasticProcess -> RegisterMe(bertiniModel); neutronInelasticProcess -> RegisterMe(LEPNeutronModel); neutronInelasticProcess -> RegisterMe(QGSPModel); // Activate the inelastic scattering neutronProcessManager -> AddDiscreteProcess(neutronInelasticProcess); G4HadronCaptureProcess* neutronCapture = new G4HadronCaptureProcess(); neutronCapture -> RegisterMe(captureModel); neutronProcessManager -> AddDiscreteProcess(neutronCapture); G4HadronFissionProcess* neutronFission = new G4HadronFissionProcess(); neutronFission -> RegisterMe(fissionModel); neutronProcessManager -> AddDiscreteProcess(neutronFission); // ****************************************** // * register models, processes to pi+ * // ****************************************** G4ParticleDefinition* piplus = G4PionPlus::PionPlusDefinition(); G4ProcessManager* pionPlusProcessManager = piplus -> GetProcessManager(); // Elastic process G4HadronElasticProcess* pionPlusElasticProcess = new G4HadronElasticProcess(); pionPlusElasticProcess -> RegisterMe(elasticModel); pionPlusProcessManager -> AddDiscreteProcess(pionPlusElasticProcess); // Inelastic process G4PionPlusInelasticProcess* pionPlusInelasticProcess = new G4PionPlusInelasticProcess(); // Set the cross section pionPlusElasticProcess -> AddDataSet(pionCrossSection); // Set the models pionPlusElasticProcess -> RegisterMe(bertiniModel); pionPlusElasticProcess -> RegisterMe(LEPPionPlusModel); pionPlusElasticProcess -> RegisterMe(QGSPModel); // Activate the inelastic scattering pionPlusProcessManager -> AddDiscreteProcess(pionPlusInelasticProcess); // ****************************************** // * register models, processes to pi- * // ****************************************** G4ParticleDefinition* piminus = G4PionMinus::PionMinusDefinition(); G4ProcessManager* pionMinusProcessManager = piminus -> GetProcessManager(); // Elastic process G4HadronElasticProcess* pionMinusElasticProcess = new G4HadronElasticProcess(); pionMinusElasticProcess -> RegisterMe(elasticModel); // Activate the elastic process pionMinusProcessManager -> AddDiscreteProcess(pionMinusElasticProcess); // Inelastic process G4PionMinusInelasticProcess* pionMinusInelasticProcess = new G4PionMinusInelasticProcess(); pionMinusInelasticProcess -> AddDataSet(pionCrossSection); pionMinusInelasticProcess -> RegisterMe(bertiniModel); pionMinusInelasticProcess -> RegisterMe(LEPPionMinusModel); pionMinusInelasticProcess -> RegisterMe(QGSPModel); pionMinusProcessManager -> AddDiscreteProcess(pionMinusInelasticProcess); // ****************************************** // * register models, processes to alpha * // ****************************************** G4ParticleDefinition* alpha = G4Alpha::AlphaDefinition(); G4ProcessManager* alphaProcessManager = alpha -> GetProcessManager(); // Elastic process G4HadronElasticProcess* alphaElasticProcess = new G4HadronElasticProcess(); alphaElasticProcess -> RegisterMe(elasticModel); // Activate the elastic scattering alphaProcessManager -> AddDiscreteProcess(alphaElasticProcess); // Inelastic process G4AlphaInelasticProcess* alphaInelasticProcess = new G4AlphaInelasticProcess(); // Set the cross sections alphaInelasticProcess -> AddDataSet(tripathi); alphaInelasticProcess -> AddDataSet(shen); // Set the models alphaInelasticProcess -> RegisterMe(LEPAlphaModel); alphaInelasticProcess -> RegisterMe(binaryIonModel); // Activate the inelastic scattering alphaProcessManager -> AddDiscreteProcess(alphaInelasticProcess); }