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

In This Package:

DsPhysConsHadron Class Reference

Hadron production physics. More...

#include <DsPhysConsHadron.h>

Inheritance diagram for DsPhysConsHadron:

[legend]
Collaboration diagram for DsPhysConsHadron:
[legend]
List of all members.

Public Types

 SUCCESS
 NO_INTERFACE
 VERSMISMATCH
 LAST_ERROR
enum  Status
enum  Status
enum  Status

Public Member Functions

 DsPhysConsHadron (const std::string &type, const std::string &name, const IInterface *parent)
virtual ~DsPhysConsHadron ()
void ConstructParticle ()
void ConstructProcess ()
virtual StatusCode initialize ()
virtual StatusCode finalize ()
virtual G4VPhysicsConstructor * physicsConstructor () const
virtual unsigned long release ()
StatusCode release (const IInterface *interface) const
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvInterface)=0
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvInterface)=0
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvInterface)=0
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvUnknown)
virtual unsigned long addRef ()=0
virtual unsigned long addRef ()=0
virtual unsigned long addRef ()=0
virtual unsigned long addRef ()
virtual const std::string & type () const =0
virtual const std::string & type () const
virtual const IInterface * parent () const =0
virtual const IInterface * parent () const
virtual StatusCode configure ()=0
virtual StatusCode configure ()
virtual StatusCode start ()=0
virtual StatusCode start ()
virtual StatusCode stop ()=0
virtual StatusCode stop ()
virtual StatusCode terminate ()=0
virtual StatusCode terminate ()
virtual StatusCode reinitialize ()=0
virtual StatusCode reinitialize ()
virtual StatusCode restart ()=0
virtual StatusCode restart ()
virtual Gaudi::StateMachine::State FSMState () const =0
virtual Gaudi::StateMachine::State FSMState () const
virtual StatusCode sysInitialize ()=0
virtual StatusCode sysInitialize ()
virtual StatusCode sysStart ()=0
virtual StatusCode sysStart ()
virtual StatusCode sysStop ()=0
virtual StatusCode sysStop ()
virtual StatusCode sysFinalize ()=0
virtual StatusCode sysFinalize ()
virtual StatusCode sysReinitialize ()=0
virtual StatusCode sysReinitialize ()
virtual StatusCode sysRestart ()=0
virtual StatusCode sysRestart ()
virtual unsigned long refCount () const =0
virtual const std::string & name () const =0
virtual const std::string & name () const
virtual void handle (const Incident &i)
IGiGaSvc * gigaSvc () const
IGiGaSetUpSvc * setupSvc () const
INTupleSvc * ntupleSvc () const
INTupleSvc * evtColSvc () const
IDataProviderSvc * detSvc () const
IDataProviderSvc * evtSvc () const
IIncidentSvc * incSvc () const
IChronoStatSvc * chronoSvc () const
IHistogramSvc * histoSvc () const
IAlgContextSvc * contextSvc () const
DataObject * put (IDataProviderSvc *svc, DataObject *object, const std::string &address, const bool useRootInTES=true) const
DataObject * put (DataObject *object, const std::string &address, const bool useRootInTES=true) const
Gaudi::Utils::GetData< TYPE
>::return_type 		get (IDataProviderSvc *svc, const std::string &location, const bool useRootInTES=true) const
Gaudi::Utils::GetData< TYPE
>::return_type 		get (const std::string &location, const bool useRootInTES=true) const
TYPE * getDet (IDataProviderSvc *svc, const std::string &location) const
TYPE * getDet (const std::string &location) const
bool exist (IDataProviderSvc *svc, const std::string &location, const bool useRootInTES=true) const
bool exist (const std::string &location, const bool useRootInTES=true) const
bool existDet (IDataProviderSvc *svc, const std::string &location) const
bool existDet (const std::string &location) const
TYPE * getOrCreate (IDataProviderSvc *svc, const std::string &location, const bool useRootInTES=true) const
TYPE * getOrCreate (const std::string &location, const bool useRootInTES=true) const
TOOL * tool (const std::string &type, const std::string &name, const IInterface *parent=0, bool create=true) const
TOOL * tool (const std::string &type, const IInterface *parent=0, bool create=true) const
SERVICE * svc (const std::string &name, const bool create=true) const
IUpdateManagerSvc * updMgrSvc () const
IDataProviderSvc * fastContainersSvc () const
StatusCode Error (const std::string &msg, const StatusCode st=StatusCode::FAILURE, const size_t mx=10) const
StatusCode Warning (const std::string &msg, const StatusCode st=StatusCode::FAILURE, const size_t mx=10) const
StatusCode Print (const std::string &msg, const StatusCode st=StatusCode::SUCCESS, const MSG::Level lev=MSG::INFO) const
StatusCode Assert (const bool ok, const std::string &message="", const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
StatusCode Assert (const bool ok, const char *message, const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
StatusCode Exception (const std::string &msg, const GaudiException &exc, const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
StatusCode Exception (const std::string &msg, const std::exception &exc, const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
StatusCode Exception (const std::string &msg="no message", const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
MsgStream & msgStream (const MSG::Level level) const
MsgStream & always () const
MsgStream & fatal () const
MsgStream & err () const
MsgStream & error () const
MsgStream & warning () const
MsgStream & info () const
MsgStream & debug () const
MsgStream & verbose () const
MsgStream & msg () const
const Statistics & counters () const
StatEntity & counter (const std::string &tag) const
MSG::Level msgLevel () const
bool msgLevel (const MSG::Level level) const
void resetMsgStream () const
bool typePrint () const
bool propsPrint () const
bool statPrint () const
bool errorsPrint () const
long printStat (const MSG::Level level=MSG::ALWAYS) const
long printErrors (const MSG::Level level=MSG::ALWAYS) const
long printProps (const MSG::Level level=MSG::ALWAYS) const
void registerCondition (const std::string &condition, StatusCode(CallerClass::*mf)()=NULL)
void registerCondition (const std::string &condition, CondType *&condPtrDest, StatusCode(CallerClass::*mf)()=NULL)
void registerCondition (char *condition, StatusCode(CallerClass::*mf)()=NULL)
void registerCondition (TargetClass *condition, StatusCode(CallerClass::*mf)()=NULL)
StatusCode runUpdate ()
TransientFastContainer< T > * getFastContainer (const std::string &location, typename TransientFastContainer< T >::size_type initial=0)
const std::string & context () const
const std::string & rootInTES () const
double globalTimeOffset () const
virtual Gaudi::StateMachine::State targetFSMState () const
virtual StatusCode setProperty (const Property &p)
virtual StatusCode setProperty (const std::string &s)
virtual StatusCode setProperty (const std::string &n, const std::string &v)
StatusCode setProperty (const std::string &name, const TYPE &value)
virtual StatusCode getProperty (Property *p) const
virtual const Property & getProperty (const std::string &name) const
virtual StatusCode getProperty (const std::string &n, std::string &v) const
virtual const std::vector<
Property * > & 		getProperties () const
PropertyMgr * getPropertyMgr ()
ISvcLocator * serviceLocator () const
ISvcLocator * svcLoc () const
IMessageSvc * msgSvc () const
IToolSvc * toolSvc () const
StatusCode setProperties ()
StatusCode service (const std::string &name, T *&svc, bool createIf=true) const
StatusCode service (const std::string &type, const std::string &name, T *&svc) const
void declInterface (const InterfaceID &, void *)
Property * declareProperty (const std::string &name, T &property, const std::string &doc="none") const
Property * declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="") const
IAuditorSvc * auditorSvc () const
IMonitorSvc * monitorSvc () const
void declareInfo (const std::string &name, const T &var, const std::string &desc) const
void declareInfo (const std::string &name, const std::string &format, const void *var, int size, const std::string &desc) const

Static Public Member Functions

static const InterfaceID & interfaceID ()
static const InterfaceID & interfaceID ()
static const InterfaceID & interfaceID ()

Public Attributes

 SUCCESS
 NO_INTERFACE
 VERSMISMATCH
 LAST_ERROR

Protected Types

typedef std::map< std::string,
StatEntity > 		Statistics
typedef std::map< std::string,
unsigned int > 		Counter
typedef std::vector< IAlgTool * > AlgTools
typedef std::pair< IInterface *,
std::string > 		ServiceEntry
typedef std::vector< ServiceEntry > Services

Protected Member Functions

virtual unsigned long refCount () const
StatusCode releaseTool (const IAlgTool *tool) const
StatusCode releaseSvc (const IInterface *svc) const
int outputLevel () const
IntegerProperty & outputLevelProperty ()
void initOutputLevel (Property &prop)

Static Protected Attributes

static const bool IgnoreRootInTES
static const bool UseRootInTES

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.
INeutronCaptureInfo * m_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 126 of file DsPhysConsHadron.cc.

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 }

DsPhysConsHadron::~DsPhysConsHadron (  )  [virtual]

Definition at line 172 of file DsPhysConsHadron.cc.

00173 {
00174 }

Member Function Documentation

void DsPhysConsHadron::ConstructParticle (  ) 

Definition at line 177 of file DsPhysConsHadron.cc.

00178 {
00179 }

void DsPhysConsHadron::ConstructProcess (  ) 

Definition at line 197 of file DsPhysConsHadron.cc.

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 }

Member Data Documentation

double DsPhysConsHadron::m_minEnergyForMultiFrag [private]

MinEnergyForMultiFrag: Minimum energy for multi-fragmentation.

Definition at line 42 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_maxEnergyPreEquilProton [private]

MaxEnergyPreEquilProton: Maximum energy for pre-equilibrium proton.

Definition at line 46 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_minEnergyPreEquilNeutron [private]

MinEnergyPreEquilNeutron: Minimum energy for pre-equilibrium neutron.

Definition at line 50 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_maxEnergyPreEquilNeutron [private]

MaxEnergyPreEquilNeutron: Maximum energy for pre-equilibrium neutron.

Definition at line 54 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_minEnergyHEModel [private]

MinEnergyHEModel: Minimum energy for high-energy mode.

Definition at line 57 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_maxEnergyHEModel [private]

MaxEnergyHEModel: Maximum energy for high-energy mode.

Definition at line 60 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_lepUpperLimit [private]

LEPUpperLimit: Low-energy parametrized model upper limit.

Definition at line 63 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_lepPnpiLimit [private]

LEPpnpiLimit: Low-energy parametrized model pnpi limit.

Definition at line 66 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_minEnergyBinaryCascadePN [private]

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

Definition at line 70 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_maxEnergyBinaryCascadePN [private]

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

Definition at line 74 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_minEnergyBinaryCascadePi [private]

MinEnergyBinaryCascadePi: Minimum energy for pion low energy binary cascade.

Definition at line 78 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_maxEnergyBinaryCascadePi [private]

MaxEnergyBinaryCascadePi: Maximum energy for pion low energy binary cascade.

Definition at line 82 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_neutronElasticEnergyBoundary [private]

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

Definition at line 86 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_neutronInlasticEnergyBoundary [private]

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

Definition at line 90 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_fissionEnergyBoundary [private]

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

Definition at line 94 of file DsPhysConsHadron.h.

double DsPhysConsHadron::m_captureEnergyBoundary [private]

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

Definition at line 98 of file DsPhysConsHadron.h.

INeutronCaptureInfo* DsPhysConsHadron::m_capinfo [private]

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 Mon Apr 11 20:53:28 2011 for DetSim by doxygen 1.4.7