| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

In This Package:

src

DsPhysConsHadron.cc

Go to the documentation of this file.
00001 #include "DsPhysConsHadron.h"
00002 
00003 #include "G4ProcessManager.hh"
00004 
00006 
00007 #include "G4TheoFSGenerator.hh"
00008 #include "G4QGSModel.hh"
00009 #include "G4QGSMFragmentation.hh"
00010 #include "G4ExcitedStringDecay.hh"
00011 #include "G4GeneratorPrecompoundInterface.hh"
00012 
00013 // elastic fission and capture process for all hadrons
00014 #include "G4HadronElasticProcess.hh"
00015 #include "G4HadronFissionProcess.hh"
00016 #include "G4HadronCaptureProcess.hh"
00017 
00018 // inelastice process for each hadron
00019 #include "G4PionPlusInelasticProcess.hh"
00020 #include "G4PionMinusInelasticProcess.hh"
00021 #include "G4KaonPlusInelasticProcess.hh"
00022 #include "G4KaonZeroSInelasticProcess.hh"
00023 #include "G4KaonZeroLInelasticProcess.hh"
00024 #include "G4KaonMinusInelasticProcess.hh"
00025 #include "G4ProtonInelasticProcess.hh"
00026 #include "G4AntiProtonInelasticProcess.hh"
00027 #include "G4NeutronInelasticProcess.hh"
00028 #include "G4AntiNeutronInelasticProcess.hh"
00029 #include "G4LambdaInelasticProcess.hh"
00030 #include "G4AntiLambdaInelasticProcess.hh"
00031 #include "G4SigmaPlusInelasticProcess.hh"
00032 #include "G4SigmaMinusInelasticProcess.hh"
00033 #include "G4AntiSigmaPlusInelasticProcess.hh"
00034 #include "G4AntiSigmaMinusInelasticProcess.hh"
00035 #include "G4XiZeroInelasticProcess.hh"
00036 #include "G4XiMinusInelasticProcess.hh"
00037 #include "G4AntiXiZeroInelasticProcess.hh"
00038 #include "G4AntiXiMinusInelasticProcess.hh"
00039 #include "G4OmegaMinusInelasticProcess.hh"
00040 #include "G4AntiOmegaMinusInelasticProcess.hh"
00041 
00042 // Low-energy models
00043 
00044 #include "G4LElastic.hh"   
00045 #include "G4LFission.hh"
00046 #include "G4LCapture.hh"
00047 
00048 #include "G4UHadronElasticProcess.hh"
00049 #include "G4HadronElastic.hh"
00050 #include "G4PreCompoundModel.hh"
00051 #include "G4BinaryCascade.hh"
00052 #include "G4CascadeInterface.hh"
00053 
00054 #include "G4LEPionPlusInelastic.hh"
00055 #include "G4LEPionMinusInelastic.hh"
00056 #include "G4LEKaonPlusInelastic.hh"
00057 #include "G4LEKaonZeroSInelastic.hh"
00058 #include "G4LEKaonZeroLInelastic.hh"
00059 #include "G4LEKaonMinusInelastic.hh"
00060 #include "G4LEProtonInelastic.hh"
00061 #include "G4LEAntiProtonInelastic.hh"
00062 #include "G4LENeutronInelastic.hh"
00063 #include "G4LEAntiNeutronInelastic.hh"
00064 #include "G4LELambdaInelastic.hh"
00065 #include "G4LEAntiLambdaInelastic.hh"
00066 #include "G4LESigmaPlusInelastic.hh"
00067 #include "G4LESigmaMinusInelastic.hh"
00068 #include "G4LEAntiSigmaPlusInelastic.hh"
00069 #include "G4LEAntiSigmaMinusInelastic.hh"
00070 #include "G4LEXiZeroInelastic.hh"
00071 #include "G4LEXiMinusInelastic.hh"
00072 #include "G4LEAntiXiZeroInelastic.hh"
00073 #include "G4LEAntiXiMinusInelastic.hh"
00074 #include "G4LEOmegaMinusInelastic.hh"
00075 #include "G4LEAntiOmegaMinusInelastic.hh"
00076 
00077 // High-energy Models
00078 
00079 #include "G4HEPionPlusInelastic.hh"
00080 #include "G4HEPionMinusInelastic.hh"
00081 #include "G4HEKaonPlusInelastic.hh"
00082 #include "G4HEKaonZeroInelastic.hh"
00083 #include "G4HEKaonZeroInelastic.hh"
00084 #include "G4HEKaonMinusInelastic.hh"
00085 #include "G4HEProtonInelastic.hh"
00086 #include "G4HEAntiProtonInelastic.hh"
00087 #include "G4HENeutronInelastic.hh"
00088 #include "G4HEAntiNeutronInelastic.hh"
00089 #include "G4HELambdaInelastic.hh"
00090 #include "G4HEAntiLambdaInelastic.hh"
00091 #include "G4HESigmaPlusInelastic.hh"
00092 #include "G4HESigmaMinusInelastic.hh"
00093 #include "G4HEAntiSigmaPlusInelastic.hh"
00094 #include "G4HEAntiSigmaMinusInelastic.hh"
00095 #include "G4HEXiZeroInelastic.hh"
00096 #include "G4HEXiMinusInelastic.hh"
00097 #include "G4HEAntiXiZeroInelastic.hh"
00098 #include "G4HEAntiXiMinusInelastic.hh"
00099 #include "G4HEOmegaMinusInelastic.hh"
00100 #include "G4HEAntiOmegaMinusInelastic.hh"
00101 
00102 // high precision model for neutron < 20MeV
00103 
00104 #include "G4NeutronHPElastic.hh"
00105 #include "G4NeutronHPInelastic.hh"
00106 #include "G4NeutronHPFission.hh"
00107 //#include "G4NeutronHPCapture.hh"
00108 #include "DsG4NeutronHPCapture.h" // modified class from G4NeutronHPCapture 
00109 
00110 #include "G4NeutronHPCaptureData.hh"
00111 #include "G4NeutronHPFissionData.hh"
00112 #include "G4NeutronHPElasticData.hh"
00113 #include "G4NeutronHPInelasticData.hh"
00114 
00115 // Stopping processes
00116 #include "G4AntiProtonAnnihilationAtRest.hh"
00117 #include "G4AntiNeutronAnnihilationAtRest.hh"
00118 #include "G4PionMinusAbsorptionAtRest.hh"
00119 #include "G4KaonMinusAbsorption.hh"
00120 
00121 //Cross-section
00122 #include "G4PiNuclearCrossSection.hh"
00123 #include "G4ProtonInelasticCrossSection.hh"
00124 #include "G4NeutronInelasticCrossSection.hh"
00125 
00126 DsPhysConsHadron::DsPhysConsHadron(const std::string& type,
00127                                    const std::string& name,
00128                                    const IInterface* parent)
00129     : GiGaPhysConstructorBase(type,name,parent)
00130 {
00131     declareProperty("MinEnergyForMultiFrag",m_minEnergyForMultiFrag=3.0*MeV,
00132                     "Minimum energy for multi-fragmentation.");
00133     declareProperty("MaxEnergyPreEquilProton",m_maxEnergyPreEquilProton=70*MeV,
00134                     "Maximum energy for pre-equilibrium proton");
00135     declareProperty("MinEnergyPreEquilNeutron",m_minEnergyPreEquilNeutron=20*MeV,
00136                     "Minimum energy for pre-equilibrium neutron");
00137     declareProperty("MaxEnergyPreEquilNeutron",m_maxEnergyPreEquilNeutron=70*MeV,
00138                     "Maximum energy for pre-equilibrium neutron");
00139     declareProperty("MinEnergyHEModel",m_minEnergyHEModel=12*GeV,
00140                     "Minimum energy for high-energy model");
00141     declareProperty("MaxEnergyHEModel",m_maxEnergyHEModel=100*TeV,
00142                     "Maximum energy for high-energy model");
00143     declareProperty("LEPUpperLimit",m_lepUpperLimit=25*GeV,
00144                     "Low-energy parametrized model upper limit.");
00145     declareProperty("LEPpnpiLimit",m_lepPnpiLimit=9.5*GeV,
00146                     "Low-energy parametrized model pnpi limit.");
00147     declareProperty("MinEnergyBinaryCascadePN",m_minEnergyBinaryCascadePN=65*MeV,
00148                     "Minimum energy for p,n low energy binary cascade");
00149     declareProperty("MaxEnergyBinaryCascadePN",m_maxEnergyBinaryCascadePN=9.9*GeV,
00150                     "Maximum energy for p,n low energy binary cascade");
00151     declareProperty("MinEnergyBinaryCascadePi",m_minEnergyBinaryCascadePi=0*GeV,
00152                     "Minimum energy for pion low energy binary cascade");
00153     declareProperty("MaxEnergyBinaryCascadePi",m_maxEnergyBinaryCascadePi=9.9*GeV,
00154                     "Maximum energy for pion low energy binary cascade");
00155     declareProperty("NeutronElasticEnergyBoundary",m_neutronElasticEnergyBoundary=20*MeV,
00156                     "Energy boundary between simple low energy and "
00157                     "precision high energy elastic models");
00158     declareProperty("NeutronInelasticEnergyBoundary",m_neutronInlasticEnergyBoundary=20*MeV,
00159                     "Energy boundary between simple low energy and "
00160                     "precision high energy inelastic models");
00161     declareProperty("FissionEnergyBoundary",m_fissionEnergyBoundary=20*MeV,
00162                     "Energy boundary between simple low energy and "
00163                     "precision high energy fission models");
00164     declareProperty("CaptureEnergyBoundary",m_captureEnergyBoundary=20*MeV,
00165                     "Energy boundary between simple low energy and "
00166                     "precision high energy capture models");
00167 
00168     m_capinfo = tool<INeutronCaptureInfo>("G4DhNeutronCaptureInfoTool");
00169     
00170 }
00171 
00172 DsPhysConsHadron::~DsPhysConsHadron()
00173 {
00174 }
00175 
00176 // Interface methods
00177 void DsPhysConsHadron::ConstructParticle()
00178 {
00179 }
00180 
00181 #include "G4Element.hh"
00182 static void dump_element_table()
00183 {
00184     const G4ElementTable *theElementTable = G4Element::GetElementTable();
00185     size_t numberOfElements = theElementTable->size();
00186     G4cerr << numberOfElements <<" elements:\n";
00187     for( size_t ind=0; ind<numberOfElements; ++ind ) {
00188         G4Element* elem = (*theElementTable)[ind];
00189         G4cerr << ind << ": " << elem->GetName() << " " << elem->GetZ() << "/" << elem->GetA() 
00190                << " " << elem->GetNumberOfIsotopes() << " isotopes"
00191                << "\n";
00192     }
00193     G4cerr << G4endl;
00194 }
00195 
00196 
00197 void DsPhysConsHadron::ConstructProcess()
00198 {
00199 
00200     // Hadronic Elastic Process and Model (the same for all hadrons except Neutron)
00201 
00202     G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess("LElastic");
00203     G4LElastic* theElasticModel = new G4LElastic();
00204     theElasticProcess->RegisterMe(theElasticModel);
00205 
00206 
00207     // evaporation logic for thermal nucleons
00208 
00209     G4Evaporation* theEvaporation;
00210     G4FermiBreakUp* theFermiBreakUp;
00211     G4StatMF* theMF;
00212     theEvaporation = new G4Evaporation();
00213     theFermiBreakUp = new G4FermiBreakUp();
00214     theMF = new G4StatMF();
00215 
00216     G4ExcitationHandler* theHandler;
00217     theHandler = new G4ExcitationHandler();
00218     theHandler->SetEvaporation(theEvaporation);
00219     theHandler->SetFermiModel(theFermiBreakUp);
00220     theHandler->SetMultiFragmentation(theMF);
00221     theHandler->SetMaxAandZForFermiBreakUp(12, 6);
00222     //theHandler->SetMinEForMultiFrag(3.*MeV);
00223     theHandler->SetMinEForMultiFrag(m_minEnergyForMultiFrag);
00224 
00225     // pre-equilibrium stage for proton
00226     G4PreCompoundModel* thePreEquilib;
00227     thePreEquilib = new G4PreCompoundModel(theHandler);
00228     //thePreEquilib->SetMaxEnergy(70*MeV);
00229     thePreEquilib->SetMaxEnergy(m_maxEnergyPreEquilProton);
00230 
00231     // pre-equilibrium stage for neutron
00232     G4PreCompoundModel* thePreEquilib2;
00233     thePreEquilib2 = new G4PreCompoundModel(theHandler);
00234     //thePreEquilib2->SetMinEnergy(20*MeV);
00235     thePreEquilib2->SetMinEnergy(m_minEnergyPreEquilNeutron);
00236     //thePreEquilib2->SetMaxEnergy(70*MeV);
00237     thePreEquilib2->SetMaxEnergy(m_maxEnergyPreEquilNeutron);
00238 
00239     // high energy model for proton, neutron, pions and kaons
00240     G4TheoFSGenerator* theHEModel = new G4TheoFSGenerator();
00241     G4GeneratorPrecompoundInterface* theCascade2 =
00242         new G4GeneratorPrecompoundInterface();
00243     theCascade2->SetDeExcitation(thePreEquilib);
00244     theHEModel->SetTransport(theCascade2);
00245     G4QGSMFragmentation* frag = new G4QGSMFragmentation();
00246     G4ExcitedStringDecay* stringDecay = new G4ExcitedStringDecay(frag);
00247     G4QGSModel<G4QGSParticipants>* stringModel =
00248         new G4QGSModel<G4QGSParticipants>();
00249     stringModel->SetFragmentationModel(stringDecay);
00250     theHEModel->SetHighEnergyGenerator(stringModel);
00251     //theHEModel->SetMinEnergy(12*GeV);
00252     theHEModel->SetMinEnergy(m_minEnergyHEModel);
00253     //theHEModel->SetMaxEnergy(100*TeV);
00254     theHEModel->SetMaxEnergy(m_maxEnergyHEModel);
00255 
00256     // Low energy parameterized models : use between 9.5 and 25 GeV for pions
00257     //G4double LEPUpperLimit = 25*GeV;
00258     G4double LEPUpperLimit = m_lepUpperLimit;
00259     //G4double LEPpnpiLimit = 9.5*GeV;
00260     G4double LEPpnpiLimit = m_lepPnpiLimit;
00261 
00262     // Binary cascade for p, n at low energy
00263     G4BinaryCascade* theCasc;
00264     theCasc = new G4BinaryCascade;
00265     //theCasc->SetMinEnergy(65*MeV);
00266     theCasc->SetMinEnergy(m_minEnergyBinaryCascadePN);
00267     theCasc->SetMaxEnergy(m_maxEnergyBinaryCascadePN);
00268 
00269     // Binary cascade crashes on pi. use Bertini instead
00270     G4CascadeInterface* bertiniModel = new G4CascadeInterface();
00271     //bertiniModel->SetMinEnergy(0.*GeV);
00272     bertiniModel->SetMinEnergy(m_minEnergyBinaryCascadePi);
00273     bertiniModel->SetMaxEnergy(m_maxEnergyBinaryCascadePi);
00274 
00275     G4ProcessManager * pmanager = 0;
00276 
00278     //               //
00279     //  pi+ physics  //
00280     //               //
00282 
00283     pmanager = G4PionPlus::PionPlus()->GetProcessManager();
00284 
00285     // hadron elastic
00286     pmanager->AddDiscreteProcess(theElasticProcess);
00287 
00288     // hadron inelastic
00289     G4PionPlusInelasticProcess* pipinelProc = new G4PionPlusInelasticProcess();
00290     G4PiNuclearCrossSection* pion_XC = new G4PiNuclearCrossSection();
00291     pipinelProc->AddDataSet(pion_XC);
00292 
00293     pipinelProc->RegisterMe(bertiniModel);
00294 
00295     G4LEPionPlusInelastic* LEPpipModel = new G4LEPionPlusInelastic();
00296     LEPpipModel->SetMinEnergy(LEPpnpiLimit);
00297     LEPpipModel->SetMaxEnergy(LEPUpperLimit);
00298 
00299     pipinelProc->RegisterMe(LEPpipModel);
00300     pipinelProc->RegisterMe(theHEModel);
00301   
00302     pmanager->AddDiscreteProcess(pipinelProc);
00303 
00305     //               //
00306     //  pi- physics  //
00307     //               //
00309 
00310     pmanager = G4PionMinus::PionMinus()->GetProcessManager();
00311 
00312     // hadron elastic
00313     pmanager->AddDiscreteProcess(theElasticProcess);
00314 
00315     // hadron inelastic
00316     G4PionMinusInelasticProcess* piminelProc = new G4PionMinusInelasticProcess();
00317 
00318     piminelProc->AddDataSet(pion_XC);
00319 
00320     piminelProc->RegisterMe(bertiniModel);
00321 
00322     G4LEPionMinusInelastic* LEPpimModel = new G4LEPionMinusInelastic();
00323     LEPpimModel->SetMinEnergy(LEPpnpiLimit);
00324     LEPpimModel->SetMaxEnergy(LEPUpperLimit);
00325       
00326     piminelProc->RegisterMe(LEPpimModel);
00327     piminelProc->RegisterMe(theHEModel);
00328 
00329     pmanager->AddDiscreteProcess(piminelProc);
00330 
00331     // pi- absorption at rest
00332     G4PionMinusAbsorptionAtRest* pimAbsorb = new G4PionMinusAbsorptionAtRest();
00333     pmanager->AddRestProcess(pimAbsorb);
00334 
00336     //               //
00337     //  K+ physics   //
00338     //               //
00340 
00341     pmanager = G4KaonPlus::KaonPlus()->GetProcessManager();
00342 
00343     // hadron elastic
00344     pmanager->AddDiscreteProcess(theElasticProcess);
00345 
00346 
00347     // hadron inelastic
00348     G4KaonPlusInelasticProcess* kpinelProc = new G4KaonPlusInelasticProcess();
00349     G4LEKaonPlusInelastic* LEPkpModel = new G4LEKaonPlusInelastic();
00350     LEPkpModel->SetMaxEnergy(LEPUpperLimit);
00351       
00352     kpinelProc->RegisterMe(LEPkpModel);
00353     kpinelProc->RegisterMe(theHEModel);
00354       
00355     pmanager->AddDiscreteProcess(kpinelProc);
00356 
00358     //               //
00359     //  K0S physics  //
00360     //               //
00362 
00363     pmanager = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
00364 
00365     // hadron elastic
00366     pmanager->AddDiscreteProcess(theElasticProcess);
00367 
00368     // hadron inelastic
00369     G4KaonZeroSInelasticProcess* k0SinelProc = new G4KaonZeroSInelasticProcess();
00370     G4LEKaonZeroSInelastic* LEPk0SModel = new G4LEKaonZeroSInelastic();
00371     LEPk0SModel->SetMaxEnergy(LEPUpperLimit);
00372 
00373     k0SinelProc->RegisterMe(LEPk0SModel);
00374     k0SinelProc->RegisterMe(theHEModel);
00375       
00376     pmanager->AddDiscreteProcess(k0SinelProc);
00377 
00379     //               //
00380     //  K0L physics  //
00381     //               //
00383 
00384     pmanager = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
00385 
00386     // hadron elastic
00387     pmanager->AddDiscreteProcess(theElasticProcess);
00388 
00389     // hadron inelastic
00390     G4KaonZeroLInelasticProcess* k0LinelProc = new G4KaonZeroLInelasticProcess();
00391     G4LEKaonZeroLInelastic* LEPk0LModel = new G4LEKaonZeroLInelastic();
00392     LEPk0LModel->SetMaxEnergy(LEPUpperLimit);
00393       
00394     k0LinelProc->RegisterMe(LEPk0LModel);
00395     k0LinelProc->RegisterMe(theHEModel);
00396       
00397     pmanager->AddDiscreteProcess(k0LinelProc);
00398 
00400     //               //
00401     //  K- physics   //
00402     //               //
00404 
00405     pmanager = G4KaonMinus::KaonMinus()->GetProcessManager();
00406 
00407     // hadron elastic
00408     pmanager->AddDiscreteProcess(theElasticProcess);
00409       
00410     // hadron inelastic
00411     G4KaonMinusInelasticProcess* kminelProc = new G4KaonMinusInelasticProcess();
00412     G4LEKaonMinusInelastic* LEPkmModel = new G4LEKaonMinusInelastic();
00413     LEPkmModel->SetMaxEnergy(LEPUpperLimit);
00414       
00415     kminelProc->RegisterMe(LEPkmModel);
00416     kminelProc->RegisterMe(theHEModel);
00417       
00418     pmanager->AddDiscreteProcess(kminelProc);
00419 
00420     // K- absorption at rest
00421     G4KaonMinusAbsorption* kmAbsorb = new G4KaonMinusAbsorption();
00422     pmanager->AddRestProcess(kmAbsorb);
00423   
00425     //               //
00426     //    Proton     //
00427     //               //
00429 
00430     pmanager = G4Proton::Proton()->GetProcessManager();
00431 
00432     // hadron elastic
00433     pmanager->AddDiscreteProcess(theElasticProcess);
00434 
00435     // hadron inelastic
00436     G4ProtonInelasticProcess* pinelProc = new G4ProtonInelasticProcess();
00437     G4ProtonInelasticCrossSection* proton_XC = 
00438         new G4ProtonInelasticCrossSection();
00439     pinelProc->AddDataSet(proton_XC);
00440 
00441     G4LEProtonInelastic* LEPpModel = new G4LEProtonInelastic();
00442     LEPpModel->SetMinEnergy(LEPpnpiLimit);
00443     LEPpModel->SetMaxEnergy(LEPUpperLimit);
00444 
00445     pinelProc->RegisterMe(thePreEquilib);
00446     pinelProc->RegisterMe(theCasc);
00447     pinelProc->RegisterMe(LEPpModel);
00448     pinelProc->RegisterMe(theHEModel);
00449 
00450     pmanager->AddDiscreteProcess(pinelProc);
00451 
00453     //               //
00454     //  Anti-Proton  //
00455     //               //
00457 
00458     pmanager = G4AntiProton::AntiProton()->GetProcessManager();
00459 
00460     // hadron elastic
00461     pmanager->AddDiscreteProcess(theElasticProcess);
00462 
00463     // hadron inelastic
00464     G4AntiProtonInelasticProcess* apinelProc = 
00465         new G4AntiProtonInelasticProcess();
00466     G4LEAntiProtonInelastic* LEPapModel = new G4LEAntiProtonInelastic(); 
00467     LEPapModel->SetMaxEnergy(LEPUpperLimit);
00468     apinelProc->RegisterMe(LEPapModel);
00469 
00470     G4HEAntiProtonInelastic* HEPapModel = new G4HEAntiProtonInelastic(); 
00471     HEPapModel->SetMinEnergy(LEPUpperLimit);
00472     apinelProc->RegisterMe(HEPapModel);
00473 
00474     pmanager->AddDiscreteProcess(apinelProc);
00475 
00476     // anti-proton annihilation at rest
00477     G4AntiProtonAnnihilationAtRest* apAnnihil = 
00478         new G4AntiProtonAnnihilationAtRest();
00479     pmanager->AddRestProcess(apAnnihil);
00480  
00482     //               //
00483     //    Neutron    //
00484     //               //
00486 
00487     pmanager = G4Neutron::Neutron()->GetProcessManager();
00488 
00489     // elastic scattering
00490     info () << "Creating neutron elastic processes" << endreq;
00491     G4UHadronElasticProcess* theHadronElasticProcess = new G4UHadronElasticProcess("neutronElastic");
00492     G4HadronElastic* theNeutronElasticModel = new G4HadronElastic();
00493     G4NeutronHPElastic* theNeutronHPElastic = new G4NeutronHPElastic();
00494     theNeutronHPElastic->SetMinEnergy(0.*MeV);
00495     //theNeutronHPElastic->SetMaxEnergy(20.*MeV);
00496     theNeutronHPElastic->SetMaxEnergy(m_neutronElasticEnergyBoundary);
00497 
00498     dump_element_table();
00499     G4NeutronHPElasticData* theHPElasticData = new G4NeutronHPElasticData();
00500     //theNeutronElasticModel->SetMinEnergy(20.*MeV);
00501     theNeutronElasticModel->SetMinEnergy(m_neutronElasticEnergyBoundary);
00502   
00503     theHadronElasticProcess->RegisterMe(theNeutronHPElastic);
00504     theHadronElasticProcess->AddDataSet(theHPElasticData);
00505     theHadronElasticProcess->RegisterMe(theNeutronElasticModel);
00506 
00507     pmanager->AddDiscreteProcess(theHadronElasticProcess);
00508 
00509       
00510     // inelastic scattering
00511     G4NeutronInelasticProcess* ninelProc = new G4NeutronInelasticProcess();
00512     G4NeutronInelasticCrossSection* neutron_XC = 
00513         new G4NeutronInelasticCrossSection();
00514     ninelProc->AddDataSet(neutron_XC);
00515   
00516     G4NeutronHPInelastic* theNeutronHPInelastic = new G4NeutronHPInelastic();
00517     //theNeutronHPInelastic->SetMaxEnergy(20.*MeV );
00518     theNeutronHPInelastic->SetMaxEnergy(m_neutronInlasticEnergyBoundary);
00519     G4NeutronHPInelasticData* theHPInelasticData = new G4NeutronHPInelasticData();
00520 
00521     G4LENeutronInelastic* LEPnModel = new G4LENeutronInelastic();
00522     LEPnModel->SetMinEnergy(LEPpnpiLimit);
00523     LEPnModel->SetMaxEnergy(LEPUpperLimit);
00524 
00525     ninelProc->RegisterMe(theNeutronHPInelastic);
00526     ninelProc->AddDataSet(theHPInelasticData);
00527     ninelProc->RegisterMe(thePreEquilib2);
00528     ninelProc->RegisterMe(theCasc);
00529     ninelProc->RegisterMe(LEPnModel);
00530     ninelProc->RegisterMe(theHEModel);
00531 
00532     pmanager->AddDiscreteProcess(ninelProc);
00533 
00534     // fission process 
00535     G4HadronFissionProcess* theHadronFissionProcess = new G4HadronFissionProcess();
00536     G4LFission* theNeutronLFission = new G4LFission();
00537     G4NeutronHPFission* theNeutronHPFission  = new   G4NeutronHPFission();
00538     //theNeutronHPFission->SetMaxEnergy( 20.*MeV );
00539     theNeutronHPFission->SetMaxEnergy(m_fissionEnergyBoundary);
00540     //theNeutronLFission->SetMinEnergy( 20.*MeV );
00541     theNeutronLFission->SetMinEnergy(m_fissionEnergyBoundary);
00542     theHadronFissionProcess->RegisterMe( theNeutronHPFission );
00543     theHadronFissionProcess->RegisterMe( theNeutronLFission );
00544     //AddDataSet(theHadronFissionProcess, new G4NeutronHPFissionData() );
00545     theHadronFissionProcess->AddDataSet(new G4NeutronHPFissionData());
00546     pmanager->AddDiscreteProcess(theHadronFissionProcess);
00547       
00548     // capture  
00549     info() << "Creating DsG4NeutronHPCapture" << endreq;
00550     G4HadronCaptureProcess* theNeutronCaptureProcess = new G4HadronCaptureProcess();
00551     G4LCapture* theNeutronLCapture = new G4LCapture();
00552 
00553     DsG4NeutronHPCapture* theNeutronHPCapture = new DsG4NeutronHPCapture();
00554 
00555     theNeutronHPCapture->passNeutronCaptureInfoTool(m_capinfo);
00556 
00557     //theNeutronHPCapture->SetMaxEnergy( 20.*MeV );
00558     theNeutronHPCapture->SetMaxEnergy(m_captureEnergyBoundary);
00559     //theNeutronLCapture->SetMinEnergy( 20.*MeV );
00560 
00561     theNeutronLCapture->SetMinEnergy(m_captureEnergyBoundary);
00562     theNeutronCaptureProcess->RegisterMe( theNeutronHPCapture );
00563     theNeutronCaptureProcess->RegisterMe( theNeutronLCapture );
00564     //AddDataSet(theNeutronCaptureProcess, new G4NeutronHPCaptureData());
00565     theNeutronCaptureProcess->AddDataSet(new G4NeutronHPCaptureData());
00566     pmanager->AddDiscreteProcess(theNeutronCaptureProcess);
00567 
00569     //               //
00570     // Anti-Neutron  //
00571     //               //
00573 
00574     pmanager = G4AntiNeutron::AntiNeutron()->GetProcessManager();
00575 
00576     // hadron elastic
00577     pmanager->AddDiscreteProcess(theElasticProcess);
00578 
00579     // hadron inelastic
00580     G4AntiNeutronInelasticProcess* aninelProc = 
00581         new G4AntiNeutronInelasticProcess();
00582     G4LEAntiNeutronInelastic* LEPanModel = new G4LEAntiNeutronInelastic();
00583     LEPanModel->SetMaxEnergy(LEPUpperLimit); 
00584     aninelProc->RegisterMe(LEPanModel);
00585     G4HEAntiNeutronInelastic* HEPanModel = new G4HEAntiNeutronInelastic();
00586     HEPanModel->SetMinEnergy(LEPUpperLimit);
00587     aninelProc->RegisterMe(HEPanModel);
00588     pmanager->AddDiscreteProcess(aninelProc);
00589 
00590     // anti-neutron annihilation at rest
00591     G4AntiNeutronAnnihilationAtRest* anAnnihil = 
00592         new G4AntiNeutronAnnihilationAtRest();
00593     pmanager->AddRestProcess(anAnnihil);
00594 
00596     //               //
00597     //    Lambda     //
00598     //               //
00600 
00601     pmanager = G4Lambda::Lambda()->GetProcessManager();
00602 
00603     // hadron elastic
00604     pmanager->AddDiscreteProcess(theElasticProcess);
00605 
00606     // hadron inelastic
00607     G4LambdaInelasticProcess* linelProc = 
00608         new G4LambdaInelasticProcess();
00609     G4LELambdaInelastic* LEPlModel = new G4LELambdaInelastic();
00610     LEPlModel->SetMaxEnergy(LEPUpperLimit); 
00611     linelProc->RegisterMe(LEPlModel);
00612     G4HELambdaInelastic* HEPlModel = new G4HELambdaInelastic(); 
00613     HEPlModel->SetMinEnergy(LEPUpperLimit);
00614     linelProc->RegisterMe(HEPlModel);
00615   
00616     pmanager->AddDiscreteProcess(linelProc);
00617 
00619     //               //
00620     //  Anti-Lambda  //
00621     //               //
00623 
00624     pmanager = G4AntiLambda::AntiLambda()->GetProcessManager();
00625 
00626     // hadron elastic
00627     pmanager->AddDiscreteProcess(theElasticProcess);
00628 
00629     // hadron inelastic
00630     G4AntiLambdaInelasticProcess* alinelProc = 
00631         new G4AntiLambdaInelasticProcess();
00632     G4LEAntiLambdaInelastic* LEPalModel = new G4LEAntiLambdaInelastic();
00633     LEPalModel->SetMaxEnergy(LEPUpperLimit); 
00634     alinelProc->RegisterMe(LEPalModel);
00635     G4HEAntiLambdaInelastic* HEPalModel = new G4HEAntiLambdaInelastic(); 
00636     HEPalModel->SetMinEnergy(LEPUpperLimit);
00637     alinelProc->RegisterMe(HEPalModel);
00638 
00639     pmanager->AddDiscreteProcess(alinelProc);
00640 
00642     //               //
00643     //    Sigma+     //
00644     //               //
00646 
00647     pmanager = G4SigmaPlus::SigmaPlus()->GetProcessManager();
00648 
00649     // hadron elastic
00650     pmanager->AddDiscreteProcess(theElasticProcess);
00651 
00652     // hadron inelastic
00653     G4SigmaPlusInelasticProcess* spinelProc = new G4SigmaPlusInelasticProcess();
00654     G4LESigmaPlusInelastic* LEPspModel = new G4LESigmaPlusInelastic();
00655     LEPspModel->SetMaxEnergy(LEPUpperLimit);
00656     spinelProc->RegisterMe(LEPspModel);
00657     G4HESigmaPlusInelastic* HEPspModel = new G4HESigmaPlusInelastic(); 
00658     HEPspModel->SetMinEnergy(LEPUpperLimit);
00659     spinelProc->RegisterMe(HEPspModel);
00660       
00661     pmanager->AddDiscreteProcess(spinelProc);
00662 
00664     //               //
00665     //    Sigma-     //
00666     //               //
00668 
00669     pmanager = G4SigmaMinus::SigmaMinus()->GetProcessManager();
00670 
00671     // hadron elastic
00672     pmanager->AddDiscreteProcess(theElasticProcess);
00673 
00674     // hadron inelastic
00675     G4SigmaMinusInelasticProcess* sminelProc = 
00676         new G4SigmaMinusInelasticProcess();
00677     G4LESigmaMinusInelastic* LEPsmModel = new G4LESigmaMinusInelastic(); 
00678     LEPsmModel->SetMaxEnergy(LEPUpperLimit);
00679     sminelProc->RegisterMe(LEPsmModel);
00680     G4HESigmaMinusInelastic* HEPsmModel = new G4HESigmaMinusInelastic(); 
00681     HEPsmModel->SetMinEnergy(LEPUpperLimit);
00682     sminelProc->RegisterMe(HEPsmModel);
00683       
00684     pmanager->AddDiscreteProcess(sminelProc);
00685 
00687     //               //
00688     //  Anti-Sigma+  //
00689     //               //
00691 
00692     pmanager = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
00693 
00694     // hadron elastic
00695     pmanager->AddDiscreteProcess(theElasticProcess);
00696 
00697     // hadron inelastic
00698     G4AntiSigmaPlusInelasticProcess* aspinelProc = 
00699         new G4AntiSigmaPlusInelasticProcess();
00700     G4LEAntiSigmaPlusInelastic* LEPaspModel = 
00701         new G4LEAntiSigmaPlusInelastic(); 
00702     LEPaspModel->SetMaxEnergy(LEPUpperLimit);
00703     aspinelProc->RegisterMe(LEPaspModel);
00704     G4HEAntiSigmaPlusInelastic* HEPaspModel = 
00705         new G4HEAntiSigmaPlusInelastic(); 
00706     HEPaspModel->SetMinEnergy(LEPUpperLimit);
00707     aspinelProc->RegisterMe(HEPaspModel);
00708     pmanager->AddDiscreteProcess(aspinelProc);
00709 
00711     //               //
00712     //  Anti-Sigma-  //
00713     //               //
00715 
00716     pmanager = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
00717 
00718     // hadron elastic
00719     pmanager->AddDiscreteProcess(theElasticProcess);
00720       
00721     // hadron inelastic
00722     G4AntiSigmaMinusInelasticProcess* asminelProc = 
00723         new G4AntiSigmaMinusInelasticProcess();
00724     G4LEAntiSigmaMinusInelastic* LEPasmModel = 
00725         new G4LEAntiSigmaMinusInelastic(); 
00726     LEPasmModel->SetMaxEnergy(LEPUpperLimit);
00727     asminelProc->RegisterMe(LEPasmModel);
00728     G4HEAntiSigmaMinusInelastic* HEPasmModel = 
00729         new G4HEAntiSigmaMinusInelastic(); 
00730     HEPasmModel->SetMinEnergy(LEPUpperLimit);
00731     asminelProc->RegisterMe(HEPasmModel);
00732 
00733     pmanager->AddDiscreteProcess(asminelProc);
00734 
00736     //               //
00737     //      Xi0      //
00738     //               //
00740 
00741     pmanager = G4XiZero::XiZero()->GetProcessManager();
00742 
00743     // hadron elastic
00744     pmanager->AddDiscreteProcess(theElasticProcess);
00745 
00746     // hadron inelastic
00747     G4XiZeroInelasticProcess* x0inelProc = new G4XiZeroInelasticProcess();
00748     G4LEXiZeroInelastic* LEPx0Model = new G4LEXiZeroInelastic();
00749     LEPx0Model->SetMaxEnergy(LEPUpperLimit); 
00750     x0inelProc->RegisterMe(LEPx0Model);
00751     G4HEXiZeroInelastic* HEPx0Model = new G4HEXiZeroInelastic(); 
00752     HEPx0Model->SetMinEnergy(LEPUpperLimit);
00753     x0inelProc->RegisterMe(HEPx0Model);
00754 
00755     pmanager->AddDiscreteProcess(x0inelProc);
00756 
00758     //               //
00759     //      Xi-      //
00760     //               //
00762 
00763     pmanager = G4XiMinus::XiMinus()->GetProcessManager();
00764 
00765     // hadron elastic
00766     pmanager->AddDiscreteProcess(theElasticProcess);
00767 
00768     // hadron inelastic
00769     G4XiMinusInelasticProcess* xminelProc = new G4XiMinusInelasticProcess();
00770     G4LEXiMinusInelastic* LEPxmModel = new G4LEXiMinusInelastic(); 
00771     LEPxmModel->SetMaxEnergy(LEPUpperLimit);
00772     xminelProc->RegisterMe(LEPxmModel);
00773     G4HEXiMinusInelastic* HEPxmModel = new G4HEXiMinusInelastic();
00774     HEPxmModel->SetMinEnergy(LEPUpperLimit);
00775     xminelProc->RegisterMe(HEPxmModel);
00776       
00777     pmanager->AddDiscreteProcess(xminelProc);
00778 
00780     //               //
00781     //   Anti-Xi0    //
00782     //               //
00784 
00785     pmanager = G4AntiXiZero::AntiXiZero()->GetProcessManager();
00786 
00787     // hadron elastic
00788     pmanager->AddDiscreteProcess(theElasticProcess);
00789 
00790     // hadron inelastic
00791     G4AntiXiZeroInelasticProcess* ax0inelProc = 
00792         new G4AntiXiZeroInelasticProcess();
00793     G4LEAntiXiZeroInelastic* LEPax0Model = new G4LEAntiXiZeroInelastic();
00794     LEPax0Model->SetMaxEnergy(LEPUpperLimit); 
00795     ax0inelProc->RegisterMe(LEPax0Model);
00796     G4HEAntiXiZeroInelastic* HEPax0Model = new G4HEAntiXiZeroInelastic(); 
00797     HEPax0Model->SetMinEnergy(LEPUpperLimit);
00798     ax0inelProc->RegisterMe(HEPax0Model);
00799 
00800     pmanager->AddDiscreteProcess(ax0inelProc);
00801 
00803     //               //
00804     //   Anti-Xi-    //
00805     //               //
00807 
00808     pmanager = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
00809 
00810     // hadron elastic
00811     pmanager->AddDiscreteProcess(theElasticProcess);
00812 
00813     // hadron inelastic
00814     G4AntiXiMinusInelasticProcess* axminelProc = 
00815         new G4AntiXiMinusInelasticProcess();
00816     G4LEAntiXiMinusInelastic* LEPaxmModel = new G4LEAntiXiMinusInelastic();
00817     LEPaxmModel->SetMaxEnergy(LEPUpperLimit);
00818     axminelProc->RegisterMe(LEPaxmModel);
00819     G4HEAntiXiMinusInelastic* HEPaxmModel = new G4HEAntiXiMinusInelastic();
00820     HEPaxmModel->SetMinEnergy(LEPUpperLimit);
00821     axminelProc->RegisterMe(HEPaxmModel);
00822 
00823     pmanager->AddDiscreteProcess(axminelProc);
00824 
00826     //               //
00827     //    Omega-     //
00828     //               //
00830 
00831     pmanager = G4OmegaMinus::OmegaMinus()->GetProcessManager();
00832 
00833     // hadron elastic
00834     pmanager->AddDiscreteProcess(theElasticProcess);
00835 
00836     // hadron inelastic
00837     G4OmegaMinusInelasticProcess* ominelProc = 
00838         new G4OmegaMinusInelasticProcess();
00839     G4LEOmegaMinusInelastic* LEPomModel = new G4LEOmegaMinusInelastic();
00840     LEPomModel->SetMaxEnergy(LEPUpperLimit); 
00841     ominelProc->RegisterMe(LEPomModel);
00842     G4HEOmegaMinusInelastic* HEPomModel = new G4HEOmegaMinusInelastic();
00843     HEPomModel->SetMinEnergy(LEPUpperLimit);
00844     ominelProc->RegisterMe(HEPomModel);
00845       
00846     pmanager->AddDiscreteProcess(ominelProc);
00847 
00849     //               //
00850     //  Anti-Omega-  //
00851     //               //
00853 
00854     pmanager = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
00855 
00856     // hadron elastic
00857     pmanager->AddDiscreteProcess(theElasticProcess);
00858 
00859     // hadron inelastic
00860     G4AntiOmegaMinusInelasticProcess* aominelProc = 
00861         new G4AntiOmegaMinusInelasticProcess();
00862     G4LEAntiOmegaMinusInelastic* LEPaomModel = 
00863         new G4LEAntiOmegaMinusInelastic();
00864     LEPaomModel->SetMaxEnergy(LEPUpperLimit);
00865     aominelProc->RegisterMe(LEPaomModel);
00866     G4HEAntiOmegaMinusInelastic* HEPaomModel = 
00867         new G4HEAntiOmegaMinusInelastic(); 
00868     HEPaomModel->SetMinEnergy(LEPUpperLimit);
00869     aominelProc->RegisterMe(HEPaomModel);
00870 
00871     pmanager->AddDiscreteProcess(aominelProc);
00872 
00873 }
00874
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |
Generated on Mon Apr 11 20:53:24 2011 for DetSim by doxygen 1.4.7