#include <LArBarrelPresamplerGeometry.h>

Inheritance diagram for LArG4::BarrelPresampler::Geometry:

Collaboration diagram for LArG4::BarrelPresampler::Geometry:

Public Member Functions
	Geometry (const std::string &name, ISvcLocator *pSvcLocator)

virtual	~Geometry ()=default

virtual StatusCode	initialize () override final
	initialize geometry parameters this should at some stage be taken from a database... More...

virtual LArG4Identifier	CalculateIdentifier (const G4Step *) const override final
	The following method computes the identifiers in the Presampler volume: More...

virtual bool	findCell (CalcData &currentCellData, G4double xloc, G4double yloc, G4double zloc) const override final
	=============================================================================== bool findCell(xloc,yloc,zloc) const More...

Private Member Functions
LArG4Identifier	CalculatePSActiveIdentifier (const G4Step *, const G4int indPS) const
	calculate identifier from a G4 step in the PS active region This function should always return a valid identifier which can be used for calibration hit even if the hit is not really in the "fiducial" active part More...

LArG4Identifier	CalculatePS_DMIdentifier (const G4Step *, const G4int indPS) const

G4int	determineZSide (const double zCoord) const

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

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

G4double	m_end_module [8] {}

G4double	m_zminPS {3.00*Athena::Units::mm}

G4double	m_zpres {1549.*Athena::Units::mm}

G4double	m_cat_th {}

G4double	m_first_cathod [8] {}

G4double	m_tilt [8] {}

G4int	m_ngap_cell [8] {}

G4double	m_pitch [8] {}

G4int	m_ncell_module [8] {}

G4double	m_halfThickLAr {0.513.Athena::Units::mm}

Detailed Description

Definition at line 27 of file LArBarrelPresamplerGeometry.h.

Constructor & Destructor Documentation

◆ Geometry()

LArG4::BarrelPresampler::Geometry::Geometry	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Definition at line 85 of file LArBarrelPresamplerGeometry.cxx.

◆ ~Geometry()

virtual LArG4::BarrelPresampler::Geometry::~Geometry ( )

virtualdefault

Member Function Documentation

◆ CalculateIdentifier()

LArG4Identifier LArG4::BarrelPresampler::Geometry::CalculateIdentifier ( const G4Step * a_step ) const

finaloverridevirtual

The following method computes the identifiers in the Presampler volume:

1) Navigate through the volumes hierarchy

2) Calculate identifier using the CalculatePSActiveIdentifier method if the hit is in the Module volume and CalculatePS_DMIdentifier if the hit is in some dead region

Get all the required information from the current step

Now navigate through the volumes hierarchy

Definition at line 147 of file LArBarrelPresamplerGeometry.cxx.

         {
           currentCellData.phiBin = 31 - currentCellData.phiBin;
           if(currentCellData.phiBin < 0 ) currentCellData.phiBin += 64;
         }
  

◆ CalculatePS_DMIdentifier()

LArG4Identifier LArG4::BarrelPresampler::Geometry::CalculatePS_DMIdentifier	(	const G4Step *	a_step,
		const G4int	indPS
	)		const

private

to get coordinates in local half barrel frame, independently of overall presampler position/rotation

shift z such that z=0 is eta=0 in Atlas standard frame

eta,phi in "local" half barrel coordinates

check if the hit is in front of the active layer of the presampler in order to distinguish between regin 2 and 3: WARNING the method is temporary!

PSModuleRmean = 1420 is the distance between the middle of the active layer (LAr) of the PS modules and the interaction point

Fill identifier.

Definition at line 232 of file LArBarrelPresamplerGeometry.cxx.

                                                                     : ploc2.phi();
       const G4double eta = ploc2.eta();
       //G4double z2=fabs(ploc2.z());
  
       const G4int numberPhiMod = 32;
       const G4double dphi = ( 2.*M_PI ) / numberPhiMod;
       const G4double inv_dphi = 1. / dphi;
       const G4double PSModuleRmean = 1420 ;
       const G4double phicheck = phi - int(phi * inv_dphi) * dphi  - (dphi /2.);
       const G4double Rcheck =  PSModuleRmean  / cos(phicheck);
       CalcData currentCellData;
       if (radius > Rcheck) {
         currentCellData.region = 3;
       } else {
         currentCellData.region = 2;
       }
  
       const G4double detaDM = 0.1 ;
       const G4double dphiDM = ( 2 * M_PI ) / 64. ;
  
       currentCellData.phiBin = G4int( phi * (1. / dphiDM) );
       currentCellData.etaBin = G4int( eta * (1. / detaDM) );
  
       if( zSide == -1 )
         {
           currentCellData.phiBin = 31 - currentCellData.phiBin;
           if(currentCellData.phiBin < 0 ) currentCellData.phiBin += 64;
         }
  
       // 07-Jul-2005 WGS: Handle an extremely rare rounding problem.
       if ( currentCellData.phiBin == 64 ) currentCellData.phiBin = 0;
  
       LArG4Identifier PS_DM_ID = LArG4Identifier();
       PS_DM_ID     << 10               // ATLAS
                    << zSide*4          // LArEM
                    << 1
                    << 1
                    << currentCellData.region
                    << currentCellData.etaBin
                    << currentCellData.phiBin;
  
 #ifdef  DEBUGHITS
       ATH_MSG_VERBOSE("Here the identifier for the presampler DEAD materials ---->");
       ATH_MSG_VERBOSE("m_zSide  ----> " << zSide*4);
       ATH_MSG_VERBOSE("region   ----> " << currentCellData.region);
       ATH_MSG_VERBOSE("etaBin   ----> " << currentCellData.etaBin);
       ATH_MSG_VERBOSE("phiBin   ----> " << currentCellData.phiBin);
 #endif
  
       return PS_DM_ID ;
     }
  
     bool  Geometry::findCell(CalcData & currentCellData, G4double xloc,G4double yloc,G4double zloc) const
     {
  
       currentCellData.sampling = 0;
       currentCellData.region   = 0;
  
       G4double phi = atan2(yloc,xloc);
       if ( phi < 0. ) phi += 2.*M_PI;

◆ CalculatePSActiveIdentifier()

LArG4Identifier LArG4::BarrelPresampler::Geometry::CalculatePSActiveIdentifier	(	const G4Step *	a_step,
		const G4int	indPS
	)		const

private

calculate identifier from a G4 step in the PS active region This function should always return a valid identifier which can be used for calibration hit even if the hit is not really in the "fiducial" active part

following code for an Y-axis rotation to define the side C half-barrel

Append the cell ID to the (empty) identifier.

Definition at line 181 of file LArBarrelPresamplerGeometry.cxx.

     {
  
       /******************************************************************************
   CaloDM_ID identifier:
  
   detector_system/subdet/type/sampling/region/eta/phi
   detector system = 10   -> Calorimeters
   subdet          = +/-4 -> LAr dead materials
   type            = 1    -> dead materials outside accordion and active presampler layers
   sampling        = 1    -> dead materials in front and in active LAr calorimeters
                               (starting from front warm cryostat walls)
   regions:        = 0 barrel warm wall and solenoid in front of the barrel presampler, 0 < |eta| < 1.5
                   = 1 barrel cryostat cold wall in front of the barrel presampler, 0 < |eta| < 1.5
                   = 2 all materials in front of the barrel presampler at radius larger than cold wall
                       outer radius, 0 < |eta| < 1.5
                   = 3 all materials from the active layer of the barrel presampler to the active layer
                       of accordion, 0 < |eta| < 1.5
  
    ---> Granularity : deta       0.1          granularity within region
                       dphi       pi/32 ~ 0.1  granularity within region
  
       ***********************************************************************************/
  
       const G4ThreeVector p = (a_step->GetPostStepPoint()->GetPosition() + a_step->GetPreStepPoint()->GetPosition()) * 0.5;
  
 #ifdef  DEBUGHITS
       ATH_MSG_VERBOSE("Position of the step in the ATLAS frame (x,y,z) --> " << p.x() << " " << p.y() << " " << p.z());
       ATH_MSG_VERBOSE("Eta and Phi in the atlas frame                  --> " << p.eta() << " " << p.phi());
 #endif
  

◆ determineZSide()

G4int LArG4::BarrelPresampler::Geometry::determineZSide ( const double zCoord ) const

inlineprivate

Definition at line 45 of file LArBarrelPresamplerGeometry.h.

                                                              {
         // in TB case, only 1 side,
         // in Atlas case, use overall z to decide side
         if (m_testbeam) { return 1; }
         if (zCoord > 0.) { return 1; }
         return -1;
       }

◆ findCell()

bool LArG4::BarrelPresampler::Geometry::findCell	(	CalcData &	currentCellData,
		G4double	xloc,
		G4double	yloc,
		G4double	zloc
	)		const

finaloverridevirtual

=============================================================================== bool findCell(xloc,yloc,zloc) const

From local PS coordinates (half barrel tube mother volume) compute etaBin,phiBin,sampling,region as well as gap number, distance to closest electrode and projection along electrode axis

Takes into account for complexity of eta segmentation

Return true if where are really within the 13mm LAr gap Return false for the few steps which are in the safety region at the edges of module Assume that hit is in the "active" LAr

note that here phiBin is computed for the + half barrel some care has to be taken to convert to the - half barrel, taking into account the rotation

findCell always fills valid currentCellData.region, currentCellData.sampling, currentCellData.etaBin, currentCellData.phiBin it returns true if the hit is in the normal 13mm Ar gap, within a real module it returns false otherwise

eta,phi in "local" Atlas like half barrel coordinates

According to the memo, phi is divided into 64 regions [0..63].

Convert phi into integer bins.

if inside LAr but outside a module, returns some etaBin value for the DM identifier, but function return false to veto this step in the normal calculator

find in which module in z the hit is

compute signed distance from middle of active layer along layer height axis

compute z distance from first cathode of module to step, taking into account the m_tilt angle of the cathode

compute gap number

compute cell number in eta

z of the centre of the anode of the gap

compute step position in electrode reference frame currentCellData.distElec => signed distance to electrode currentCellData.xElec => projection along electrode axis

Definition at line 369 of file LArBarrelPresamplerGeometry.cxx.

         {
           G4cerr << "LArBarrelPresampler: invalid module/hit " << currentCellData.module << " " << z2 << G4endl;
           if (currentCellData.module<0) currentCellData.etaBin=0;
           if (currentCellData.module>7) currentCellData.etaBin=60;
           return false;
         }
  
       const G4int isect=G4int(phi*m_nsectors/(2.*M_PI));
       const G4double phi0= ((double)isect+0.5)*2.*M_PI/((double) m_nsectors);
       static const G4double r0=1420.4*CLHEP::mm;   // FIXME should be recomputed from database
       currentCellData.dist=(xloc*cos(phi0)+yloc*sin(phi0)-r0);
  
 #ifdef DEBUGHITS
       ATH_MSG_VERBOSE("sector number, dist along height " << isect << " " << currentCellData.dist);
       ATH_MSG_VERBOSE("z2,module number,m_first_cathod " << z2 << " " << currentCellData.module << " "
                       << m_first_cathod[currentCellData.module]);
 #endif
  
       G4double deltaz=z2-(m_first_cathod[currentCellData.module]+currentCellData.dist*tan(m_tilt[currentCellData.module]));
       if (deltaz<0 ) {
         if (currentCellData.module>0) {
           currentCellData.module=currentCellData.module-1;
           deltaz=z2-(m_first_cathod[currentCellData.module]+currentCellData.dist*tan(m_tilt[currentCellData.module]));
         }
         else deltaz=0;
       }
  
       currentCellData.gap = ((int)(deltaz/m_pitch[currentCellData.module]));
  
 #ifdef DEBUGHITS
       ATH_MSG_VERBOSE("deltaz from first cathode,gap number " << deltaz << " " << currentCellData.gap);
 #endif
  
       currentCellData.etaBin= currentCellData.gap/m_ngap_cell[currentCellData.module];
 #ifdef DEBUGHITS
       ATH_MSG_VERBOSE("etaBin inside module " << currentCellData.etaBin);
 #endif
       if (currentCellData.etaBin >= m_ncell_module[currentCellData.module]) currentCellData.etaBin=m_ncell_module[currentCellData.module]-1;
  
       for (int i=0;i<currentCellData.module;i++) currentCellData.etaBin=currentCellData.etaBin+m_ncell_module[i];
 #ifdef DEBUGHITS
       ATH_MSG_VERBOSE(" final etaBin " << currentCellData.etaBin);
 #endif
  
       if (currentCellData.etaBin < 0 || currentCellData.etaBin > 60) {
         ATH_MSG_WARNING("LArBarrelPresamplerGeometry::findCell  etaBin outside range " << currentCellData.etaBin);
       }
  
       const G4double zmiddle=m_first_cathod[currentCellData.module]+((double)(currentCellData.gap+0.5))*m_pitch[currentCellData.module];
  
       currentCellData.xElec=currentCellData.dist*cos(m_tilt[currentCellData.module])+(z2-zmiddle)*sin(m_tilt[currentCellData.module]);
       currentCellData.distElec=(z2-zmiddle)*cos(m_tilt[currentCellData.module]) - currentCellData.dist*sin(m_tilt[currentCellData.module]);
 #ifdef DEBUGHITS
       ATH_MSG_VERBOSE("zmiddle,xloc,yloc " << zmiddle << " " << currentCellData.distElec << " " << currentCellData.xElec);
 #endif
  
       bool status=true;
       if (fabs(currentCellData.dist)>m_halfThickLAr) {
 #ifdef DEBUGHITS
         ATH_MSG_VERBOSE("Outside normal LAr 13mm gap "),
 #endif
           status=false;
       }
  
       return status;
     }
  
   } 
 } 

◆ initialize()

StatusCode LArG4::BarrelPresampler::Geometry::initialize ( )

finaloverridevirtual

initialize geometry parameters this should at some stage be taken from a database...

compute positions of end of modules and of first cathode in a module in nominal Atlas coordinates

Definition at line 93 of file LArBarrelPresamplerGeometry.cxx.

     {
       const static G4String fullPSName = (m_detectorName.empty()) ? "LAr::Barrel::Presampler" : G4String(m_detectorName+"::LAr::Barrel::Presampler");
       const static G4String fullCryoName = (m_detectorName.empty()) ? "LAr::TBBarrel::Cryostat::LAr" : G4String(m_detectorName+"::LAr::TBBarrel::Cryostat::LAr");
       const static G4String fullModuleName = (m_detectorName.empty()) ? "LAr::Barrel::Presampler::Module" : G4String(m_detectorName+"::LAr::Barrel::Presampler::Module");
  
       const G4NavigationHistory* g4navigation = a_step->GetPreStepPoint()->GetTouchable()->GetHistory();
       const G4int ndep = g4navigation->GetDepth();
       bool iactive(false);
       G4int idep(-999);
  
       for (G4int ii=0;ii<=ndep;ii++) {
         // FIXME Need to find a way to avoid these string-comparisons
         const G4String& vname = g4navigation->GetVolume(ii)->GetName();
         if (idep<0 && vname==fullPSName) idep=ii;    // half barrel
         else if (!iactive && vname==fullModuleName) iactive=true;
       }
  
       if (idep < 0) std::abort();
  
       if ( iactive ) {