LArBarrelPresamplerCalculator Class Reference

#include <LArBarrelPresamplerCalculator.h>

Inheritance diagram for LArBarrelPresamplerCalculator:

Collaboration diagram for LArBarrelPresamplerCalculator:

Public Member Functions
	LArBarrelPresamplerCalculator (const std::string &name, ISvcLocator *pSvcLocator)
	LArBarrelPresamplerCalculator (const LArBarrelPresamplerCalculator &)=delete
LArBarrelPresamplerCalculator &	operator= (const LArBarrelPresamplerCalculator &)=delete
virtual StatusCode	initialize () override final
virtual StatusCode	finalize () override final
virtual G4float	OOTcut () const override final
virtual G4bool	Process (const G4Step *a_step, std::vector< LArHitData > &hdata) const override final
virtual G4bool	isInTime (G4double hitTime) const override final
virtual void	initializeForSDCreation () override

Protected Attributes
Gaudi::Property< bool >	m_BirksLaw {this, "BirksLaw", true}
Gaudi::Property< double >	m_Birksk {this, "Birksk", 0.05832}
Gaudi::Property< double >	m_OOTcut {this, "OOTcut", 300*CLHEP::ns}

Private Attributes
ServiceHandle< ILArBarrelPresamplerGeometry >	m_geometry {this, "GeometryCalculator", "LArBarrelPresamplerGeometry"}
Gaudi::Property< bool >	m_IflCur {this, "IflCur", true}
Gaudi::Property< std::string >	m_detectorName {this, "DetectorName", "LArMgr"}
Gaudi::Property< bool >	m_testbeam {this, "isTestbeam", false}
const PsMap *	m_psmap {nullptr}
const LArG4BirksLaw *	m_birksLaw {nullptr}
G4String	m_volname {"LArMgr::LAr::Barrel::Presampler"}

Detailed Description

Definition at line 25 of file LArBarrelPresamplerCalculator.h.

Constructor & Destructor Documentation

LArBarrelPresamplerCalculator() [1/2]

LArBarrelPresamplerCalculator::LArBarrelPresamplerCalculator	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 41 of file LArBarrelPresamplerCalculator.cxx.

 : LArCalculatorSvcImp(name, pSvcLocator)
{
}

LArBarrelPresamplerCalculator() [2/2]

LArBarrelPresamplerCalculator::LArBarrelPresamplerCalculator ( const LArBarrelPresamplerCalculator & )

delete

Member Function Documentation

finalize()

StatusCode LArBarrelPresamplerCalculator::finalize ( )

finaloverridevirtual

Definition at line 86 of file LArBarrelPresamplerCalculator.cxx.

{
  if (m_BirksLaw)   delete m_birksLaw;
  return StatusCode::SUCCESS;
}

initialize()

StatusCode LArBarrelPresamplerCalculator::initialize ( )

finaloverridevirtual

Definition at line 46 of file LArBarrelPresamplerCalculator.cxx.

{
  ATH_MSG_DEBUG("LArBarrelPresamplerCalculator: Beginning initialization ");
  // Initialize private members.
 
  // Access source of detector parameters.
  const LArVG4DetectorParameters* parameters = LArVG4DetectorParameters::GetInstance();
 
  // Initialize the geometry calculator
  ATH_CHECK(m_geometry.retrieve());
 
  if (m_IflCur)
    {
      ATH_MSG_DEBUG(" LArBarrelPresamplerCalculator: start reading current maps");
      m_psmap = PsMap::GetPsMap();
    }
 
  // Get the out-of-time cut from the detector parameters routine.
  m_OOTcut = parameters->GetValue("LArExpHallOutOfTimeCut"); //FIXME should be done by configurables
 
  if (m_BirksLaw)
    {
      const double Birks_LAr_density = 1.396;
      m_birksLaw = new LArG4BirksLaw(Birks_LAr_density,m_Birksk);
      ATH_MSG_INFO("Use Birks_LAr_density="<<Birks_LAr_density<<", Birksk="<<(double)m_Birksk);
    }
  else
    {
      ATH_MSG_DEBUG(" LArBarrelPresamplerCalculator: Birks' law OFF");
    }
 
  if(m_detectorName.empty()) m_volname="LAr::Barrel::Presampler";
  else m_volname=m_detectorName+"::LAr::Barrel::Presampler";
 
  ATH_MSG_DEBUG("End of LArBarrelPresamplerCalculator initialization ");
 
  return StatusCode::SUCCESS;
}

initializeForSDCreation()

virtual void LArCalculatorSvcImp::initializeForSDCreation ( )

inlineoverridevirtualinherited

Reimplemented in LArBarrelCalculator, and LArHECWheelCalculator.

Definition at line 19 of file LArCalculatorSvcImp.h.

{};

isInTime()

virtual G4bool LArBarrelPresamplerCalculator::isInTime ( G4double hitTime ) const

inlinefinaloverridevirtual

Definition at line 43 of file LArBarrelPresamplerCalculator.h.

  {
    return !(std::fabs(hitTime) > m_OOTcut);
  }

OOTcut()

virtual G4float LArBarrelPresamplerCalculator::OOTcut ( ) const

inlinefinaloverridevirtual

Definition at line 38 of file LArBarrelPresamplerCalculator.h.

{ return m_OOTcut; }

operator=()

LArBarrelPresamplerCalculator & LArBarrelPresamplerCalculator::operator= ( const LArBarrelPresamplerCalculator & )

delete

Process()

G4bool LArBarrelPresamplerCalculator::Process ( const G4Step * a_step, std::vector< LArHitData > & hdata ) const

finaloverridevirtual

Definition at line 93 of file LArBarrelPresamplerCalculator.cxx.

{
  hdata.clear();
  LArG4Identifier identifier2;
 
  //  check the Step content is non trivial
  G4double thisStepEnergyDeposit = a_step->GetTotalEnergyDeposit() * a_step->GetTrack()->GetWeight();
  G4double thisStepLength = a_step->GetStepLength() / Units::mm;
  G4double dstep = .1*Units::mm;   // length of punctual charge for Current Option
 
#ifdef  DEBUGSTEP
  ATH_MSG_DEBUG( "******  LArBarrelPresamplerCalculator:  Step energy,length "
            << thisStepEnergyDeposit << " " << thisStepLength);
#endif
  if(thisStepEnergyDeposit <= 0. || thisStepLength <= 0.)
    {
      return false;
    }
 
  // Get Step geometrical parameters (first and end)
  G4StepPoint *thisStepPoint = a_step->GetPreStepPoint();
  G4StepPoint *thisStepBackPoint = a_step->GetPostStepPoint();
  G4ThreeVector startPoint = thisStepPoint->GetPosition();
  G4ThreeVector endPoint = thisStepBackPoint->GetPosition();
 
#ifdef  DEBUGSTEP
  ATH_MSG_DEBUG("   Global beginning step position "
            << startPoint.x() << " " << startPoint.y() << " "
            << startPoint.z());
  ATH_MSG_DEBUG("   Global end       step position "
            << endPoint.x() << " " << endPoint.y() << " "
            << endPoint.z());
#endif
 
 
  // find transformation to go inside local half presampler tube volume
 
  const G4NavigationHistory* g4navigation = thisStepPoint->GetTouchable()->GetHistory();
  G4int ndep = g4navigation->GetDepth();
  G4int idep = -999;
 
#ifdef DEBUGSTEP
  ATH_MSG_DEBUG(" Detector Name " << m_detectorName);
#endif
 
    const G4String presamplerName((m_detectorName.empty()) ? "LAr::Barrel::Presampler" :
                                  m_detectorName+"::LAr::Barrel::Presampler");
    for (G4int ii=0;ii<=ndep;ii++) {
      G4VPhysicalVolume* v1 = g4navigation->GetVolume(ii);
#ifdef DEBUGSTEP
      ATH_MSG_DEBUG(" Level,VolumeName " << ii << " " << v1->GetName());
#endif
      // FIXME More efficient to find the comparison volume once and compare pointers?
      if (v1->GetName()==presamplerName) idep=ii;
    }
 
#ifdef DEBUGSTEP
  ATH_MSG_DEBUG(" idep = " << idep);
#endif
 
  if (idep<0) {
     ATH_MSG_WARNING(" LArBarrelPresamplerCalculator::Process  Presampler volume not found !!");
     return false;
  }
 
  // transformation to go from global frame to LAr::Barrel::Presampler frame
  const G4AffineTransform transformation = g4navigation->GetTransform(idep);
 
  // step beginning and end in local frame
  G4ThreeVector startPointinLocal =
    transformation.TransformPoint(startPoint);
  G4ThreeVector   endPointinLocal =
    transformation.TransformPoint  (endPoint);
 
#ifdef  DEBUGSTEP
  ATH_MSG_DEBUG("   Local beginning step position "
            << startPointinLocal.x() << " " << startPointinLocal.y() << " "
            << startPointinLocal.z());
  ATH_MSG_DEBUG("   Local end       step position "
            << endPointinLocal.x() << " " << endPointinLocal.y() << " "
            << endPointinLocal.z());
#endif
 
  // compute number of sub steps
  //   = 1 if no charge collection
  //   otherwise 200 microns (dstep) division
 
  G4int nsub_step=1;
  if (m_IflCur) nsub_step=(int) (thisStepLength*(1./dstep)) + 1;
  // delta is fraction of step between two sub steps
  G4double delta=1./((double) nsub_step);
#ifdef DEBUGSTEP
  ATH_MSG_DEBUG("   nsub_step,delta " << nsub_step << " " << delta);
#endif
 
  G4double energy = a_step->GetTotalEnergyDeposit() * a_step->GetTrack()->GetWeight();
  if (m_BirksLaw) {
     const double EField = 10. ; // 10 kV/cm electric field in presampler gap
     const double wholeStepLengthCm = a_step->GetStepLength() / CLHEP::cm;
     energy = (*m_birksLaw)(energy, wholeStepLengthCm, EField);
  }
 
  // loop over sub steps
 
 
  // share total step energy evenly in each sub step
  energy = energy / ((float) (nsub_step));
  for (G4int i=0;i<nsub_step;i++) {
 
#ifdef DEBUGSTEP
    ATH_MSG_DEBUG("   Energy for sub step " << energy);
#endif
 
    // position for this substep
    G4double fraction=(((G4double) i)+0.5)*delta;
    G4ThreeVector subinLocal=startPointinLocal*(1-fraction) + endPointinLocal*fraction;
    G4double xloc   = subinLocal.x();
    G4double yloc   = subinLocal.y();
    G4double zloc   = subinLocal.z();
    // call geometry method to find cell from local position
    //  status = true if hit is in  normal region (13mm LAr gap)
    //  this method fills the cell number as well as coordinates in the electrode frame
    LArG4::BarrelPresampler::CalcData currentCellData;
    bool status = m_geometry->findCell(currentCellData,xloc,yloc,zloc);
 
    // check fiducical cuts
    if (status) {
 
      // compute cell identifier
      G4int zSide;
      if (m_testbeam)
        zSide = 1;
      else
        zSide = ( startPoint.z() > 0.) ? 1 : -1;
 
      G4int region = currentCellData.region;
      G4int etaBin = currentCellData.etaBin;
      G4int phiBin = currentCellData.phiBin;
      G4int sampling = currentCellData.sampling;
 
      if( zSide == -1 )
        {
          // following code for an Y-axis rotation to define Z < 0. Barrel part
          phiBin = 31 - phiBin;
          if(phiBin < 0 ) phiBin += 64;
        }
 
      // check identifier
      if (sampling !=0 || region != 0 ||
          etaBin <0 || etaBin > 60 || phiBin <0 || phiBin>63) continue;
 
      // fill identifier
      identifier2.clear();
      identifier2 << 4          // LArCalorimeter
                  << 1          // LArEM
                  << zSide
                  << sampling
                  << region
                  << etaBin
                  << phiBin;
 
      // time computation is not necessarily correct for test beam
      G4double time;
      if (m_testbeam)
        {
          time=0.;
        }
      else
        {
          G4double tof;
          tof = thisStepPoint->GetGlobalTime() / Units::ns;
          time  = tof - thisStepPoint->GetPosition().mag() * (1. / (CLHEP::c_light * CLHEP::ns));
        }
 
      G4double Current;
      if (!m_IflCur)  {
        // no charge collection   Current=E from Geant
        Current=energy;
      }
      else  {
        // get module number and coordinates in electrode frame
        G4int imodule = currentCellData.module;
        G4double x0 = currentCellData.distElec;
        G4double y0 = currentCellData.xElec;
        // full symmetry for angle=0 electrodes
        if (imodule>1) {
          x0=std::fabs(x0);
          y0=std::fabs(y0);
        }
        // reduced symmetry (point symmetry around 0) for tilted electrodes
        if (imodule==0 || imodule ==1) {
          if (x0<0) {
            x0=-1.*x0;
            y0=-1.*y0;
          }
        }
#ifdef DEBUGSTEP
        ATH_MSG_DEBUG(" set current map for module " << imodule);
#endif
    const CurrMap* cm = m_psmap->GetMap(imodule);
        if (!cm) {
          ATH_MSG_WARNING(" LArBarrelPresamplerCalculator: cannot get map for module " << imodule);
          continue;
        }
        double current0,current1,current2,gap;
 
        // get information from current map
        cm->GetAll(x0,y0,&gap,&current0,&current1,&current2);
#ifdef DEBUGSTEP
        ATH_MSG_DEBUG(" module,x0,y0,current0 from map " << imodule << " " << x0 << " " << y0 << " " << current0);
#endif
 
        // assume HV=2000 everywhere for the time being
        Current = energy*current0;
 
      }
 
      // check if we have a new hit in a different cell, or if we add this substep
      //  to an already existing hit
      G4bool found=false;
      for (unsigned int j=0; j<hdata.size(); j++) {
        if (hdata[j].id==identifier2) {
          hdata[j].energy += Current;
          hdata[j].time += time*Current;
          found=true;
          break;
        }
      }    // loop over hits
      if (!found) {
        hdata.emplace_back(LArHitData{identifier2, time*Current, Current});
      }    // hit was not existing before
 
 
    }   // hit fulfills fiducial cuts
  }   // end loop over sub steps
 
#ifdef DEBUGSTEP
    ATH_MSG_DEBUG("Number of hits for this step " << m_nhits << " " << hdata.size());
#endif
 
  // finalise time computations
  for (unsigned int i=0;i<hdata.size();i++) {
    if (std::fabs(hdata[i].energy)>1e-6) hdata[i].time=hdata[i].time/hdata[i].energy;
    else hdata[i].time=0.;
#ifdef DEBUGSTEP
     ATH_MSG_DEBUG("Hit Energy/Time " << hdata[i].energy << " " << hdata[i].time);
#endif
  }
 
  if (!hdata.empty()) return true;
  else           return false;
 
}

Member Data Documentation

m_Birksk

Gaudi::Property<double> LArCalculatorSvcImp::m_Birksk {this, "Birksk", 0.05832}

protectedinherited

Definition at line 27 of file LArCalculatorSvcImp.h.

{this, "Birksk", 0.05832};

m_BirksLaw

Gaudi::Property<bool> LArCalculatorSvcImp::m_BirksLaw {this, "BirksLaw", true}

protectedinherited

Definition at line 23 of file LArCalculatorSvcImp.h.

{this, "BirksLaw", true};

m_birksLaw

const LArG4BirksLaw* LArBarrelPresamplerCalculator::m_birksLaw {nullptr}

private

Definition at line 61 of file LArBarrelPresamplerCalculator.h.

{nullptr};

m_detectorName

Gaudi::Property<std::string> LArBarrelPresamplerCalculator::m_detectorName {this, "DetectorName", "LArMgr"}

private

Definition at line 56 of file LArBarrelPresamplerCalculator.h.

{this, "DetectorName", "LArMgr"};

m_geometry

ServiceHandle<ILArBarrelPresamplerGeometry> LArBarrelPresamplerCalculator::m_geometry {this, "GeometryCalculator", "LArBarrelPresamplerGeometry"}

private

Definition at line 51 of file LArBarrelPresamplerCalculator.h.

{this, "GeometryCalculator", "LArBarrelPresamplerGeometry"};

m_IflCur

Gaudi::Property<bool> LArBarrelPresamplerCalculator::m_IflCur {this, "IflCur", true}

private

Definition at line 53 of file LArBarrelPresamplerCalculator.h.

{this, "IflCur", true};

m_OOTcut

Gaudi::Property<double> LArCalculatorSvcImp::m_OOTcut {this, "OOTcut", 300*CLHEP::ns}

protectedinherited

Definition at line 30 of file LArCalculatorSvcImp.h.

{this, "OOTcut", 300*CLHEP::ns};

m_psmap

const PsMap* LArBarrelPresamplerCalculator::m_psmap {nullptr}

private

Definition at line 60 of file LArBarrelPresamplerCalculator.h.

{nullptr};

m_testbeam

Gaudi::Property<bool> LArBarrelPresamplerCalculator::m_testbeam {this, "isTestbeam", false}

private

Definition at line 58 of file LArBarrelPresamplerCalculator.h.

{this, "isTestbeam", false};

m_volname

G4String LArBarrelPresamplerCalculator::m_volname {"LArMgr::LAr::Barrel::Presampler"}

private

Definition at line 62 of file LArBarrelPresamplerCalculator.h.

{"LArMgr::LAr::Barrel::Presampler"};

---

The documentation for this class was generated from the following files:

• LArBarrelPresamplerCalculator.h
• LArBarrelPresamplerCalculator.cxx