EndcapFastSimDedicatedSD Class Reference

NEEDS DOCUMENTATION. More...

#include <EndcapFastSimDedicatedSD.h>

Inheritance diagram for EndcapFastSimDedicatedSD:

Collaboration diagram for EndcapFastSimDedicatedSD:

Public Types
enum	LArHitTimeBins { HitTimeBinDefault = 0 , HitTimeBinUniform = 1 }

Public Member Functions
	EndcapFastSimDedicatedSD (StoreGateSvc *, std::string hitCollectionName, bool verbose)
	~EndcapFastSimDedicatedSD ()
	EndcapFastSimDedicatedSD (const EndcapFastSimDedicatedSD &)=delete
EndcapFastSimDedicatedSD &	operator= (const EndcapFastSimDedicatedSD &)=delete
void	ProcessSpot (const EnergySpot &spot, double weight) override final
	ProcessHitsMethod.
void	Initialize (G4HCofThisEvent *) override
	Register this regular SD with the event-owned builder.
G4bool	ProcessHits (G4Step *a_step, G4TouchableHistory *) override
	Main processing method.
G4bool	SimpleHit (const LArG4Identifier &lar_id, G4double time, G4double energy)
	First method translates to this - also for fast sims.
void	setupHelpers (const LArEM_ID *EM, const LArFCAL_ID *FCAL, const LArHEC_ID *HEC)
	Sets the ID helper pointers.
Identifier	ConvertID (const LArG4Identifier &a_ident) const
	Helper function for making "real" identifiers from LArG4Identifiers.

Protected Member Functions
G4int	getTimeBin (G4double time) const
	Helper method for time info.
LArHitContainerBuilder *	getHitContainer () const

Protected Attributes
ILArCalculatorSvc *	m_calculator
	Member variable - the calculator we'll use.
G4int	m_numberInvalidHits
	Count the number of invalid hits.
LArG4SimpleSD::LArHitTimeBins	m_timeBinType
G4float	m_timeBinWidth
	Width of the time bins for summing hits - for the uniform binning.
const LArEM_ID *	m_larEmID
	Pointers to the identifier helpers.
const LArFCAL_ID *	m_larFcalID
const LArHEC_ID *	m_larHecID

Private Member Functions
	FRIEND_TEST (LArG4SimpleSDtest, ProcessHits)
	FRIEND_TEST (LArG4SimpleSDtest, setupHelpers)
	FRIEND_TEST (LArG4SimpleSDtest, getTimeBin)
	FRIEND_TEST (LArG4SimpleSDtest, SimpleHit)
	FRIEND_TEST (LArG4SimpleSDtest, ConvertID)

Private Attributes
EMECDetectorManager *	m_emecManager
LArWheelCalculator *	m_innerWheelCalculatorPos
LArWheelCalculator *	m_innerWheelCalculatorNeg
LArWheelCalculator *	m_outerWheelCalculatorPos
LArWheelCalculator *	m_outerWheelCalculatorNeg
LArG4Identifier	m_larID
	My LAr identifier.
std::string	m_hitCollectionName
std::string	m_hitSourceName

Detailed Description

NEEDS DOCUMENTATION.

Definition at line 23 of file EndcapFastSimDedicatedSD.h.

Member Enumeration Documentation

LArHitTimeBins

enum LArG4SimpleSD::LArHitTimeBins

inherited

Enumerator
HitTimeBinDefault
HitTimeBinUniform

Definition at line 46 of file LArG4SimpleSD.h.

  {
      HitTimeBinDefault = 0,
      HitTimeBinUniform = 1
  };

Constructor & Destructor Documentation

EndcapFastSimDedicatedSD() [1/2]

EndcapFastSimDedicatedSD::EndcapFastSimDedicatedSD	(	StoreGateSvc *	detStore,
		std::string	hitCollectionName,
		bool	verbose )

Definition at line 38 of file EndcapFastSimDedicatedSD.cxx.

  : IFastSimDedicatedSD("EndcapFastSimDedicatedSD", detStore,
                        std::move(hitCollectionName))
  , m_emecManager(nullptr)
  , m_innerWheelCalculatorPos(nullptr)
  , m_innerWheelCalculatorNeg(nullptr)
  , m_outerWheelCalculatorPos(nullptr)
  , m_outerWheelCalculatorNeg(nullptr)
{
  if (verbose) { G4cout << GetName() << "::initialize()" << G4endl; }
  if ( detStore->retrieve( m_emecManager ).isFailure()  ){
    throw std::runtime_error("Could not retrieve EMEC manager");
  }
 
 
 
  ISvcLocator* svcLocator = Gaudi::svcLocator();
 
  // Access the GeoModelSvc:
  SmartIF<IGeoModelSvc> geoModel{svcLocator->service ("GeoModelSvc")};
  if ( !geoModel ) {
    G4Exception(
                "LArWheelSliceSolid", "AccessGeoModel", FatalException,
                "createSolid cannot access GeoModelSvc");
  }
 
  SmartIF<IGeoDbTagSvc> geoDbTagSvc{svcLocator->service ("GeoDbTagSvc")};
  if ( !geoDbTagSvc ) {
    G4Exception(
                "LArWheelSliceSolid", "AccessDbTagSvc", FatalException,
                "createSolid cannot access DbTagSvc");
  }
 
  // Access the geometry database:
  SmartIF<IRDBAccessSvc> pAccessSvc{svcLocator->service(geoDbTagSvc->getParamSvcName())};
  if ( !pAccessSvc ) {
    G4Exception(
                "LArWheelSliceSolid", "AccessAccessSvc", FatalException,
                "createSolid cannot access AccessSvc");
  }
 
  DecodeVersionKey larVersionKey(geoModel, "LAr");
  EMECData emecData=toEMECData(pAccessSvc,larVersionKey);
 
 
 
  m_innerWheelCalculatorPos = new LArWheelCalculator(emecData,LArG4::InnerAbsorberWheel,+1);
  m_innerWheelCalculatorNeg = new LArWheelCalculator(emecData,LArG4::InnerAbsorberWheel,-1);
  m_outerWheelCalculatorPos = new LArWheelCalculator(emecData,LArG4::OuterAbsorberWheel,+1);
  m_outerWheelCalculatorNeg = new LArWheelCalculator(emecData,LArG4::OuterAbsorberWheel,-1);
}

~EndcapFastSimDedicatedSD()

EndcapFastSimDedicatedSD::~EndcapFastSimDedicatedSD ( )

inline

Definition at line 33 of file EndcapFastSimDedicatedSD.h.

{}

EndcapFastSimDedicatedSD() [2/2]

EndcapFastSimDedicatedSD::EndcapFastSimDedicatedSD ( const EndcapFastSimDedicatedSD & )

delete

Member Function Documentation

ConvertID()

Identifier LArG4SimpleSD::ConvertID ( const LArG4Identifier & a_ident ) const

inherited

Helper function for making "real" identifiers from LArG4Identifiers.

FRIEND_TEST() [1/5]

LArG4SimpleSD::FRIEND_TEST ( LArG4SimpleSDtest , ConvertID  )

privateinherited

FRIEND_TEST() [2/5]

LArG4SimpleSD::FRIEND_TEST ( LArG4SimpleSDtest , getTimeBin  )

privateinherited

FRIEND_TEST() [3/5]

LArG4SimpleSD::FRIEND_TEST ( LArG4SimpleSDtest , ProcessHits  )

privateinherited

FRIEND_TEST() [4/5]

LArG4SimpleSD::FRIEND_TEST ( LArG4SimpleSDtest , setupHelpers  )

privateinherited

FRIEND_TEST() [5/5]

LArG4SimpleSD::FRIEND_TEST ( LArG4SimpleSDtest , SimpleHit  )

privateinherited

getHitContainer()

LArHitContainerBuilder * LArG4SimpleSD::getHitContainer ( ) const

protectedinherited

getTimeBin()

G4int LArG4SimpleSD::getTimeBin ( G4double time ) const

protectedinherited

Helper method for time info.

Initialize()

void LArG4SimpleSD::Initialize ( G4HCofThisEvent * )

overrideinherited

Register this regular SD with the event-owned builder.

operator=()

EndcapFastSimDedicatedSD & EndcapFastSimDedicatedSD::operator= ( const EndcapFastSimDedicatedSD & )

delete

ProcessHits()

G4bool LArG4SimpleSD::ProcessHits ( G4Step * a_step, G4TouchableHistory *  )

overrideinherited

Main processing method.

ProcessSpot()

void EndcapFastSimDedicatedSD::ProcessSpot ( const EnergySpot & spot, double weight )

finaloverridevirtual

ProcessHitsMethod.

Process a single energy spot from a frozen shower. The appropriate region of the sensitive detector is calculated and a LArIdentifier is constructed

Implements IFastSimDedicatedSD.

Definition at line 93 of file EndcapFastSimDedicatedSD.cxx.

                                                                                 {
 
  // Fill the identifier.
  Point3D<double> globalPosition=spot.GetPosition();
 
  static const Transform3D xfPos = Amg::EigenTransformToCLHEP(m_emecManager->getDetectorRegion(1,1,0,0)->getAbsoluteTransform().inverse());
  static const Transform3D xfNeg = Amg::EigenTransformToCLHEP(m_emecManager->getDetectorRegion(0,1,0,0)->getAbsoluteTransform().inverse());
 
 
  Point3D<double> localPosition        = globalPosition.z()<0 ? xfNeg*globalPosition : xfPos*globalPosition;
  Point3D<double> shiftedLocalPosition = localPosition + Point3D<double>(0.0,0.0,m_emecManager->getFocalToRef()+m_emecManager->getRefToActive());
  int zIndex = globalPosition.z()<0 ? 0:1;
  double eta = shiftedLocalPosition.getEta();
  double phi = localPosition.getPhi();
  double z   = localPosition.z();
 
  EMECDetectorManager::DetectorRegionConstIterator e;
  for (e=m_emecManager->beginDetectorRegion();e!=m_emecManager->endDetectorRegion();  ++e) {
    const EMECDetectorRegion *region = *e;
    if (region->getEndcapIndex()!=zIndex) continue;
    const EMECDetDescr       *regionDescriptor=region->getDescriptor();
    const CellBinning       & etaBinning=regionDescriptor->getEtaBinning();
    if (eta>etaBinning.getStart() && eta<etaBinning.getEnd()) {
 
      unsigned int etaIndex = int((eta - etaBinning.getStart())/etaBinning.getDelta()) + etaBinning.getFirstDivisionNumber();
      unsigned int phiIndex = 0;
      EMECCellConstLink cellPtr = region->getEMECCell(etaIndex,phiIndex);
      double zmax = cellPtr->getZLocal(EMECCell::BACK);
      double zmin = cellPtr->getZLocal(EMECCell::FRONT);
      if (z>zmin && z<zmax) {
        const CellBinning       & phiBinning=regionDescriptor->getPhiBinning();
        double minPhi=std::min(phiBinning.getStart(), phiBinning.getEnd());
        double maxPhi=std::max(phiBinning.getStart(), phiBinning.getEnd());
        while (phi<minPhi)   phi += 2*M_PI;
        while (phi>maxPhi)   phi -= 2*M_PI;
 
        unsigned int regionIndex = region->getRegionIndex();
        unsigned int samplingIndex = region->getSamplingIndex();
        //unsigned int phiIndex      =  int((phi - phiBinning.getStart())/phiBinning.getDelta()) + phiBinning.getFirstDivisionNumber();
        int wheel  = region->getRadialIndex()==0 ? 2:3;
        int sWheel = zIndex==0 ? -wheel: wheel;
 
        // But now we are more sophisticated...:
 
        LArWheelCalculator *wheelCalc=nullptr;
        int nGaps= region->getRadialIndex()==0 ? 768:256;
        int nBins= phiBinning.getNumDivisions();
        int gapsPerBin = nGaps/nBins;
 
 
        if      (zIndex==0 && region->getRadialIndex()==0) {
          wheelCalc=const_cast<LArWheelCalculator *> (m_outerWheelCalculatorNeg);
        }
        else if (zIndex==0 && region->getRadialIndex()==1){
          wheelCalc=const_cast<LArWheelCalculator *> (m_innerWheelCalculatorPos);
        }
        else if (zIndex==1 && region->getRadialIndex()==0){
          wheelCalc=const_cast<LArWheelCalculator *>(m_outerWheelCalculatorNeg);
        }
        else if (zIndex==1 && region->getRadialIndex()==1){
          wheelCalc=const_cast<LArWheelCalculator *> (m_innerWheelCalculatorPos);
        }
        else {
          throw std::runtime_error("Error, unknown wheel in EndcapFastSimDedicatedSD");
        }
 
        int phiBin = wheelCalc->GetPhiGap(localPosition)/gapsPerBin;
 
        if (zIndex==0) {
          phiBin = (nBins-2)/2 - phiBin;
          if(phiBin < 0) {
            phiBin += nBins;
          }
        }
 
        //std::cout << didIt <<  "Compare phi gap: " << nGaps << ' ' << nBins << ' ' << gapsPerBin << ':' << phiBin <<  '/' << phiIndex << std::endl;
 
        //static LArG4Identifier id;
        m_larID.clear();
        m_larID        << 4          // LArCalorimeter
                       << 1          // LArEM
                       << sWheel
                       << samplingIndex
                       << regionIndex
                       << etaIndex
                       << phiBin;
        // call process to add this to the collection 
        SimpleHit(m_larID, spot.GetTime(), spot.GetEnergy()*weight);
        return;
      }
    }
  }
 
 
}

setupHelpers()

void LArG4SimpleSD::setupHelpers ( const LArEM_ID * EM, const LArFCAL_ID * FCAL, const LArHEC_ID * HEC )

inlineinherited

Sets the ID helper pointers.

Definition at line 75 of file LArG4SimpleSD.h.

                                            {
    m_larEmID = EM;
    m_larFcalID = FCAL;
    m_larHecID = HEC;
  }

SimpleHit()

G4bool LArG4SimpleSD::SimpleHit ( const LArG4Identifier & lar_id, G4double time, G4double energy )

inherited

First method translates to this - also for fast sims.

Member Data Documentation

m_calculator

ILArCalculatorSvc* LArG4SimpleSD::m_calculator

protectedinherited

Member variable - the calculator we'll use.

Definition at line 91 of file LArG4SimpleSD.h.

m_emecManager

EMECDetectorManager* EndcapFastSimDedicatedSD::m_emecManager

private

Definition at line 43 of file EndcapFastSimDedicatedSD.h.

m_hitCollectionName

std::string LArG4SimpleSD::m_hitCollectionName

privateinherited

Definition at line 122 of file LArG4SimpleSD.h.

m_hitSourceName

std::string LArG4SimpleSD::m_hitSourceName

privateinherited

Definition at line 123 of file LArG4SimpleSD.h.

m_innerWheelCalculatorNeg

LArWheelCalculator* EndcapFastSimDedicatedSD::m_innerWheelCalculatorNeg

private

Definition at line 45 of file EndcapFastSimDedicatedSD.h.

m_innerWheelCalculatorPos

LArWheelCalculator* EndcapFastSimDedicatedSD::m_innerWheelCalculatorPos

private

Definition at line 44 of file EndcapFastSimDedicatedSD.h.

m_larEmID

const LArEM_ID* LArG4SimpleSD::m_larEmID

protectedinherited

Pointers to the identifier helpers.

Definition at line 115 of file LArG4SimpleSD.h.

m_larFcalID

const LArFCAL_ID* LArG4SimpleSD::m_larFcalID

protectedinherited

Definition at line 116 of file LArG4SimpleSD.h.

m_larHecID

const LArHEC_ID* LArG4SimpleSD::m_larHecID

protectedinherited

Definition at line 117 of file LArG4SimpleSD.h.

m_larID

LArG4Identifier EndcapFastSimDedicatedSD::m_larID

private

My LAr identifier.

Definition at line 50 of file EndcapFastSimDedicatedSD.h.

m_numberInvalidHits

G4int LArG4SimpleSD::m_numberInvalidHits

protectedinherited

Count the number of invalid hits.

Definition at line 94 of file LArG4SimpleSD.h.

m_outerWheelCalculatorNeg

LArWheelCalculator* EndcapFastSimDedicatedSD::m_outerWheelCalculatorNeg

private

Definition at line 47 of file EndcapFastSimDedicatedSD.h.

m_outerWheelCalculatorPos

LArWheelCalculator* EndcapFastSimDedicatedSD::m_outerWheelCalculatorPos

private

Definition at line 46 of file EndcapFastSimDedicatedSD.h.

m_timeBinType

LArG4SimpleSD::LArHitTimeBins LArG4SimpleSD::m_timeBinType

protectedinherited

Definition at line 109 of file LArG4SimpleSD.h.

m_timeBinWidth

G4float LArG4SimpleSD::m_timeBinWidth

protectedinherited

Width of the time bins for summing hits - for the uniform binning.

Definition at line 112 of file LArG4SimpleSD.h.

---

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

• EndcapFastSimDedicatedSD.h
• EndcapFastSimDedicatedSD.cxx