#include <AFP_Geometry.h>

Inheritance diagram for AFP_Geometry:

Collaboration diagram for AFP_Geometry:

Public Member Functions
	AFP_Geometry ()

	AFP_Geometry (const AFP_CONFIGURATION *pCfgParams)

	~AFP_Geometry ()

void	getCfgParams (AFP_CONFIGURATION *pCfgParams) const

HepGeom::Transform3D	getStationTransform (const char *pszStationName) const

HepGeom::Transform3D	getStationElementTransform (const char *pszStationName, eStationElement eElement, const int nPlateID=-1) const

int	getSIDPlatesCnt (const eAFPStation eStation) const

HepGeom::Transform3D	getSIDTransform (const eSIDTransformType eType, const char *pszStationName, const int nPlateID) const

StatusCode	getPointInSIDSensorLocalCS (const int nStationID, const int nPlateID, const HepGeom::Point3D< double > &GlobalPoint, HepGeom::Point3D< double > &LocalPoint) const

StatusCode	getPointInSIDSensorGlobalCS (const int nStationID, const int nPlateID, const HepGeom::Point3D< double > &LocalPoint, HepGeom::Point3D< double > &GlobalPoint) const

eAFPStation	parseStationName (const char *pszStationName) const

void	setupLBarsDims (const eAFPStation eStation)

void	getPixelLocalPosition (const eAFPStation eStation, const int nPixelID, double pfX1Pos, double pfX2Pos) const

int	getPixelRow (const int nPixelID) const

int	getPixelColumn (const int nPixelID) const

Protected Attributes
AFP_CONFIGURATION	m_CfgParams

std::map< eAFPStation, std::map< int, HepGeom::Transform3D > >	m_MapSIDTransToLocal

std::map< eAFPStation, std::map< int, HepGeom::Transform3D > >	m_MapSIDTransToGlobal

Detailed Description

Definition at line 19 of file AFP_Geometry.h.

Constructor & Destructor Documentation

◆ AFP_Geometry() [1/2]

AFP_Geometry::AFP_Geometry ( )

inline

Definition at line 29 of file AFP_Geometry.h.

29 {}

◆ AFP_Geometry() [2/2]

AFP_Geometry::AFP_Geometry ( const AFP_CONFIGURATION * pCfgParams )

Definition at line 22 of file AFP_Geometry.cxx.

   : m_CfgParams (*pCfgParams)
 {
     setupLBarsDims(EAS_AFP00);
     setupLBarsDims(EAS_AFP03);
  
     for(int nStationID=0; nStationID<=3; ++nStationID){
         eAFPStation eStation=(eAFPStation)nStationID;
         for(int nPlateID=0; nPlateID<getSIDPlatesCnt(eStation); ++nPlateID){
             if(!(m_MapSIDTransToGlobal.find(eStation)!=m_MapSIDTransToGlobal.end() && m_MapSIDTransToGlobal[eStation].find(nPlateID)!=m_MapSIDTransToGlobal[eStation].end()))
             {
                 char szStationName[8];
                 sprintf(szStationName,"AFP%02i",(int)eStation);
                 HepGeom::Transform3D Aux=getSIDTransform(ESTT_SENSORGLOBAL,szStationName,nPlateID);
                 m_MapSIDTransToGlobal[eStation][nPlateID]=Aux;
             }
  
             if(!(m_MapSIDTransToLocal.find(eStation)!=m_MapSIDTransToLocal.end() && m_MapSIDTransToLocal[eStation].find(nPlateID)!=m_MapSIDTransToLocal[eStation].end()))
             {
                 char szStationName[8];
                 sprintf(szStationName,"AFP%02i",(int)eStation);
                 HepGeom::Transform3D Aux=getSIDTransform(ESTT_SENSORLOCAL,szStationName,nPlateID);
                 m_MapSIDTransToLocal[eStation][nPlateID]=Aux;
             }
         }
     }
 }

◆ ~AFP_Geometry()

AFP_Geometry::~AFP_Geometry ( )

Definition at line 50 of file AFP_Geometry.cxx.

 {
     m_CfgParams.clear();
 }

Member Function Documentation

◆ getCfgParams()

void AFP_Geometry::getCfgParams ( AFP_CONFIGURATION * pCfgParams ) const

inline

Definition at line 34 of file AFP_Geometry.h.

34 { *pCfgParams=m_CfgParams; }

◆ getPixelColumn()

int AFP_Geometry::getPixelColumn ( const int nPixelID ) const

inline

Definition at line 53 of file AFP_Geometry.h.

53 { return nPixelID%10; }

◆ getPixelLocalPosition()

void AFP_Geometry::getPixelLocalPosition	(	const eAFPStation	eStation,
		const int	nPixelID,
		double *	pfX1Pos,
		double *	pfX2Pos
	)		const

Definition at line 264 of file AFP_Geometry.cxx.

 {
     int i,j;
     AFP_TDCONFIGURATION TofCfg=m_CfgParams.tdcfg.at(eStation);
  
     i=getPixelRow(nPixelID)-1;
     j=getPixelColumn(nPixelID)-1;
  
     if(pfX1Pos) *pfX1Pos = -i * m_CfgParams.tdcfg.at(eStation).fPixelX1Dim;
     if(pfX2Pos) *pfX2Pos =  j * m_CfgParams.tdcfg.at(eStation).fPixelX2Dim;
 }

◆ getPixelRow()

int AFP_Geometry::getPixelRow ( const int nPixelID ) const

inline

Definition at line 52 of file AFP_Geometry.h.

52 { return (nPixelID-(nPixelID%10))/10; }

◆ getPointInSIDSensorGlobalCS()

StatusCode AFP_Geometry::getPointInSIDSensorGlobalCS	(	const int	nStationID,
		const int	nPlateID,
		const HepGeom::Point3D< double > &	LocalPoint,
		HepGeom::Point3D< double > &	GlobalPoint
	)		const

Definition at line 245 of file AFP_Geometry.cxx.

 {
     StatusCode Status=StatusCode::FAILURE;
     GlobalPoint=HepGeom::Point3D<double>();
     eAFPStation eStation=(eAFPStation)nStationID;
  
     if(nStationID>=0 && nStationID<=3){
         if(nPlateID>=0 && nPlateID<getSIDPlatesCnt(eStation)){
             GlobalPoint=m_MapSIDTransToGlobal.at(eStation).at(nPlateID)*static_cast<HepGeom::Point3D<double> >(LocalPoint+HepGeom::Point3D<double>(0.5*AFP_CONSTANTS::SiT_Pixel_length_totx,0.5*AFP_CONSTANTS::SiT_Pixel_length_toty,0.5*AFP_CONSTANTS::SiT_Pixel_thickness));
             Status=StatusCode::SUCCESS;
         }
     }
  
     return Status;
 }

◆ getPointInSIDSensorLocalCS()

StatusCode AFP_Geometry::getPointInSIDSensorLocalCS	(	const int	nStationID,
		const int	nPlateID,
		const HepGeom::Point3D< double > &	GlobalPoint,
		HepGeom::Point3D< double > &	LocalPoint
	)		const

Definition at line 227 of file AFP_Geometry.cxx.

 {
     StatusCode Status=StatusCode::FAILURE;
     LocalPoint=HepGeom::Point3D<double>();
     eAFPStation eStation=(eAFPStation)nStationID;
  
     AFP_TDCONFIGURATION tdcfg=m_CfgParams.tdcfg.at(eStation);
  
     if(nStationID>=0 && nStationID<=3){
         if(nPlateID>=0 && nPlateID<getSIDPlatesCnt(eStation)){
             LocalPoint=m_MapSIDTransToLocal.at(eStation).at(nPlateID)*GlobalPoint-HepGeom::Point3D<double>(0.5*AFP_CONSTANTS::SiT_Pixel_length_totx,0.5*AFP_CONSTANTS::SiT_Pixel_length_toty,0.5*AFP_CONSTANTS::SiT_Pixel_thickness);
             Status=StatusCode::SUCCESS;
         }
     }
  
     return Status;
 }

◆ getSIDPlatesCnt()

int AFP_Geometry::getSIDPlatesCnt ( const eAFPStation eStation ) const

inline

Definition at line 40 of file AFP_Geometry.h.

                                                          {
         std::map<eAFPStation, AFP_SIDCONFIGURATION> sidcfg(m_CfgParams.sidcfg.begin(),m_CfgParams.sidcfg.end());
         return sidcfg[eStation].fLayerCount;
     }

◆ getSIDTransform()

HepGeom::Transform3D AFP_Geometry::getSIDTransform	(	const eSIDTransformType	eType,
		const char *	pszStationName,
		const int	nPlateID
	)		const

Definition at line 136 of file AFP_Geometry.cxx.

 {
     HepGeom::Transform3D ReqTransform=HepGeom::Transform3D();
  
     std::string Station=std::string(pszStationName);
     eAFPStation eStation=parseStationName(pszStationName);
     AFP_SIDCONFIGURATION sidcfg=m_CfgParams.sidcfg.at(eStation);
     double falpha = sidcfg.fSlope;
     
     double fzm=0.0;
  
     if(eType==ESTT_VACUUMSENSOR)
     {
         if(nPlateID<AFP_CONSTANTS::Stat_GlobalVacuumSensorID)
         {
             double fxm=-(sidcfg.vecChipXPos[nPlateID]+0.5*sidcfg.vecChipXLength[nPlateID])*std::cos(falpha); 
             double fZCorrOffset=(DETXSIDE==+1 || falpha==0)? -0:4*AFP_CONSTANTS::SiT_CorrZOffset;
             HepGeom::Transform3D TransInMotherVolume=getStationElementTransform(pszStationName,ESE_SID,nPlateID);
             HepGeom::Transform3D NominalPosInPocket=HepGeom::Translate3D(0.0*CLHEP::mm,0.0*CLHEP::mm, (fzm-fZCorrOffset));
     
             ReqTransform=HepGeom::Translate3D(0.5*AFP_CONSTANTS::SiT_Plate_Main_length_x-0.5*AFP_CONSTANTS::SiT_Chip_length_x, 0.0*CLHEP::mm, -0.5*AFP_CONSTANTS::SiT_Plate_Main_thickness-0.5*AFP_CONSTANTS::Stat_GlobalVacuumSensorThickness);
             ReqTransform=TransInMotherVolume*NominalPosInPocket*HepGeom::Translate3D(fxm, 0.0*CLHEP::mm, nPlateID*sidcfg.fLayerSpacing/std::cos(falpha))*HepGeom::RotateY3D(falpha)*ReqTransform;
         }
         else
         {
             if(nPlateID==AFP_CONSTANTS::Stat_GlobalVacuumSensorID)
             {
                 if(eStation==EAS_AFP00) ReqTransform=HepGeom::TranslateZ3D(-AFP_CONSTANTS::Stat_GlobalVacuumSensorZOffset);
                 else if(eStation==EAS_AFP01) ReqTransform=HepGeom::TranslateZ3D(-AFP_CONSTANTS::Stat_GlobalVacuumSensorZOffset);
                 else if(eStation==EAS_AFP02) ReqTransform=HepGeom::TranslateZ3D(-AFP_CONSTANTS::Stat_GlobalVacuumSensorZOffset);
                 else if(eStation==EAS_AFP03) ReqTransform=HepGeom::TranslateZ3D(-AFP_CONSTANTS::Stat_GlobalVacuumSensorZOffset);
             }
         }
         
         return ReqTransform;
     }
     
     double fxm=-(sidcfg.vecChipXPos[nPlateID]+0.5*sidcfg.vecChipXLength[nPlateID])*std::cos(falpha); 
     double fZCorrOffset=(DETXSIDE==+1 || falpha==0)? -0:4*AFP_CONSTANTS::SiT_CorrZOffset;
     HepGeom::Transform3D TransInMotherVolume=getStationElementTransform(pszStationName,ESE_SID,nPlateID);
     HepGeom::Transform3D NominalPosInPocket=HepGeom::Translate3D(0.0*CLHEP::mm,0.0*CLHEP::mm, (fzm-fZCorrOffset));
  
     HepGeom::Transform3D TransMotherInWorld=getStationTransform(pszStationName);    
  
     //staggering of sensor shift in its plane - correction to cosinus needed fo x-staggering to transform to staggering in LHC CS
     HepGeom::Transform3D TransStaggering=HepGeom::Translate3D(sidcfg.vecXStaggering[nPlateID]*std::cos(falpha),sidcfg.vecYStaggering[nPlateID], 0.0*CLHEP::mm);
     HepGeom::Transform3D TotTransform=TransInMotherVolume*TransStaggering*NominalPosInPocket;
  
     HepGeom::Transform3D PlateTotTrans=TotTransform*HepGeom::Translate3D(fxm,0.0*CLHEP::mm, nPlateID*sidcfg.fLayerSpacing/std::cos(falpha))*HepGeom::RotateY3D(falpha);
     HepGeom::Transform3D TransFEI4=PlateTotTrans*HepGeom::Translate3D(sidcfg.vecChipXPos[nPlateID], sidcfg.vecChipYPos[nPlateID], 0.5*AFP_CONSTANTS::SiT_Plate_Main_thickness+0.5*AFP_CONSTANTS::SiT_Chip_thickness)*HepGeom::RotateZ3D(sidcfg.vecChipRotAngle[nPlateID]);
     HepGeom::Transform3D TransSID=TotTransform*HepGeom::Translate3D(fxm,0.0*CLHEP::mm, nPlateID*sidcfg.fLayerSpacing/std::cos(falpha)) * HepGeom::Translate3D(sidcfg.vecChipXPos[nPlateID]+sidcfg.vecSensorXPos[nPlateID], sidcfg.vecChipYPos[nPlateID]+sidcfg.vecSensorYPos[nPlateID],  (0.5*AFP_CONSTANTS::SiT_Plate_Main_thickness+AFP_CONSTANTS::SiT_Chip_thickness+0.5*AFP_CONSTANTS::SiT_Pixel_thickness))*HepGeom::RotateY3D(falpha) * HepGeom::RotateZ3D(sidcfg.vecChipRotAngle[nPlateID]);
     HepGeom::Transform3D TotTransSIDInWorld=TransMotherInWorld*TransSID;
     
     switch(eType)
     {
     case ESTT_PLATE:
         ReqTransform=PlateTotTrans;
         break;
     case ESTT_SENSOR:
         ReqTransform=TransSID;
         break;
     case ESTT_FEI4CHIP: //CHANGE
         ReqTransform=TransFEI4;
         break;
     case ESTT_SENSORLOCAL:
         ReqTransform=TotTransSIDInWorld.inverse();
         break;
     case ESTT_SENSORGLOBAL:
         ReqTransform=TotTransSIDInWorld;
         break;
     
     default:
         break;
     }
  
     return ReqTransform;
 }

◆ getStationElementTransform()

HepGeom::Transform3D AFP_Geometry::getStationElementTransform	(	const char *	pszStationName,
		eStationElement	eElement,
		const int	nPlateID = `-1`
	)		const

Definition at line 81 of file AFP_Geometry.cxx.

 {
     HepGeom::Transform3D ReqTransform;
     eAFPStation eStation=parseStationName(pszStationName);
  
     AFP_TDCONFIGURATION tdcfg=m_CfgParams.tdcfg.at(eStation);
     AFP_SIDCONFIGURATION sidcfg=m_CfgParams.sidcfg.at(eStation);
  
     double xComponent = -m_CfgParams.vecRPotFloorDistance[eStation];
     double yComponent = m_CfgParams.vecRPotYPos[eStation];
  
     double xStag = 0.0;
     if(eElement==ESE_SID && nPlateID!=AFP_CONSTANTS::Stat_GlobalVacuumSensorID)
         xStag = (nPlateID>-1) ? -sidcfg.vecXStaggering[nPlateID] : 0.0;
     
     switch(eStation)
     {
     case EAS_AFP00:
         if(eElement==ESE_RPOT)
             ReqTransform=HepGeom::Translate3D(xComponent, yComponent, 0.0);
         else if(eElement==ESE_TOF)
             ReqTransform=HepGeom::Translate3D(xComponent, yComponent, 0.0)*HepGeom::Translate3D(-tdcfg.fXFloorDistance,tdcfg.fYPosInRPot,tdcfg.fZPosInRPot-sidcfg.fZDistanceInRPot);
         else if(eElement==ESE_SID)
             ReqTransform=HepGeom::Translate3D(xComponent, yComponent, 0.0)*HepGeom::Translate3D( xStag,0.0,-sidcfg.fZDistanceInRPot);
         else {};
         break;
     case EAS_AFP01:
         if(eElement==ESE_RPOT)
             ReqTransform=HepGeom::Translate3D(xComponent, yComponent, 0.0);
         else if(eElement==ESE_SID)
             ReqTransform=HepGeom::Translate3D(xComponent, yComponent, 0.0)*HepGeom::TranslateX3D( xStag);
         else {};
         break;
     case EAS_AFP02:
         if(eElement==ESE_RPOT)
             ReqTransform=HepGeom::Translate3D(xComponent, yComponent, 0.0);
         else if(eElement==ESE_SID)
             ReqTransform=HepGeom::Translate3D(xComponent, yComponent ,0.0)*HepGeom::TranslateX3D( xStag);
         else {};
         break;
     case EAS_AFP03:
         if(eElement==ESE_RPOT)
             ReqTransform=HepGeom::Translate3D(xComponent, yComponent, 0.0);
     else if(eElement==ESE_TOF)
             ReqTransform=HepGeom::Translate3D(xComponent, yComponent, 0.0)*HepGeom::Translate3D(-tdcfg.fXFloorDistance,tdcfg.fYPosInRPot,tdcfg.fZPosInRPot-sidcfg.fZDistanceInRPot);
     else if(eElement==ESE_SID)
             ReqTransform=HepGeom::Translate3D(xComponent, yComponent, 0.0)*HepGeom::Translate3D( xStag,0.0,-sidcfg.fZDistanceInRPot);
         break;
     default:
         break;
     }
  
     return ReqTransform;
 }

◆ getStationTransform()

HepGeom::Transform3D AFP_Geometry::getStationTransform ( const char * pszStationName ) const

Definition at line 55 of file AFP_Geometry.cxx.

 {
     HepGeom::Transform3D ReqTransform;
     eAFPStation eStation=parseStationName(pszStationName);
  
     switch(eStation)
     {
     case EAS_AFP00:
     ReqTransform=HepGeom::Translate3D(LHCXOFFSET, 0.0*CLHEP::mm, m_CfgParams.vecStatNominalZPos[0]);
         break;
     case EAS_AFP01:
     ReqTransform=HepGeom::Translate3D(LHCXOFFSET, 0.0*CLHEP::mm, m_CfgParams.vecStatNominalZPos[1]);
         break;
     case EAS_AFP02:
     ReqTransform=HepGeom::Translate3D(LHCXOFFSET, 0.0*CLHEP::mm, m_CfgParams.vecStatNominalZPos[2]) * HepGeom::RotateX3D(180*CLHEP::deg);
         break;
     case EAS_AFP03:
     ReqTransform=HepGeom::Translate3D(LHCXOFFSET, 0.0*CLHEP::mm, m_CfgParams.vecStatNominalZPos[3]) * HepGeom::RotateX3D(180*CLHEP::deg);
         break;
     default:
         break;
     }
  
     return ReqTransform;
 }

◆ parseStationName()

eAFPStation AFP_Geometry::parseStationName ( const char * pszStationName ) const

Definition at line 214 of file AFP_Geometry.cxx.

 {
     eAFPStation eStation=EAS_UNKNOWN;
  
     if(!strcmp(pszStationName,"AFP00")) eStation=EAS_AFP00;
     else if(!strcmp(pszStationName,"AFP01")) eStation=EAS_AFP01;
     else if(!strcmp(pszStationName,"AFP02")) eStation=EAS_AFP02;
     else if(!strcmp(pszStationName,"AFP03")) eStation=EAS_AFP03;
     else eStation=EAS_UNKNOWN;
  
     return eStation;
 }

◆ setupLBarsDims()

void AFP_Geometry::setupLBarsDims ( const eAFPStation eStation )

Definition at line 276 of file AFP_Geometry.cxx.

 {
     int i,j,nTrainOfBar11,nRefTrainID,nTrainID,nTrainCnt;
     AFPTOF_LBARDIMENSIONS BarDims;
     double fRadLength11, fLGuideLength11, fRadLength, fLGuideLength;
  
     AFP_TDCONFIGURATION tdcfg=m_CfgParams.tdcfg.at(eStation);
     AFPTOF_LBARREFDIMENSIONS RefBarDims=tdcfg.RefBarDims;
  
     nTrainCnt=nTrainOfBar11=tdcfg.nX1PixCnt;
  
     if(RefBarDims.fLBarThickness>(tdcfg.fPixelX2Dim-AFP_CONSTANTS::ToF_MinBarGap)) RefBarDims.fLBarThickness=tdcfg.fPixelX2Dim-AFP_CONSTANTS::ToF_MinBarGap;
  
     //calculate dimensions for bar (1,1), move from (refx1,refx2)
     nRefTrainID = nTrainCnt-(RefBarDims.nBarX1ID-1); //reference train
     fRadLength11 = (RefBarDims.fRadLength+tdcfg.mapTrainInfo.at(nRefTrainID).fTaperOffset)+(1-RefBarDims.nBarX1ID)*tdcfg.fPixelX1Dim; // move to (refx1,1)
     fRadLength11 += (tdcfg.mapTrainInfo.at(nRefTrainID).fPerpShiftInPixel-tdcfg.mapTrainInfo.at(nTrainOfBar11).fPerpShiftInPixel)+0.5*(tdcfg.mapTrainInfo.at(nTrainOfBar11).fLGuideWidth-tdcfg.mapTrainInfo.at(nRefTrainID).fLGuideWidth);
     fRadLength11 -= ((1-RefBarDims.nBarX2ID)*tdcfg.fPixelX2Dim)/std::tan(tdcfg.fAlpha); //move to (1,1)
     for(fLGuideLength11=RefBarDims.fLGuideLength,i=RefBarDims.nBarX1ID-1;i>=1;i--){
         nTrainID = nTrainCnt-(i-1);
         fLGuideLength11 -= AFP_CONSTANTS::ToF_LGuideTrainOffset+(tdcfg.mapTrainInfo.at(nTrainID).fLGuideWidth-tdcfg.mapTrainInfo.at(nTrainID).fTaperOffset);
     }
  
     //calculate length of light guides
     std::vector<double> vecLGLengths;
     vecLGLengths.resize(tdcfg.nX1PixCnt);
     vecLGLengths[0]=fLGuideLength11;
     for(i=2;i<=tdcfg.nX1PixCnt;i++){
         nTrainID=nTrainCnt-(i-1);
         vecLGLengths[i-1]=vecLGLengths[i-2]+AFP_CONSTANTS::ToF_LGuideTrainOffset+tdcfg.mapTrainInfo.at(nTrainID+1).fLGuideWidth-tdcfg.mapTrainInfo.at(nTrainID+1).fTaperOffset;
     }
  
     tdcfg.mapBarDims.clear();
     for(i=0;i<tdcfg.nX1PixCnt;i++){
         nTrainID=tdcfg.nX1PixCnt-i;
  
         for(j=0;j<tdcfg.nX2PixCnt;j++){
             int k = j;
             if(eStation==EAS_AFP02 || eStation==EAS_AFP03){
                 k = tdcfg.nX2PixCnt-1 - j;
             }
             
             fRadLength=fRadLength11+i*tdcfg.fPixelX1Dim-k*tdcfg.fPixelX2Dim/std::tan(tdcfg.fAlpha);
             fRadLength+=(tdcfg.mapTrainInfo.at(nTrainOfBar11).fPerpShiftInPixel-tdcfg.mapTrainInfo.at(nTrainID).fPerpShiftInPixel);
             fRadLength+=0.5*(tdcfg.mapTrainInfo.at(nTrainID).fLGuideWidth-tdcfg.mapTrainInfo.at(nTrainOfBar11).fLGuideWidth);
             fLGuideLength=vecLGLengths[i];
  
             BarDims.nBarX1ID=i+1;
             BarDims.nBarX2ID=j+1;
             BarDims.nTrainID=nTrainID;
             BarDims.fLGuideLength=fLGuideLength;
             BarDims.fLBarThickness=RefBarDims.fLBarThickness;
             BarDims.fRadLength=fRadLength-tdcfg.mapTrainInfo.at(BarDims.nTrainID).fTaperOffset;
             BarDims.fRadYDim=tdcfg.mapTrainInfo.at(nTrainID).fLGuideWidth-tdcfg.mapTrainInfo.at(BarDims.nTrainID).fTaperOffset;
             BarDims.fLGuideWidth=tdcfg.mapTrainInfo.at(nTrainID).fLGuideWidth;
  
             if(j==0) tdcfg.mapTrainInfo.at(nTrainCnt-i).fLength=fLGuideLength+0.5*BarDims.fRadYDim;
             tdcfg.mapBarDims[10*(i+1)+(k + 1)]=BarDims;
         }
     }
 }

Member Data Documentation

◆ m_CfgParams

AFP_CONFIGURATION AFP_Geometry::m_CfgParams

protected

Definition at line 23 of file AFP_Geometry.h.

◆ m_MapSIDTransToGlobal

std::map<eAFPStation, std::map<int, HepGeom::Transform3D> > AFP_Geometry::m_MapSIDTransToGlobal

protected

Definition at line 26 of file AFP_Geometry.h.

◆ m_MapSIDTransToLocal

std::map<eAFPStation, std::map<int, HepGeom::Transform3D> > AFP_Geometry::m_MapSIDTransToLocal

protected

Definition at line 25 of file AFP_Geometry.h.

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

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AFP_Geometry() [1/2]

◆ AFP_Geometry() [2/2]

◆ ~AFP_Geometry()

Member Function Documentation

◆ getCfgParams()

◆ getPixelColumn()

◆ getPixelLocalPosition()

◆ getPixelRow()

◆ getPointInSIDSensorGlobalCS()

◆ getPointInSIDSensorLocalCS()

◆ getSIDPlatesCnt()

◆ getSIDTransform()

◆ getStationElementTransform()

◆ getStationTransform()

◆ parseStationName()

◆ setupLBarsDims()

Member Data Documentation

◆ m_CfgParams

◆ m_MapSIDTransToGlobal

◆ m_MapSIDTransToLocal