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

In This Package:

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