#include "IonizationAndScintillation.h"

Public Member Functions
void	Reset (const G4Step *step)

double	EnergyDeposit () const

double	VisibleEnergyDeposit () const

double	NumberIonizationElectrons () const

double	NumberScintillationPhotons () const

double	StepSizeLimit () const

Static Public Member Functions
static IonizationAndScintillation *	CreateInstance (detinfo::DetectorPropertiesData const &detProp, CLHEP::HepRandomEngine &engine)

static IonizationAndScintillation *	Instance ()

Private Member Functions
	IonizationAndScintillation (detinfo::DetectorPropertiesData const &detProp, CLHEP::HepRandomEngine &engine)

Private Attributes
std::unique_ptr< larg4::ISCalculation >	fISCalc

std::string	fISCalculator
	name of calculator to use, NEST or Separate More...

G4Step const *	fStep {nullptr}
	pointer to the current G4 step More...

int	fStepNumber {-1}
	last StepNumber checked More...

int	fTrkID {-1}
	last TrkID checked More...

TH1F *	fElectronsPerStep {nullptr}
	histogram of electrons per step More...

TH1F *	fStepSize {nullptr}
	histogram of the step sizes More...

TH1F *	fPhotonsPerStep {nullptr}
	histogram of the photons per step More...

TH1F *	fEnergyPerStep {nullptr}
	histogram of the energy deposited per step More...

TH1F *	fElectronsPerLength
	histogram of electrons per cm More...

TH1F *	fPhotonsPerLength
	histogram of photons per cm More...

TH1F *	fElectronsPerEDep
	histogram of electrons per MeV deposited More...

TH1F *	fPhotonsPerEDep
	histogram of photons per MeV deposited More...

TH2F *	fElectronsVsPhotons {nullptr}
	histogram of electrons vs photons per step More...

CLHEP::HepRandomEngine &	fEngine
	random engine (needed for NEST) More...

Detailed Description

Definition at line 31 of file IonizationAndScintillation.h.

Constructor & Destructor Documentation

larg4::IonizationAndScintillation::IonizationAndScintillation	(	detinfo::DetectorPropertiesData const &	detProp,
		CLHEP::HepRandomEngine &	engine
	)

private

Definition at line 52 of file IonizationAndScintillation.cxx.

References fElectronsPerEDep, fElectronsPerLength, fElectronsPerStep, fElectronsVsPhotons, fEnergyPerStep, fEngine, fISCalc, fISCalculator, fPhotonsPerEDep, fPhotonsPerLength, fPhotonsPerStep, fStepNumber, fStepSize, fTrkID, and sim::LArG4Parameters::IonAndScintCalculator().

Referenced by CreateInstance().

     : fEngine{engine}
   {
     art::ServiceHandle<sim::LArG4Parameters const> lgp;
     fISCalculator = lgp->IonAndScintCalculator();
 
     if (fISCalculator == "Separate")
       fISCalc = std::make_unique<larg4::ISCalculationSeparate>();
     else if (fISCalculator == "Correlated")
       fISCalc = std::make_unique<larg4::ISCalculationCorrelated>(detProp);
     else if (fISCalculator == "NEST")
       fISCalc = std::make_unique<larg4::ISCalculationNEST>(fEngine);
     else
       mf::LogWarning("IonizationAndScintillation") << "No ISCalculation set, this can't be good.";
 
     // Reset the values for the electrons, photons, and energy to 0
     // in the calculator
     fISCalc->Reset();
     //set the current track and step number values to bogus so that it will run the first reset:
     fStepNumber = -1;
     fTrkID = -1;
 
     // make the histograms
     art::ServiceHandle<art::TFileService const> tfs;
     fElectronsPerStep = tfs->make<TH1F>("electronsPerStep", ";Electrons;Steps", 500, 0., 5000.);
     fPhotonsPerStep = tfs->make<TH1F>("photonsPerStep", ";Photons;Steps", 500, 0., 5000.);
     fEnergyPerStep = tfs->make<TH1F>("energyPerStep", ";Energy (MeV);Steps", 100, 0., 0.5);
     fStepSize = tfs->make<TH1F>("stepSize", ";Step Size (CLHEP::cm);Steps", 500, 0., 0.2);
     fElectronsPerLength = tfs->make<TH1F>(
       "electronsPerLength", ";Electrons #times 10^{3}/CLHEP::cm;Steps", 1000, 0., 1000.);
     fPhotonsPerLength = tfs->make<TH1F>(
       "photonsPerLength", ";Photons #times 10^{3}/CLHEP::cm;Steps", 1000, 0., 1000.);
     fElectronsPerEDep =
       tfs->make<TH1F>("electronsPerEDep", ";Electrons #times 10^{3}/MeV;Steps", 1000, 0., 1000.);
     fPhotonsPerEDep =
       tfs->make<TH1F>("photonsPerEDep", ";Photons #times 10^{3}/MeV;Steps", 1000, 0., 1000.);
 
     fElectronsVsPhotons =
       tfs->make<TH2F>("electronsVsPhotons", ";Photons;Electrons", 500, 0., 5000., 500, 0., 5000.);
   }

Member Function Documentation

IonizationAndScintillation * larg4::IonizationAndScintillation::CreateInstance	(	detinfo::DetectorPropertiesData const &	detProp,
		CLHEP::HepRandomEngine &	engine
	)

static

Definition at line 34 of file IonizationAndScintillation.cxx.

References larg4::gInstance, and IonizationAndScintillation().

Referenced by larg4::LArG4::beginJob().

   {
     if (!gInstance) gInstance = new IonizationAndScintillation(detProp, engine);
     return gInstance;
   }

double larg4::IonizationAndScintillation::EnergyDeposit ( ) const

inline

Definition at line 42 of file IonizationAndScintillation.h.

Referenced by larg4::LArVoxelReadout::DriftIonizationElectrons().

42 { return fISCalc->EnergyDeposit(); }

larg4::IonizationAndScintillation::fISCalc

std::unique_ptr< larg4::ISCalculation > fISCalc

Definition: IonizationAndScintillation.h:53

IonizationAndScintillation * larg4::IonizationAndScintillation::Instance ( )

static

Definition at line 43 of file IonizationAndScintillation.cxx.

References larg4::gInstance.

Referenced by larg4::LArVoxelReadout::DriftIonizationElectrons(), larg4::LArVoxelReadoutGeometry::LArVoxelReadoutGeometry(), larg4::OpFastScintillation::PostStepDoIt(), larg4::LArVoxelReadout::ProcessHits(), larg4::OpFastScintillation::RecordPhotonsProduced(), and larg4::IonizationAndScintillationAction::SteppingAction().

   {
     // the instance must have been created already by CreateInstance()
     assert(gInstance);
     return gInstance;
   }

double larg4::IonizationAndScintillation::NumberIonizationElectrons ( ) const

inline

Definition at line 44 of file IonizationAndScintillation.h.

Referenced by larg4::LArVoxelReadout::DriftIonizationElectrons().

44 { return fISCalc->NumberIonizationElectrons(); }

larg4::IonizationAndScintillation::fISCalc

std::unique_ptr< larg4::ISCalculation > fISCalc

Definition: IonizationAndScintillation.h:53

double larg4::IonizationAndScintillation::NumberScintillationPhotons ( ) const

inline

Definition at line 45 of file IonizationAndScintillation.h.

Referenced by larg4::OpFastScintillation::PostStepDoIt().

45 { return fISCalc->NumberScintillationPhotons(); }

larg4::IonizationAndScintillation::fISCalc

std::unique_ptr< larg4::ISCalculation > fISCalc

Definition: IonizationAndScintillation.h:53

void larg4::IonizationAndScintillation::Reset ( const G4Step * step )

Definition at line 96 of file IonizationAndScintillation.cxx.

References fElectronsPerEDep, fElectronsPerLength, fElectronsPerStep, fElectronsVsPhotons, fEnergyPerStep, fISCalc, fPhotonsPerEDep, fPhotonsPerLength, fPhotonsPerStep, fStep, fStepNumber, fStepSize, fTrkID, and MF_LOG_DEBUG.

Referenced by larg4::OpFastScintillation::PostStepDoIt(), larg4::LArVoxelReadout::ProcessHits(), and larg4::IonizationAndScintillationAction::SteppingAction().

   {
 
     if (fStepNumber == step->GetTrack()->GetCurrentStepNumber() &&
         fTrkID == step->GetTrack()->GetTrackID())
       return;
 
     fStepNumber = step->GetTrack()->GetCurrentStepNumber();
     fTrkID = step->GetTrack()->GetTrackID();
 
     fStep = step;
 
     fISCalc->Reset();
 
     // check the material for this step and be sure it is LAr
     if (step->GetTrack()->GetMaterial()->GetName() != "LAr") return;
 
     // double check that the energy deposit is non-zero
     // then do the calculation if it is
     if (step->GetTotalEnergyDeposit() > 0) {
 
       fISCalc->CalculateIonizationAndScintillation(fStep);
 
       MF_LOG_DEBUG("IonizationAndScintillation")
         << "Step Size: " << fStep->GetStepLength() / CLHEP::cm
         << "\nEnergy: " << fISCalc->EnergyDeposit()
         << "\nElectrons: " << fISCalc->NumberIonizationElectrons()
         << "\nPhotons: " << fISCalc->NumberScintillationPhotons();
 
       G4ThreeVector totstep = fStep->GetPostStepPoint()->GetPosition();
       totstep -= fStep->GetPreStepPoint()->GetPosition();
 
       // Fill the histograms
       fStepSize->Fill(totstep.mag() / CLHEP::cm);
       fEnergyPerStep->Fill(fISCalc->EnergyDeposit());
       fElectronsPerStep->Fill(fISCalc->NumberIonizationElectrons());
       fPhotonsPerStep->Fill(fISCalc->NumberScintillationPhotons());
       fElectronsVsPhotons->Fill(fISCalc->NumberScintillationPhotons(),
                                 fISCalc->NumberIonizationElectrons());
       double const stepSize = totstep.mag() / CLHEP::cm;
       if (stepSize > 0.0) {
         fElectronsPerLength->Fill(fISCalc->NumberIonizationElectrons() * 1.e-3 / stepSize);
         fPhotonsPerLength->Fill(fISCalc->NumberScintillationPhotons() * 1.e-3 / stepSize);
       }
       double const energyDep = fISCalc->EnergyDeposit();
       if (energyDep) {
         fElectronsPerEDep->Fill(fISCalc->NumberIonizationElectrons() * 1.e-3 / energyDep);
         fPhotonsPerEDep->Fill(fISCalc->NumberScintillationPhotons() * 1.e-3 / energyDep);
       }
 
     } // end if the energy deposition is non-zero
 
     return;
   }