#include <ParametrisedEMPhysics.h>

Inheritance diagram for ParametrisedEMPhysics:

Public Member Functions
virtual void	ConstructParticle ()

virtual void	ConstructProcess ()

	ParametrisedEMPhysics (std::string name, const edm::ParameterSet &p)

virtual	~ParametrisedEMPhysics ()

Private Attributes
GFlashEMShowerModel *	theEcalEMShowerModel

GFlashHadronShowerModel *	theEcalHadShowerModel

ElectronLimiter *	theElectronLimiter

GFlashEMShowerModel *	theHcalEMShowerModel

GFlashHadronShowerModel *	theHcalHadShowerModel

edm::ParameterSet	theParSet

ElectronLimiter *	thePositronLimiter

Detailed Description

Definition at line 18 of file ParametrisedEMPhysics.h.

Constructor & Destructor Documentation

ParametrisedEMPhysics::ParametrisedEMPhysics	(	std::string	name,
		const edm::ParameterSet &	p
	)

Definition at line 43 of file ParametrisedEMPhysics.cc.

References theEcalEMShowerModel, theEcalHadShowerModel, theHcalEMShowerModel, and theHcalHadShowerModel.

   : G4VPhysicsConstructor(name), theParSet(p) 
 {
   theEcalEMShowerModel = 0;
   theEcalHadShowerModel = 0;
   theHcalEMShowerModel = 0;
   theHcalHadShowerModel = 0;
 }

ParametrisedEMPhysics::~ParametrisedEMPhysics ( )

virtual

Definition at line 53 of file ParametrisedEMPhysics.cc.

References theEcalEMShowerModel, theEcalHadShowerModel, theHcalEMShowerModel, and theHcalHadShowerModel.

                                               {
   delete theEcalEMShowerModel;
   delete theEcalHadShowerModel;
   delete theHcalEMShowerModel;
   delete theHcalHadShowerModel;
 }

Member Function Documentation

void ParametrisedEMPhysics::ConstructParticle ( )

virtual

Definition at line 60 of file ParametrisedEMPhysics.cc.

 {
   G4LeptonConstructor pLeptonConstructor;
   pLeptonConstructor.ConstructParticle();
 
   G4MesonConstructor pMesonConstructor;
   pMesonConstructor.ConstructParticle();
 
   G4BaryonConstructor pBaryonConstructor;
   pBaryonConstructor.ConstructParticle();
 
   G4ShortLivedConstructor pShortLivedConstructor;
   pShortLivedConstructor.ConstructParticle();  
     
   G4IonConstructor pConstructor;
   pConstructor.ConstructParticle();  
 }

void ParametrisedEMPhysics::ConstructProcess ( )

virtual

Definition at line 78 of file ParametrisedEMPhysics.cc.

References configurableAnalysis::Electron, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), GeV, i, MeV, ElectronLimiter::SetFieldCheckFlag(), ElectronLimiter::SetRangeCheckFlag(), theEcalEMShowerModel, theEcalHadShowerModel, theElectronLimiter, theHcalEMShowerModel, theHcalHadShowerModel, theParSet, and thePositronLimiter.

                                              {
 
   // GFlash part 
   bool gem  = theParSet.getParameter<bool>("GflashEcal");
   bool ghad = theParSet.getParameter<bool>("GflashHcal");
   bool gemHad  = theParSet.getParameter<bool>("GflashEcalHad");
   bool ghadHad = theParSet.getParameter<bool>("GflashHcalHad");
 
   G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
   if(gem || ghad || gemHad || ghadHad) {
     edm::LogInfo("SimG4CoreApplication") 
       << "ParametrisedEMPhysics: GFlash Construct for e+-: " 
       << gem << "  " << ghad << " for hadrons: " << gemHad << "  " << ghadHad;
 
     G4FastSimulationManagerProcess * theFastSimulationManagerProcess = 
       new G4FastSimulationManagerProcess();
 
     if(gem || ghad) {
       ph->RegisterProcess(theFastSimulationManagerProcess, G4Electron::Electron());
       ph->RegisterProcess(theFastSimulationManagerProcess, G4Positron::Positron());
     }
     if(gemHad || ghadHad) {
       ph->RegisterProcess(theFastSimulationManagerProcess, G4Proton::Proton());
       ph->RegisterProcess(theFastSimulationManagerProcess, G4AntiProton::AntiProton());
       ph->RegisterProcess(theFastSimulationManagerProcess, G4PionPlus::PionPlus());
       ph->RegisterProcess(theFastSimulationManagerProcess, G4PionMinus::PionMinus());
       ph->RegisterProcess(theFastSimulationManagerProcess, G4KaonPlus::KaonPlus());
       ph->RegisterProcess(theFastSimulationManagerProcess, G4KaonMinus::KaonMinus());
     }
 
     if(gem || gemHad) {
       G4Region* aRegion = 
     G4RegionStore::GetInstance()->GetRegion("EcalRegion");
       
       if(!aRegion){
     edm::LogInfo("SimG4CoreApplication") 
       << "ParametrisedEMPhysics::ConstructProcess: " 
       << "EcalRegion is not defined, GFlash will not be enabled for ECAL!";
     
       } else {
     if(gem) {
 
       //Electromagnetic Shower Model for ECAL
       theEcalEMShowerModel = 
         new GFlashEMShowerModel("GflashEcalEMShowerModel",aRegion,theParSet);
       //std::cout << "GFlash is defined for EcalRegion" << std::endl;
     }
     if(gemHad) {
 
       //Electromagnetic Shower Model for ECAL
       theEcalHadShowerModel = 
         new GFlashHadronShowerModel("GflashEcalHadShowerModel",aRegion,theParSet);
       //std::cout << "GFlash is defined for EcalRegion" << std::endl;
     }    
       }
     }
     if(ghad || ghadHad) {
       G4Region* aRegion = 
     G4RegionStore::GetInstance()->GetRegion("HcalRegion");
       if(!aRegion) {
     edm::LogInfo("SimG4CoreApplication") 
       << "ParametrisedEMPhysics::ConstructProcess: " 
       << "HcalRegion is not defined, GFlash will not be enabled for HCAL!";
     
       } else {
     if(ghad) {
 
       //Electromagnetic Shower Model for HCAL
       theHcalEMShowerModel = 
         new GFlashEMShowerModel("GflashHcalEMShowerModel",aRegion,theParSet);
       //std::cout << "GFlash is defined for HcalRegion" << std::endl;
     }
     if(ghadHad) {
 
       //Electromagnetic Shower Model for ECAL
       theHcalHadShowerModel = 
         new GFlashHadronShowerModel("GflashHcalHadShowerModel",aRegion,theParSet);
       //std::cout << "GFlash is defined for EcalRegion" << std::endl;
     }    
       }
     }
   }
   // bremsstrahlung threshold and EM verbosity
   G4EmProcessOptions opt;
   G4int verb = theParSet.getUntrackedParameter<int>("Verbosity",0);
   opt.SetVerbose(verb - 1);
 
   G4double bremth = theParSet.getParameter<double>("G4BremsstrahlungThreshold")*GeV; 
   edm::LogInfo("SimG4CoreApplication") 
     << "ParametrisedEMPhysics::ConstructProcess: bremsstrahlung threshold Eth= "
     << bremth/GeV << " GeV"; 
   opt.SetBremsstrahlungTh(bremth);
 
   // Russian roulette and tracking cut for e+-
   const G4int NREG = 6; 
   const G4String rname[NREG] = {"EcalRegion", "HcalRegion", "MuonIron",
                 "PreshowerRegion","CastorRegion",
                 "DefaultRegionForTheWorld"};
   G4double rrfact[NREG] = { 1.0 };
 
   double energyLim = 
     theParSet.getParameter<double>("RusRoElectronEnergyLimit")*MeV;
   if(energyLim > 0.0) {
     rrfact[0] = theParSet.getParameter<double>("RusRoEcalElectron");
     rrfact[1] = theParSet.getParameter<double>("RusRoHcalElectron");
     rrfact[2] = theParSet.getParameter<double>("RusRoMuonIronElectron");
     rrfact[3] = theParSet.getParameter<double>("RusRoPreShowerElectron");
     rrfact[4] = theParSet.getParameter<double>("RusRoCastorElectron");
     rrfact[5] = theParSet.getParameter<double>("RusRoWorldElectron");
     for(int i=0; i<NREG; ++i) {
       if(rrfact[i] < 1.0) {
     opt.ActivateSecondaryBiasing("eIoni",rname[i],rrfact[i],energyLim);
     opt.ActivateSecondaryBiasing("hIoni",rname[i],rrfact[i],energyLim);
     edm::LogInfo("SimG4CoreApplication") 
       << "ParametrisedEMPhysics: Russian Roulette"
       << " for e- Prob= " << rrfact[i]  
       << " Elimit(MeV)= " << energyLim/CLHEP::MeV
       << " inside " << rname[i];
       }
     }
   }
 
   // Step limiters for e+-
   bool eLimiter = theParSet.getParameter<bool>("ElectronStepLimit");
   bool rLimiter = theParSet.getParameter<bool>("ElectronRangeTest");
   bool pLimiter = theParSet.getParameter<bool>("PositronStepLimit");
 
   if(eLimiter || rLimiter) {
     theElectronLimiter = new ElectronLimiter(theParSet);
     theElectronLimiter->SetRangeCheckFlag(rLimiter);
     theElectronLimiter->SetFieldCheckFlag(eLimiter);
     ph->RegisterProcess(theElectronLimiter, G4Electron::Electron());
   }
   
   if(pLimiter){
     thePositronLimiter = new ElectronLimiter(theParSet);
     thePositronLimiter->SetFieldCheckFlag(pLimiter);
     ph->RegisterProcess(theElectronLimiter, G4Positron::Positron());
   }
   // enable fluorescence
   bool fluo = theParSet.getParameter<bool>("FlagFluo");
   if(fluo) {
     G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
     G4LossTableManager::Instance()->SetAtomDeexcitation(de);
     de->SetFluo(true);
   }
   // enable muon nuclear (valid option for Geant4 10.0pX only)
   bool munuc = theParSet.getParameter<bool>("FlagMuNucl");
   if(munuc) {
     G4MuonNuclearProcess* muNucProcess = new G4MuonNuclearProcess();
     muNucProcess->RegisterMe(new G4MuonVDNuclearModel());
     ph->RegisterProcess(muNucProcess, G4MuonPlus::MuonPlus());
     ph->RegisterProcess(muNucProcess, G4MuonMinus::MuonMinus());
   }
 
 }