/search.css" rel="stylesheet" type="text/css"/> /search.js">
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

In This Package:

Public Member Functions | Private Attributes
DsPhysConsHadron Class Reference

Hadron production physics. More...

#include <DsPhysConsHadron.h>

Collaboration diagram for DsPhysConsHadron:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 DsPhysConsHadron (const std::string &type, const std::string &name, const IInterface *parent)
virtual ~DsPhysConsHadron ()
void ConstructParticle ()
void ConstructProcess ()

Private Attributes

double m_minEnergyForMultiFrag
 MinEnergyForMultiFrag: Minimum energy for multi-fragmentation.
double m_maxEnergyPreEquilProton
 MaxEnergyPreEquilProton: Maximum energy for pre-equilibrium proton.
double m_minEnergyPreEquilNeutron
 MinEnergyPreEquilNeutron: Minimum energy for pre-equilibrium neutron.
double m_maxEnergyPreEquilNeutron
 MaxEnergyPreEquilNeutron: Maximum energy for pre-equilibrium neutron.
double m_minEnergyHEModel
 MinEnergyHEModel: Minimum energy for high-energy mode.
double m_maxEnergyHEModel
 MaxEnergyHEModel: Maximum energy for high-energy mode.
double m_lepUpperLimit
 LEPUpperLimit: Low-energy parametrized model upper limit.
double m_lepPnpiLimit
 LEPpnpiLimit: Low-energy parametrized model pnpi limit.
double m_minEnergyBinaryCascadePN
 MinEnergyBinaryCascadePN: Minimum energy for p,n low energy binary cascade.
double m_maxEnergyBinaryCascadePN
 MaxEnergyBinaryCascadePN: Maximum energy for p,n low energy binary cascade.
double m_minEnergyBinaryCascadePi
 MinEnergyBinaryCascadePi: Minimum energy for pion low energy binary cascade.
double m_maxEnergyBinaryCascadePi
 MaxEnergyBinaryCascadePi: Maximum energy for pion low energy binary cascade.
double m_neutronElasticEnergyBoundary
 NeutronElasticEnergyBoundary: Energy boundary between simple low energy and precision high energy elastic models.
double m_neutronInlasticEnergyBoundary
 NeutronInelasticEnergyBoundary: Energy boundary between simple low energy and precision high energy inelastic models.
double m_fissionEnergyBoundary
 FissionEnergyBoundary: Energy boundary between simple low energy and precision high energy fission models.
double m_captureEnergyBoundary
 CaptureEnergyBoundary: Energy boundary between simple low energy and precision high energy capture models.
INeutronCaptureInfom_capinfo
 NeutronCaptureInfo: GaudiTool of recording the capture target info.

Detailed Description

Hadron production physics.

bv@bnl.gov Wed Apr 16 11:44:11 2008

Definition at line 25 of file DsPhysConsHadron.h.


Constructor & Destructor Documentation

DsPhysConsHadron::DsPhysConsHadron ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 131 of file DsPhysConsHadron.cc.

    : GiGaPhysConstructorBase(type,name,parent)
{
    declareProperty("MinEnergyForMultiFrag",m_minEnergyForMultiFrag=3.0*MeV,
                    "Minimum energy for multi-fragmentation.");
    declareProperty("MaxEnergyPreEquilProton",m_maxEnergyPreEquilProton=70*MeV,
                    "Maximum energy for pre-equilibrium proton");
    declareProperty("MinEnergyPreEquilNeutron",m_minEnergyPreEquilNeutron=20*MeV,
                    "Minimum energy for pre-equilibrium neutron");
    declareProperty("MaxEnergyPreEquilNeutron",m_maxEnergyPreEquilNeutron=70*MeV,
                    "Maximum energy for pre-equilibrium neutron");
    declareProperty("MinEnergyHEModel",m_minEnergyHEModel=12*GeV,
                    "Minimum energy for high-energy model");
    declareProperty("MaxEnergyHEModel",m_maxEnergyHEModel=100*TeV,
                    "Maximum energy for high-energy model");
    declareProperty("LEPUpperLimit",m_lepUpperLimit=25*GeV,
                    "Low-energy parametrized model upper limit.");
    declareProperty("LEPpnpiLimit",m_lepPnpiLimit=9.5*GeV,
                    "Low-energy parametrized model pnpi limit.");
    declareProperty("MinEnergyBinaryCascadePN",m_minEnergyBinaryCascadePN=65*MeV,
                    "Minimum energy for p,n low energy binary cascade");
    declareProperty("MaxEnergyBinaryCascadePN",m_maxEnergyBinaryCascadePN=9.9*GeV,
                    "Maximum energy for p,n low energy binary cascade");
    declareProperty("MinEnergyBinaryCascadePi",m_minEnergyBinaryCascadePi=0*GeV,
                    "Minimum energy for pion low energy binary cascade");
    declareProperty("MaxEnergyBinaryCascadePi",m_maxEnergyBinaryCascadePi=9.9*GeV,
                    "Maximum energy for pion low energy binary cascade");
    declareProperty("NeutronElasticEnergyBoundary",m_neutronElasticEnergyBoundary=20*MeV,
                    "Energy boundary between simple low energy and "
                    "precision high energy elastic models");
    declareProperty("NeutronInelasticEnergyBoundary",m_neutronInlasticEnergyBoundary=20*MeV,
                    "Energy boundary between simple low energy and "
                    "precision high energy inelastic models");
    declareProperty("FissionEnergyBoundary",m_fissionEnergyBoundary=20*MeV,
                    "Energy boundary between simple low energy and "
                    "precision high energy fission models");
    declareProperty("CaptureEnergyBoundary",m_captureEnergyBoundary=20*MeV,
                    "Energy boundary between simple low energy and "
                    "precision high energy capture models");

    m_capinfo = tool<INeutronCaptureInfo>("G4DhNeutronCaptureInfoTool");
    
}
DsPhysConsHadron::~DsPhysConsHadron ( ) [virtual]

Definition at line 177 of file DsPhysConsHadron.cc.

{
}

Member Function Documentation

void DsPhysConsHadron::ConstructParticle ( )

Definition at line 182 of file DsPhysConsHadron.cc.

{
}
void DsPhysConsHadron::ConstructProcess ( )

Definition at line 202 of file DsPhysConsHadron.cc.

{

    // Hadronic Elastic Process and Model (the same for all hadrons except Neutron)

    G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess("LElastic");
    G4LElastic* theElasticModel = new G4LElastic();
    theElasticProcess->RegisterMe(theElasticModel);


    // evaporation logic for thermal nucleons

    G4Evaporation* theEvaporation;
    G4FermiBreakUp* theFermiBreakUp;
    G4StatMF* theMF;
    theEvaporation = new G4Evaporation();
    theFermiBreakUp = new G4FermiBreakUp();
    theMF = new G4StatMF();

    G4ExcitationHandler* theHandler;
    theHandler = new G4ExcitationHandler();
    theHandler->SetEvaporation(theEvaporation);
    theHandler->SetFermiModel(theFermiBreakUp);
    theHandler->SetMultiFragmentation(theMF);
    theHandler->SetMaxAandZForFermiBreakUp(12, 6);
    //theHandler->SetMinEForMultiFrag(3.*MeV);
    theHandler->SetMinEForMultiFrag(m_minEnergyForMultiFrag);

    // pre-equilibrium stage for proton
    G4PreCompoundModel* thePreEquilib;
    thePreEquilib = new G4PreCompoundModel(theHandler);
    //thePreEquilib->SetMaxEnergy(70*MeV);
    thePreEquilib->SetMaxEnergy(m_maxEnergyPreEquilProton);

    // pre-equilibrium stage for neutron
    G4PreCompoundModel* thePreEquilib2;
    thePreEquilib2 = new G4PreCompoundModel(theHandler);
    //thePreEquilib2->SetMinEnergy(20*MeV);
    thePreEquilib2->SetMinEnergy(m_minEnergyPreEquilNeutron);
    //thePreEquilib2->SetMaxEnergy(70*MeV);
    thePreEquilib2->SetMaxEnergy(m_maxEnergyPreEquilNeutron);

    // high energy model for proton, neutron, pions and kaons
    G4TheoFSGenerator* theHEModel = new G4TheoFSGenerator();
    G4GeneratorPrecompoundInterface* theCascade2 =
        new G4GeneratorPrecompoundInterface();
    theCascade2->SetDeExcitation(thePreEquilib);
    theHEModel->SetTransport(theCascade2);
    G4QGSMFragmentation* frag = new G4QGSMFragmentation();
    G4ExcitedStringDecay* stringDecay = new G4ExcitedStringDecay(frag);
    G4QGSModel<G4QGSParticipants>* stringModel =
        new G4QGSModel<G4QGSParticipants>();
    stringModel->SetFragmentationModel(stringDecay);
    theHEModel->SetHighEnergyGenerator(stringModel);
    //theHEModel->SetMinEnergy(12*GeV);
    theHEModel->SetMinEnergy(m_minEnergyHEModel);
    //theHEModel->SetMaxEnergy(100*TeV);
    theHEModel->SetMaxEnergy(m_maxEnergyHEModel);

    // Low energy parameterized models : use between 9.5 and 25 GeV for pions
    //G4double LEPUpperLimit = 25*GeV;
    G4double LEPUpperLimit = m_lepUpperLimit;
    //G4double LEPpnpiLimit = 9.5*GeV;
    G4double LEPpnpiLimit = m_lepPnpiLimit;

    // Binary cascade for p, n at low energy
    G4BinaryCascade* theCasc;
    theCasc = new G4BinaryCascade;
    //theCasc->SetMinEnergy(65*MeV);
    theCasc->SetMinEnergy(m_minEnergyBinaryCascadePN);
    theCasc->SetMaxEnergy(m_maxEnergyBinaryCascadePN);

    // Binary cascade crashes on pi. use Bertini instead
    G4CascadeInterface* bertiniModel = new G4CascadeInterface();
    //bertiniModel->SetMinEnergy(0.*GeV);
    bertiniModel->SetMinEnergy(m_minEnergyBinaryCascadePi);
    bertiniModel->SetMaxEnergy(m_maxEnergyBinaryCascadePi);

    G4ProcessManager * pmanager = 0;

    //               //
    //  pi+ physics  //
    //               //

    pmanager = G4PionPlus::PionPlus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4PionPlusInelasticProcess* pipinelProc = new G4PionPlusInelasticProcess();
    G4PiNuclearCrossSection* pion_XC = new G4PiNuclearCrossSection();
    pipinelProc->AddDataSet(pion_XC);

    pipinelProc->RegisterMe(bertiniModel);

    G4LEPionPlusInelastic* LEPpipModel = new G4LEPionPlusInelastic();
    LEPpipModel->SetMinEnergy(LEPpnpiLimit);
    LEPpipModel->SetMaxEnergy(LEPUpperLimit);

    pipinelProc->RegisterMe(LEPpipModel);
    pipinelProc->RegisterMe(theHEModel);
  
    pmanager->AddDiscreteProcess(pipinelProc);

    //               //
    //  pi- physics  //
    //               //

    pmanager = G4PionMinus::PionMinus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4PionMinusInelasticProcess* piminelProc = new G4PionMinusInelasticProcess();

    piminelProc->AddDataSet(pion_XC);

    piminelProc->RegisterMe(bertiniModel);

    G4LEPionMinusInelastic* LEPpimModel = new G4LEPionMinusInelastic();
    LEPpimModel->SetMinEnergy(LEPpnpiLimit);
    LEPpimModel->SetMaxEnergy(LEPUpperLimit);
      
    piminelProc->RegisterMe(LEPpimModel);
    piminelProc->RegisterMe(theHEModel);

    pmanager->AddDiscreteProcess(piminelProc);

    // pi- absorption at rest
    G4PionMinusAbsorptionAtRest* pimAbsorb = new G4PionMinusAbsorptionAtRest();
    pmanager->AddRestProcess(pimAbsorb);

    //               //
    //  K+ physics   //
    //               //

    pmanager = G4KaonPlus::KaonPlus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);


    // hadron inelastic
    G4KaonPlusInelasticProcess* kpinelProc = new G4KaonPlusInelasticProcess();
    G4LEKaonPlusInelastic* LEPkpModel = new G4LEKaonPlusInelastic();
    LEPkpModel->SetMaxEnergy(LEPUpperLimit);
      
    kpinelProc->RegisterMe(LEPkpModel);
    kpinelProc->RegisterMe(theHEModel);
      
    pmanager->AddDiscreteProcess(kpinelProc);

    //               //
    //  K0S physics  //
    //               //

    pmanager = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4KaonZeroSInelasticProcess* k0SinelProc = new G4KaonZeroSInelasticProcess();
    G4LEKaonZeroSInelastic* LEPk0SModel = new G4LEKaonZeroSInelastic();
    LEPk0SModel->SetMaxEnergy(LEPUpperLimit);

    k0SinelProc->RegisterMe(LEPk0SModel);
    k0SinelProc->RegisterMe(theHEModel);
      
    pmanager->AddDiscreteProcess(k0SinelProc);

    //               //
    //  K0L physics  //
    //               //

    pmanager = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4KaonZeroLInelasticProcess* k0LinelProc = new G4KaonZeroLInelasticProcess();
    G4LEKaonZeroLInelastic* LEPk0LModel = new G4LEKaonZeroLInelastic();
    LEPk0LModel->SetMaxEnergy(LEPUpperLimit);
      
    k0LinelProc->RegisterMe(LEPk0LModel);
    k0LinelProc->RegisterMe(theHEModel);
      
    pmanager->AddDiscreteProcess(k0LinelProc);

    //               //
    //  K- physics   //
    //               //

    pmanager = G4KaonMinus::KaonMinus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);
      
    // hadron inelastic
    G4KaonMinusInelasticProcess* kminelProc = new G4KaonMinusInelasticProcess();
    G4LEKaonMinusInelastic* LEPkmModel = new G4LEKaonMinusInelastic();
    LEPkmModel->SetMaxEnergy(LEPUpperLimit);
      
    kminelProc->RegisterMe(LEPkmModel);
    kminelProc->RegisterMe(theHEModel);
      
    pmanager->AddDiscreteProcess(kminelProc);

    // K- absorption at rest
    G4KaonMinusAbsorption* kmAbsorb = new G4KaonMinusAbsorption();
    pmanager->AddRestProcess(kmAbsorb);
  
    //               //
    //    Proton     //
    //               //

    pmanager = G4Proton::Proton()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4ProtonInelasticProcess* pinelProc = new G4ProtonInelasticProcess();
    G4ProtonInelasticCrossSection* proton_XC = 
        new G4ProtonInelasticCrossSection();
    pinelProc->AddDataSet(proton_XC);

    G4LEProtonInelastic* LEPpModel = new G4LEProtonInelastic();
    LEPpModel->SetMinEnergy(LEPpnpiLimit);
    LEPpModel->SetMaxEnergy(LEPUpperLimit);

    pinelProc->RegisterMe(thePreEquilib);
    pinelProc->RegisterMe(theCasc);
    pinelProc->RegisterMe(LEPpModel);
    pinelProc->RegisterMe(theHEModel);

    pmanager->AddDiscreteProcess(pinelProc);

    //               //
    //  Anti-Proton  //
    //               //

    pmanager = G4AntiProton::AntiProton()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4AntiProtonInelasticProcess* apinelProc = 
        new G4AntiProtonInelasticProcess();
    G4LEAntiProtonInelastic* LEPapModel = new G4LEAntiProtonInelastic(); 
    LEPapModel->SetMaxEnergy(LEPUpperLimit);
    apinelProc->RegisterMe(LEPapModel);

    G4HEAntiProtonInelastic* HEPapModel = new G4HEAntiProtonInelastic(); 
    HEPapModel->SetMinEnergy(LEPUpperLimit);
    apinelProc->RegisterMe(HEPapModel);

    pmanager->AddDiscreteProcess(apinelProc);

    // anti-proton annihilation at rest
    G4AntiProtonAnnihilationAtRest* apAnnihil = 
        new G4AntiProtonAnnihilationAtRest();
    pmanager->AddRestProcess(apAnnihil);
 
    //               //
    //    Neutron    //
    //               //

    pmanager = G4Neutron::Neutron()->GetProcessManager();

    // elastic scattering
    info () << "Creating neutron elastic processes" << endreq;
    G4UHadronElasticProcess* theHadronElasticProcess = new G4UHadronElasticProcess("neutronElastic");
    G4HadronElastic* theNeutronElasticModel = new G4HadronElastic();
    G4NeutronHPElastic* theNeutronHPElastic = new G4NeutronHPElastic();
    //theNeutronHPElastic->SetMinEnergy(0.*MeV);
    theNeutronHPElastic->SetMinEnergy(4.0*eV);//caogf
    //theNeutronHPElastic->SetMaxEnergy(20.*MeV);
    theNeutronHPElastic->SetMaxEnergy(m_neutronElasticEnergyBoundary);

    dump_element_table();
    G4NeutronHPElasticData* theHPElasticData = new G4NeutronHPElasticData();
    theHadronElasticProcess->AddDataSet(theHPElasticData);
    //theNeutronElasticModel->SetMinEnergy(20.*MeV);
    theNeutronElasticModel->SetMinEnergy(m_neutronElasticEnergyBoundary);

    //add thermal scattering
    DsG4NeutronHPThermalScatteringData* theHPThermalScatteringData = new DsG4NeutronHPThermalScatteringData();
    theHadronElasticProcess->AddDataSet(theHPThermalScatteringData);
    DsG4NeutronHPThermalScattering* theNeutronThermalElasticModel = new DsG4NeutronHPThermalScattering();
    theNeutronThermalElasticModel->SetMaxEnergy(4.0*eV);
  
    theHadronElasticProcess->RegisterMe(theNeutronHPElastic);
    theHadronElasticProcess->RegisterMe(theNeutronElasticModel);
    theHadronElasticProcess->RegisterMe(theNeutronThermalElasticModel);

    pmanager->AddDiscreteProcess(theHadronElasticProcess);

      
    // inelastic scattering
    G4NeutronInelasticProcess* ninelProc = new G4NeutronInelasticProcess();
    G4NeutronInelasticCrossSection* neutron_XC = 
        new G4NeutronInelasticCrossSection();
    ninelProc->AddDataSet(neutron_XC);
  
    G4NeutronHPInelastic* theNeutronHPInelastic = new G4NeutronHPInelastic();
    //theNeutronHPInelastic->SetMaxEnergy(20.*MeV );
    theNeutronHPInelastic->SetMaxEnergy(m_neutronInlasticEnergyBoundary);
    G4NeutronHPInelasticData* theHPInelasticData = new G4NeutronHPInelasticData();

    G4LENeutronInelastic* LEPnModel = new G4LENeutronInelastic();
    LEPnModel->SetMinEnergy(LEPpnpiLimit);
    LEPnModel->SetMaxEnergy(LEPUpperLimit);

    ninelProc->RegisterMe(theNeutronHPInelastic);
    ninelProc->AddDataSet(theHPInelasticData);
    ninelProc->RegisterMe(thePreEquilib2);
    ninelProc->RegisterMe(theCasc);
    ninelProc->RegisterMe(LEPnModel);
    ninelProc->RegisterMe(theHEModel);

    pmanager->AddDiscreteProcess(ninelProc);

    // fission process 
    G4HadronFissionProcess* theHadronFissionProcess = new G4HadronFissionProcess();
    G4LFission* theNeutronLFission = new G4LFission();
    G4NeutronHPFission* theNeutronHPFission  = new   G4NeutronHPFission();
    //theNeutronHPFission->SetMaxEnergy( 20.*MeV );
    theNeutronHPFission->SetMaxEnergy(m_fissionEnergyBoundary);
    //theNeutronLFission->SetMinEnergy( 20.*MeV );
    theNeutronLFission->SetMinEnergy(m_fissionEnergyBoundary);
    theHadronFissionProcess->RegisterMe( theNeutronHPFission );
    theHadronFissionProcess->RegisterMe( theNeutronLFission );
    //AddDataSet(theHadronFissionProcess, new G4NeutronHPFissionData() );
    theHadronFissionProcess->AddDataSet(new G4NeutronHPFissionData());
    pmanager->AddDiscreteProcess(theHadronFissionProcess);
      
    // capture  
    info() << "Creating DsG4NeutronHPCapture" << endreq;
    G4HadronCaptureProcess* theNeutronCaptureProcess = new G4HadronCaptureProcess();
    G4LCapture* theNeutronLCapture = new G4LCapture();

    DsG4NeutronHPCapture* theNeutronHPCapture = new DsG4NeutronHPCapture();

    theNeutronHPCapture->passNeutronCaptureInfoTool(m_capinfo);

    //theNeutronHPCapture->SetMaxEnergy( 20.*MeV );
    theNeutronHPCapture->SetMaxEnergy(m_captureEnergyBoundary);
    //theNeutronLCapture->SetMinEnergy( 20.*MeV );

    theNeutronLCapture->SetMinEnergy(m_captureEnergyBoundary);
    theNeutronCaptureProcess->RegisterMe( theNeutronHPCapture );
    theNeutronCaptureProcess->RegisterMe( theNeutronLCapture );
    //AddDataSet(theNeutronCaptureProcess, new G4NeutronHPCaptureData());
    theNeutronCaptureProcess->AddDataSet(new G4NeutronHPCaptureData());
    pmanager->AddDiscreteProcess(theNeutronCaptureProcess);

    //               //
    // Anti-Neutron  //
    //               //

    pmanager = G4AntiNeutron::AntiNeutron()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4AntiNeutronInelasticProcess* aninelProc = 
        new G4AntiNeutronInelasticProcess();
    G4LEAntiNeutronInelastic* LEPanModel = new G4LEAntiNeutronInelastic();
    LEPanModel->SetMaxEnergy(LEPUpperLimit); 
    aninelProc->RegisterMe(LEPanModel);
    G4HEAntiNeutronInelastic* HEPanModel = new G4HEAntiNeutronInelastic();
    HEPanModel->SetMinEnergy(LEPUpperLimit);
    aninelProc->RegisterMe(HEPanModel);
    pmanager->AddDiscreteProcess(aninelProc);

    // anti-neutron annihilation at rest
    G4AntiNeutronAnnihilationAtRest* anAnnihil = 
        new G4AntiNeutronAnnihilationAtRest();
    pmanager->AddRestProcess(anAnnihil);

    //               //
    //    Lambda     //
    //               //

    pmanager = G4Lambda::Lambda()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4LambdaInelasticProcess* linelProc = 
        new G4LambdaInelasticProcess();
    G4LELambdaInelastic* LEPlModel = new G4LELambdaInelastic();
    LEPlModel->SetMaxEnergy(LEPUpperLimit); 
    linelProc->RegisterMe(LEPlModel);
    G4HELambdaInelastic* HEPlModel = new G4HELambdaInelastic(); 
    HEPlModel->SetMinEnergy(LEPUpperLimit);
    linelProc->RegisterMe(HEPlModel);
  
    pmanager->AddDiscreteProcess(linelProc);

    //               //
    //  Anti-Lambda  //
    //               //

    pmanager = G4AntiLambda::AntiLambda()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4AntiLambdaInelasticProcess* alinelProc = 
        new G4AntiLambdaInelasticProcess();
    G4LEAntiLambdaInelastic* LEPalModel = new G4LEAntiLambdaInelastic();
    LEPalModel->SetMaxEnergy(LEPUpperLimit); 
    alinelProc->RegisterMe(LEPalModel);
    G4HEAntiLambdaInelastic* HEPalModel = new G4HEAntiLambdaInelastic(); 
    HEPalModel->SetMinEnergy(LEPUpperLimit);
    alinelProc->RegisterMe(HEPalModel);

    pmanager->AddDiscreteProcess(alinelProc);

    //               //
    //    Sigma+     //
    //               //

    pmanager = G4SigmaPlus::SigmaPlus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4SigmaPlusInelasticProcess* spinelProc = new G4SigmaPlusInelasticProcess();
    G4LESigmaPlusInelastic* LEPspModel = new G4LESigmaPlusInelastic();
    LEPspModel->SetMaxEnergy(LEPUpperLimit);
    spinelProc->RegisterMe(LEPspModel);
    G4HESigmaPlusInelastic* HEPspModel = new G4HESigmaPlusInelastic(); 
    HEPspModel->SetMinEnergy(LEPUpperLimit);
    spinelProc->RegisterMe(HEPspModel);
      
    pmanager->AddDiscreteProcess(spinelProc);

    //               //
    //    Sigma-     //
    //               //

    pmanager = G4SigmaMinus::SigmaMinus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4SigmaMinusInelasticProcess* sminelProc = 
        new G4SigmaMinusInelasticProcess();
    G4LESigmaMinusInelastic* LEPsmModel = new G4LESigmaMinusInelastic(); 
    LEPsmModel->SetMaxEnergy(LEPUpperLimit);
    sminelProc->RegisterMe(LEPsmModel);
    G4HESigmaMinusInelastic* HEPsmModel = new G4HESigmaMinusInelastic(); 
    HEPsmModel->SetMinEnergy(LEPUpperLimit);
    sminelProc->RegisterMe(HEPsmModel);
      
    pmanager->AddDiscreteProcess(sminelProc);

    //               //
    //  Anti-Sigma+  //
    //               //

    pmanager = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4AntiSigmaPlusInelasticProcess* aspinelProc = 
        new G4AntiSigmaPlusInelasticProcess();
    G4LEAntiSigmaPlusInelastic* LEPaspModel = 
        new G4LEAntiSigmaPlusInelastic(); 
    LEPaspModel->SetMaxEnergy(LEPUpperLimit);
    aspinelProc->RegisterMe(LEPaspModel);
    G4HEAntiSigmaPlusInelastic* HEPaspModel = 
        new G4HEAntiSigmaPlusInelastic(); 
    HEPaspModel->SetMinEnergy(LEPUpperLimit);
    aspinelProc->RegisterMe(HEPaspModel);
    pmanager->AddDiscreteProcess(aspinelProc);

    //               //
    //  Anti-Sigma-  //
    //               //

    pmanager = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);
      
    // hadron inelastic
    G4AntiSigmaMinusInelasticProcess* asminelProc = 
        new G4AntiSigmaMinusInelasticProcess();
    G4LEAntiSigmaMinusInelastic* LEPasmModel = 
        new G4LEAntiSigmaMinusInelastic(); 
    LEPasmModel->SetMaxEnergy(LEPUpperLimit);
    asminelProc->RegisterMe(LEPasmModel);
    G4HEAntiSigmaMinusInelastic* HEPasmModel = 
        new G4HEAntiSigmaMinusInelastic(); 
    HEPasmModel->SetMinEnergy(LEPUpperLimit);
    asminelProc->RegisterMe(HEPasmModel);

    pmanager->AddDiscreteProcess(asminelProc);

    //               //
    //      Xi0      //
    //               //

    pmanager = G4XiZero::XiZero()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4XiZeroInelasticProcess* x0inelProc = new G4XiZeroInelasticProcess();
    G4LEXiZeroInelastic* LEPx0Model = new G4LEXiZeroInelastic();
    LEPx0Model->SetMaxEnergy(LEPUpperLimit); 
    x0inelProc->RegisterMe(LEPx0Model);
    G4HEXiZeroInelastic* HEPx0Model = new G4HEXiZeroInelastic(); 
    HEPx0Model->SetMinEnergy(LEPUpperLimit);
    x0inelProc->RegisterMe(HEPx0Model);

    pmanager->AddDiscreteProcess(x0inelProc);

    //               //
    //      Xi-      //
    //               //

    pmanager = G4XiMinus::XiMinus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4XiMinusInelasticProcess* xminelProc = new G4XiMinusInelasticProcess();
    G4LEXiMinusInelastic* LEPxmModel = new G4LEXiMinusInelastic(); 
    LEPxmModel->SetMaxEnergy(LEPUpperLimit);
    xminelProc->RegisterMe(LEPxmModel);
    G4HEXiMinusInelastic* HEPxmModel = new G4HEXiMinusInelastic();
    HEPxmModel->SetMinEnergy(LEPUpperLimit);
    xminelProc->RegisterMe(HEPxmModel);
      
    pmanager->AddDiscreteProcess(xminelProc);

    //               //
    //   Anti-Xi0    //
    //               //

    pmanager = G4AntiXiZero::AntiXiZero()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4AntiXiZeroInelasticProcess* ax0inelProc = 
        new G4AntiXiZeroInelasticProcess();
    G4LEAntiXiZeroInelastic* LEPax0Model = new G4LEAntiXiZeroInelastic();
    LEPax0Model->SetMaxEnergy(LEPUpperLimit); 
    ax0inelProc->RegisterMe(LEPax0Model);
    G4HEAntiXiZeroInelastic* HEPax0Model = new G4HEAntiXiZeroInelastic(); 
    HEPax0Model->SetMinEnergy(LEPUpperLimit);
    ax0inelProc->RegisterMe(HEPax0Model);

    pmanager->AddDiscreteProcess(ax0inelProc);

    //               //
    //   Anti-Xi-    //
    //               //

    pmanager = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4AntiXiMinusInelasticProcess* axminelProc = 
        new G4AntiXiMinusInelasticProcess();
    G4LEAntiXiMinusInelastic* LEPaxmModel = new G4LEAntiXiMinusInelastic();
    LEPaxmModel->SetMaxEnergy(LEPUpperLimit);
    axminelProc->RegisterMe(LEPaxmModel);
    G4HEAntiXiMinusInelastic* HEPaxmModel = new G4HEAntiXiMinusInelastic();
    HEPaxmModel->SetMinEnergy(LEPUpperLimit);
    axminelProc->RegisterMe(HEPaxmModel);

    pmanager->AddDiscreteProcess(axminelProc);

    //               //
    //    Omega-     //
    //               //

    pmanager = G4OmegaMinus::OmegaMinus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4OmegaMinusInelasticProcess* ominelProc = 
        new G4OmegaMinusInelasticProcess();
    G4LEOmegaMinusInelastic* LEPomModel = new G4LEOmegaMinusInelastic();
    LEPomModel->SetMaxEnergy(LEPUpperLimit); 
    ominelProc->RegisterMe(LEPomModel);
    G4HEOmegaMinusInelastic* HEPomModel = new G4HEOmegaMinusInelastic();
    HEPomModel->SetMinEnergy(LEPUpperLimit);
    ominelProc->RegisterMe(HEPomModel);
      
    pmanager->AddDiscreteProcess(ominelProc);

    //               //
    //  Anti-Omega-  //
    //               //

    pmanager = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();

    // hadron elastic
    pmanager->AddDiscreteProcess(theElasticProcess);

    // hadron inelastic
    G4AntiOmegaMinusInelasticProcess* aominelProc = 
        new G4AntiOmegaMinusInelasticProcess();
    G4LEAntiOmegaMinusInelastic* LEPaomModel = 
        new G4LEAntiOmegaMinusInelastic();
    LEPaomModel->SetMaxEnergy(LEPUpperLimit);
    aominelProc->RegisterMe(LEPaomModel);
    G4HEAntiOmegaMinusInelastic* HEPaomModel = 
        new G4HEAntiOmegaMinusInelastic(); 
    HEPaomModel->SetMinEnergy(LEPUpperLimit);
    aominelProc->RegisterMe(HEPaomModel);

    pmanager->AddDiscreteProcess(aominelProc);

}

Member Data Documentation

MinEnergyForMultiFrag: Minimum energy for multi-fragmentation.

Definition at line 42 of file DsPhysConsHadron.h.

MaxEnergyPreEquilProton: Maximum energy for pre-equilibrium proton.

Definition at line 46 of file DsPhysConsHadron.h.

MinEnergyPreEquilNeutron: Minimum energy for pre-equilibrium neutron.

Definition at line 50 of file DsPhysConsHadron.h.

MaxEnergyPreEquilNeutron: Maximum energy for pre-equilibrium neutron.

Definition at line 54 of file DsPhysConsHadron.h.

MinEnergyHEModel: Minimum energy for high-energy mode.

Definition at line 57 of file DsPhysConsHadron.h.

MaxEnergyHEModel: Maximum energy for high-energy mode.

Definition at line 60 of file DsPhysConsHadron.h.

LEPUpperLimit: Low-energy parametrized model upper limit.

Definition at line 63 of file DsPhysConsHadron.h.

LEPpnpiLimit: Low-energy parametrized model pnpi limit.

Definition at line 66 of file DsPhysConsHadron.h.

MinEnergyBinaryCascadePN: Minimum energy for p,n low energy binary cascade.

Definition at line 70 of file DsPhysConsHadron.h.

MaxEnergyBinaryCascadePN: Maximum energy for p,n low energy binary cascade.

Definition at line 74 of file DsPhysConsHadron.h.

MinEnergyBinaryCascadePi: Minimum energy for pion low energy binary cascade.

Definition at line 78 of file DsPhysConsHadron.h.

MaxEnergyBinaryCascadePi: Maximum energy for pion low energy binary cascade.

Definition at line 82 of file DsPhysConsHadron.h.

NeutronElasticEnergyBoundary: Energy boundary between simple low energy and precision high energy elastic models.

Definition at line 86 of file DsPhysConsHadron.h.

NeutronInelasticEnergyBoundary: Energy boundary between simple low energy and precision high energy inelastic models.

Definition at line 90 of file DsPhysConsHadron.h.

FissionEnergyBoundary: Energy boundary between simple low energy and precision high energy fission models.

Definition at line 94 of file DsPhysConsHadron.h.

CaptureEnergyBoundary: Energy boundary between simple low energy and precision high energy capture models.

Definition at line 98 of file DsPhysConsHadron.h.

NeutronCaptureInfo: GaudiTool of recording the capture target info.

Definition at line 101 of file DsPhysConsHadron.h.


The documentation for this class was generated from the following files:
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

Generated on Fri May 16 2014 10:17:58 for DetSim by doxygen 1.7.4