ATLAS Offline Software
Public Member Functions | Public Attributes | Static Public Attributes | Private Member Functions | Private Attributes | List of all members
ALFA_GeometryReader Class Reference

#include <ALFA_GeometryReader.h>

Collaboration diagram for ALFA_GeometryReader:

Public Member Functions

 ALFA_GeometryReader ()
 
 ~ALFA_GeometryReader ()
 
bool Initialize (const PGEOMETRYCONFIGURATION pConfig, eFiberCoordSystem eFCoordSystem)
 
bool ReadFiberGeometry (const PGEOMETRYCONFIGURATION pConfig)
 
int GetRPotCount () const
 
void PrintFiberGeometry (std::ostream &OutStream)
 
void PrintFiberGeometry (const char *szOutFilename)
 
void GetListOfRPotIDs (std::map< eRPotName, std::string > *pMapRPotName)
 
void GetListOfExistingRPotIDs (std::list< eRPotName > *pListRPotName)
 
bool GetUFiberParams (PFIBERPARAMS pFiberParams, const eRPotName eRPName, const int nPlateID, const int nFiberID)
 
bool GetVFiberParams (PFIBERPARAMS pFiberParams, const eRPotName eRPName, const int nPlateID, const int nFiberID)
 
bool StoreReconstructionGeometry (const eRPotName eRPName, const eFiberType eFType, const char *szDataDestination)
 
bool GetPlateParams (PPLATEPARAMS pPlateParams, const eRPotName eRPName, const int nPlateID)
 
bool GetRPPosParams (PRPPOSPARAMS pRPosParams, const eRPotName eRPName)
 
bool GetASPosParams (PASPOSPARAMS pRPosParams, const eAStationName eASName)
 
const char * GetRPotLabel (const eRPotName eRPName)
 
const char * GetAStationLabel (const eAStationName eASName)
 
eGeoSourceType GetRPGeometryType (const eRPotName eRPName, eFiberType eFType)
 
bool GetMDFiberParams (PFIBERPARAMS pFiberParams, const eFiberType eFType, const eRPotName eRPName, const int nPlateID, const int nFiberID)
 
bool GetODFiberParams (PFIBERPARAMS pFiberParams, const eFiberType eFType, const eRPotName eRPName, const int nPlateID, const int nFiberID)
 
bool SaveRPGeometryParams (const eRPotName eRPName, const char *szDataDestination)
 
HepGeom::Point3D< double > GetDetPointInAtlas (eRPotName eRPName, const HepGeom::Point3D< double > &PointInDetCS)
 
HepGeom::Point3D< double > GetDetPointInRPot (eRPotName eRPName, const HepGeom::Point3D< double > &PointInDetCS)
 
HepGeom::Transform3D GetTransformMatrix (const eRPotName eRPName, const eTransformElement eMatrixType)
 
double GetRPotZPosInAtlas (const eRPotName eRPName)
 
double GetUFiberCentreXPos (const eRPotName eRPName, const int nPlateID, const int nFiberID)
 
double GetVFiberCentreXPos (const eRPotName eRPName, const int nPlateID, const int nFiberID)
 
double GetUFiberAngle (const eRPotName eRPName, const int nPlateID, const int nFiberID)
 
double GetVFiberAngle (const eRPotName eRPName, const int nPlateID, const int nFiberID)
 
double GetODFiberCentreYPos (const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
 
double GetODFiberAngle (const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
 
void SetUFiberPositionToMainReference (const eRPotName eRPName, const int nPlateID, const int nFiberID, const HepGeom::Point3D< float > &TransPoint, const double fTransSlope)
 
void SetVFiberPositionToMainReference (const eRPotName eRPName, const int nPlateID, const int nFiberID, const HepGeom::Point3D< float > &TransPoint, const double fTransSlope)
 
void SetODFiberPositionToMainReference (const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID, const HepGeom::Point3D< float > &TransPoint, const double fTransSlope)
 
double GetMDFiberSlope (const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
 
double GetMDFiberOffset (const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
 
double GetMDFiberZPos (const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
 
double GetODFiberSlope (const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
 
double GetODFiberOffset (const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
 
double GetODFiberZPos (const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
 

Public Attributes

std::map< eRPotName, RPPOSPARAMS > m_RPPosParams
 
std::map< eAStationName, ASPOSPARAMS > m_ASPosParams
 

Static Public Attributes

static const HepGeom::Point3D< double > ms_NominalRPPin1 =HepGeom::Point3D<double>(+77.5*CLHEP::mm,+172.2*CLHEP::mm,-124.0*CLHEP::mm)
 
static const HepGeom::Point3D< double > ms_NominalRPMainPoint =HepGeom::Point3D<double>(0.0*CLHEP::mm,31.525*CLHEP::mm,8.0*CLHEP::mm)
 
static const HepGeom::Point3D< double > ms_NominalAlfaRefPoint =HepGeom::Point3D<double>(-77.5*CLHEP::mm,-35.2*CLHEP::mm,114.0*CLHEP::mm)
 
static const HepGeom::Point3D< double > ms_NominalDetPin1 =HepGeom::Point3D<double>(-77.5*CLHEP::mm,-35.0*CLHEP::mm,114.0*CLHEP::mm)
 

Private Member Functions

bool InitializeDefault (const PGEOMETRYCONFIGURATION pConfig)
 
bool ReadSource (const eGeoSourceType eSourceType, const eRPotName eRPName, const eFiberType eFType, const char *szDataSource)
 
bool SetIdealGeometry (const eRPotName eRPName, const eFiberType eFType)
 
void UpdateGeometry ()
 
void UpdateStationsPosParams ()
 
void UpdateSimRPPos (const eRPotName eRPName)
 
bool ReadFile (const eRPotName eRPName, const eFiberType eFType, const char *szFilename)
 
bool ReadDatabase (const eRPotName eRPName, const eFiberType eFType, const char *szDataSource)
 
void TransformFiberPositions (PFIBERPARAMS pFiberParams, eRPotName eRPName, const eFiberType eType, const eGeoSourceType eSourceType)
 
void TransformFiberPositionsFCSCladding (PFIBERPARAMS pFiberParams, eRPotName eRPName, const eFiberType eType, const eGeoSourceType eSourceType)
 
void TransformFiberPositionsFCSAtlas (PFIBERPARAMS pFiberParams, eRPotName eRPName, const eFiberType eType, const eGeoSourceType eSourceType)
 
HepGeom::Transform3D ComputeTransformMatrix (const std::vector< HepGeom::Point3D< double > > &VecIdealRefPoints, const std::vector< HepGeom::Point3D< double > > &VecRealRefPoints, const int nPointCnt, HepGeom::Scale3D &Scale, bool bForceUseSVD=false)
 
bool ParseRPMetrology (eGeoSourceType eSourceType, const char *szDataSource)
 
bool ResolveRPotRefPoints (const char *szvalue, eRPotName eRPName, eRefPointType eRPointType)
 
bool ParseRefPoints (const char *szvalue, std::vector< HepGeom::Point3D< double > > &vecRefPoints, eMetrologyCoordSystem eCSystem)
 
bool ParseArrayOfValues (const char *szvalue, std::vector< double > &vecValues)
 
bool SetupRPMetrologyPoints (ALFA_ConfigParams &CfgParams, eRPotName eRPName)
 
bool SetupDetMetrologyPoints (ALFA_ConfigParams &CfgParams, eRPotName eRPName)
 
bool SetupStationMetrologyPoints (ALFA_ConfigParams &CfgParams, eAStationName eASName)
 
double GetPolyFitValue (const double fInputValue, const std::vector< double > &vecPolyFitParams)
 
void SetupCurrentLVDT (const PGEOMETRYCONFIGURATION pConfig)
 
void SetupSWCorrections (const PGEOMETRYCONFIGURATION pConfig)
 
void SetupUserCorrections (const PGEOMETRYCONFIGURATION pConfig)
 

Private Attributes

eFiberCoordSystem m_eFCoordSystem
 
GEOMETRYCONFIGURATION m_ConfigOpts
 
eMetrologyType m_eMetrologyType
 
std::map< eRPotName, ROMAPOT > m_MapRPot
 
std::list< eRPotName > m_ListExistingRPots
 

Detailed Description

Definition at line 215 of file ALFA_GeometryReader.h.

Constructor & Destructor Documentation

◆ ALFA_GeometryReader()

ALFA_GeometryReader::ALFA_GeometryReader ( )

Definition at line 108 of file ALFA_GeometryReader.cxx.

109 {
110  m_eFCoordSystem=EFCS_UNDEFINED;
111  m_eMetrologyType=EMT_UNDEFINED;
112  m_MapRPot.clear();
113 }

◆ ~ALFA_GeometryReader()

ALFA_GeometryReader::~ALFA_GeometryReader ( )

Definition at line 115 of file ALFA_GeometryReader.cxx.

116 {
117  m_MapRPot.clear();
118 }

Member Function Documentation

◆ ComputeTransformMatrix()

HepGeom::Transform3D ALFA_GeometryReader::ComputeTransformMatrix ( const std::vector< HepGeom::Point3D< double > > &  VecIdealRefPoints,
const std::vector< HepGeom::Point3D< double > > &  VecRealRefPoints,
const int  nPointCnt,
HepGeom::Scale3D &  Scale,
bool  bForceUseSVD = false 
)
private

Definition at line 887 of file ALFA_GeometryReader.cxx.

889 {
890  int i,j;
891  const int N=nPointCnt;
892  CLHEP::HepVector vecAux1,vecAux2;
893  CLHEP::HepVector xmean,ymean,t;
894  CLHEP::HepMatrix C,U,V,R,W;
895  HepGeom::Transform3D TransTot;
896  HepGeom::Rotate3D AuxRot;
897  HepGeom::Translate3D AuxTranslation;
898 
899  //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_DetectorFactory::ReadGeometry");
900 
901  if(nPointCnt==3 && !bForceUseSVD)
902  {
903  HepGeom::Transform3D AuxTrans=HepGeom::Transform3D(VecIdealRefPoints[0],VecIdealRefPoints[1],VecIdealRefPoints[2],
904  VecRealRefPoints[0],VecRealRefPoints[1],VecRealRefPoints[2]);
905  AuxTrans.getDecomposition(Scale,AuxRot,AuxTranslation);
906 
907  TransTot=HepGeom::Transform3D(AuxTrans.getRotation(),AuxTrans.getTranslation());
908 
909  }
910  else
911  {
912  std::vector<CLHEP::HepVector> pX (N);
913  std::vector<CLHEP::HepVector> pY (N);
914  std::vector<CLHEP::HepVector> pXs (N);
915  std::vector<CLHEP::HepVector> pYs(N);
916 
917  for(i=0;i<N;i++){
918  pX[i]=CLHEP::Hep3Vector(VecIdealRefPoints[i].x(),VecIdealRefPoints[i].y(),VecIdealRefPoints[i].z());
919  pY[i]=CLHEP::Hep3Vector(VecRealRefPoints[i].x(),VecRealRefPoints[i].y(),VecRealRefPoints[i].z());
920  }
921 
922  /*
923  pX[0]=CLHEP::Hep3Vector(1.0, 0.0, 0.0);
924  pX[1]=CLHEP::Hep3Vector(0.0, 1.0, 0.0);
925  pX[2]=CLHEP::Hep3Vector(0.0, 0.0, 1.0);
926 
927  pY[0]=CLHEP::Hep3Vector(1.7071, -9.7071, 1.0000);
928  pY[1]=CLHEP::Hep3Vector(1.7071, -8.2929, 1.0000);
929  pY[2]=CLHEP::Hep3Vector(1.0, -9.0, 2.0);*/
930 
931  vecAux1=CLHEP::Hep3Vector();
932  vecAux2=CLHEP::Hep3Vector();
933  for(i=0;i<N;i++){
934  vecAux1+=pX[i];
935  vecAux2+=pY[i];
936  }
937 
938  xmean=vecAux1/(1.0*N);
939  ymean=vecAux2/(1.0*N);
940 
941  C=CLHEP::HepMatrix(3,3);
942  for(i=0;i<N;i++){
943  pXs[i]=pX[i]-xmean;
944  pYs[i]=pY[i]-ymean;
945  C+=pYs[i]*pXs[i].T();
946  }
947 
948  //LogStream<<MSG::INFO<<"C="<<C<<endmsg;
949 
950  std::vector<double*> ppfA(3);
951  std::vector<double*> ppfV(3);
952  for(i=0;i<3;i++){
953  ppfA[i]=new double[3];
954  std::fill (ppfA[i], ppfA[i]+3, 0);
955 
956  ppfV[i]=new double[3];
957  std::fill (ppfV[i], ppfV[i]+3, 0);
958  }
959 
960  std::vector<double> pfW (3);
961 
962 
963  for(i=0;i<3;i++){
964  for(j=0;j<3;j++) ppfA[i][j]=(double)C[i][j];
965  }
966 
967  dsvd(ppfA.data(),3,3,pfW.data(),ppfV.data());
968 
969  U=CLHEP::HepMatrix(3,3); V=CLHEP::HepMatrix(3,3);
970  for(i=0;i<3;i++){
971  for(j=0;j<3;j++) U[i][j]=(double)ppfA[i][j];
972  for(j=0;j<3;j++) V[i][j]=(double)ppfV[i][j];
973  }
974 
975  W=CLHEP::HepMatrix(3,3);
976  W[0][0]=1; W[1][1]=1;
977  W[2][2]=(U*V).determinant();
978 
979  R=U*W*V.T();
980  t=ymean-R*xmean;
981  //LogStream<<MSG::INFO<<"U="<<U<<endmsg;
982  //LogStream<<MSG::INFO<<"V="<<V<<endmsg;
983  //LogStream<<MSG::INFO<<"W="<<W<<endmsg;
984  //LogStream<<MSG::INFO<<"R="<<R<<endmsg;
985  //LogStream<<MSG::INFO<<"t="<<t<<endmsg;
986 
987  CLHEP::HepRep3x3 matAux;
988  matAux.xx_=R[0][0]; matAux.xy_=R[0][1]; matAux.xz_=R[0][2];
989  matAux.yx_=R[1][0]; matAux.yy_=R[1][1]; matAux.yz_=R[1][2];
990  matAux.zx_=R[2][0]; matAux.zy_=R[2][1]; matAux.zz_=R[2][2];
991  CLHEP::HepRotation TransM=CLHEP::HepRotation(matAux);
992  CLHEP::Hep3Vector TransT=CLHEP::Hep3Vector(t[0],t[1],t[2]);
993  TransTot=HepGeom::Transform3D(TransM,TransT);
994 
995  for(i=0;i<3;i++){
996  delete [] ppfA[i];
997  delete [] ppfV[i];
998  }
999  }
1000 
1001  return TransTot;
1002 }

◆ GetASPosParams()

bool ALFA_GeometryReader::GetASPosParams ( PASPOSPARAMS  pRPosParams,
const eAStationName  eASName 
)

Definition at line 1949 of file ALFA_GeometryReader.cxx.

1950 {
1951  bool bRes=false;
1952  std::map<eAStationName,ASPOSPARAMS>::iterator iter;
1953 
1954  MsgStream LogStream(Athena::getMessageSvc(),"ALFA_GeometryReader::GetASPosParams");
1955 
1956  pASPosParams->clear();
1957  if((iter=m_ASPosParams.find(eASName))!=m_ASPosParams.end()){
1958  *pASPosParams=(*iter).second;
1959  bRes=true;
1960  }
1961  else{
1962  LogStream<<MSG::ERROR<<"Unknown ALFA Station ID="<<eASName<<endmsg;
1963  }
1964 
1965  return bRes;
1966 }

◆ GetAStationLabel()

const char* ALFA_GeometryReader::GetAStationLabel ( const eAStationName  eASName)
inline

Definition at line 280 of file ALFA_GeometryReader.h.

280 { return m_ASPosParams[eASName].szLabel; }

◆ GetDetPointInAtlas()

HepGeom::Point3D< double > ALFA_GeometryReader::GetDetPointInAtlas ( eRPotName  eRPName,
const HepGeom::Point3D< double > &  PointInDetCS 
)

Definition at line 2859 of file ALFA_GeometryReader.cxx.

2860 {
2861  RPPOSPARAMS RPPosParams;
2862  ASPOSPARAMS ASPosParams;
2863 
2864  HepGeom::Point3D<double> RPPin1=ms_NominalRPPin1;//HepGeom::Point3D<double>(+77.5*mm,+172.2*mm,-114.0*mm);
2865  HepGeom::Point3D<double> MainPoint=ms_NominalRPMainPoint;//HepGeom::Point3D<double>(0.0*mm,31.025*mm,18.0*mm);
2866  HepGeom::Point3D<double> AlfaRefPoint=ms_NominalAlfaRefPoint;//HepGeom::Point3D<double>(-77.5*mm,-35.7*mm,114.0*mm);
2867  HepGeom::Point3D<double> PointInAtlasCS, PointInRPotCS;
2868 
2869  if(m_eFCoordSystem==EFCS_ATLAS || m_eFCoordSystem==EFCS_CLADDING){
2870  GetRPPosParams(&RPPosParams, eRPName);
2871  GetASPosParams(&ASPosParams, RPPosParams.eASName);
2872  HepGeom::Vector3D<double> Shift=RPPin1-MainPoint;
2873  HepGeom::Point3D<double> PointInMainPoint=Shift+AlfaRefPoint+PointInDetCS;
2874  HepGeom::Point3D<double> PointInRPotCS=RPPosParams.DetTransformInMainPoint*PointInMainPoint; //wrt. MainPoint
2875  HepGeom::Transform3D TotTransform=ASPosParams.ASTransformInATLAS*RPPosParams.RPTransformInStation;
2876  PointInAtlasCS=TotTransform*PointInRPotCS;
2877  }
2878  else{
2879  throw new GaudiException(" The GetDetPointInAtlas() can be used only with EFCS_ATLAS or EFCS_CLADDING flag ", "ALFA_GeometryReader::GetDetPointInAtlas", StatusCode::FAILURE);
2880  }
2881  /*
2882  RPPOSPARAMS RPPosParams;
2883  ASPOSPARAMS ASPosParams;
2884  HepGeom::Point3D<double> AlfaRefPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm,+105.475*CLHEP::mm,-18.0*CLHEP::mm);
2885  HepGeom::Point3D<double> PointInAtlasCS;
2886 
2887  if(m_eFCoordSystem==EFCS_ATLAS || m_eFCoordSystem==EFCS_CLADDING){
2888  GetRPPosParams(&RPPosParams, eRPName);
2889  GetASPosParams(&ASPosParams, RPPosParams.eASName);
2890 
2891  CLHEP::Point3D<double> PointInDetMainPoint=AlfaRefPoint+PointInDetCS;
2892  HepGeom::Transform3D TotTransform=ASPosParams.ASTransformInATLAS*RPPosParams.RPTransformInStation*RPPosParams.DetTransformInMainPoint;
2893  PointInAtlasCS=TotTransform*PointInDetMainPoint;
2894  HepGeom::Point3D<double> auxPoint=PointInAtlasCS;
2895  int a=0;
2896  }
2897  else{
2898  throw new GaudiException(" The GetDetPointInAtlas() can be used only with EFCS_ATLAS or EFCS_CLADDING flag ", "ALFA_GeometryReader::GetDetPointInAtlas", StatusCode::FAILURE);
2899  }
2900 */
2901  return PointInAtlasCS;
2902 }

◆ GetDetPointInRPot()

HepGeom::Point3D< double > ALFA_GeometryReader::GetDetPointInRPot ( eRPotName  eRPName,
const HepGeom::Point3D< double > &  PointInDetCS 
)

Definition at line 2904 of file ALFA_GeometryReader.cxx.

2905 {
2906  RPPOSPARAMS RPPosParams;
2907  HepGeom::Point3D<double> RPPin1=ms_NominalRPPin1;
2908  HepGeom::Point3D<double> MainPoint=ms_NominalRPMainPoint;
2909  HepGeom::Point3D<double> AlfaRefPoint=ms_NominalAlfaRefPoint;
2910  HepGeom::Point3D<double> PointInRPotCS;
2911 
2912  if(m_eFCoordSystem==EFCS_ATLAS || m_eFCoordSystem==EFCS_CLADDING){
2913  GetRPPosParams(&RPPosParams, eRPName);
2914 
2915  HepGeom::Vector3D<double> Shift=RPPin1-MainPoint;
2916  HepGeom::Point3D<double> PointInMainPoint=Shift+AlfaRefPoint+PointInDetCS;
2917  PointInRPotCS=RPPosParams.DetTransformInMainPoint*PointInMainPoint-Shift; // wrt. RPPin1
2918  }
2919  else{
2920  throw new GaudiException(" The GetDetPointInAtlas() can be used only with EFCS_ATLAS or EFCS_CLADDING flag ", "ALFA_GeometryReader::GetDetPointInAtlas", StatusCode::FAILURE);
2921  }
2922 
2923  return PointInRPotCS;
2924 }

◆ GetListOfExistingRPotIDs()

void ALFA_GeometryReader::GetListOfExistingRPotIDs ( std::list< eRPotName > *  pListRPotName)

Definition at line 1925 of file ALFA_GeometryReader.cxx.

1926 {
1927  *pListRPotName=m_ListExistingRPots;
1928 }

◆ GetListOfRPotIDs()

void ALFA_GeometryReader::GetListOfRPotIDs ( std::map< eRPotName, std::string > *  pMapRPotName)

Definition at line 1910 of file ALFA_GeometryReader.cxx.

1911 {
1912  std::string strLabel;
1913  std::map<eRPotName,ROMAPOT>::const_iterator rpiter;
1914 
1915  if(pMapRPotName!=nullptr){
1916  pMapRPotName->clear();
1917 
1918  for(rpiter=m_MapRPot.begin();rpiter!=m_MapRPot.end();++rpiter){
1919  strLabel=GetRPotLabel((*rpiter).first);
1920  pMapRPotName->insert(std::pair<eRPotName,std::string>((*rpiter).first,strLabel));
1921  }
1922  }
1923 }

◆ GetMDFiberOffset()

double ALFA_GeometryReader::GetMDFiberOffset ( const eRPotName  eRPName,
const eFiberType  eFType,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 2303 of file ALFA_GeometryReader.cxx.

2304 {
2305  double fOffset=0.0;
2306  FIBERPARAMS FiberParams;
2307 
2308  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetMDFiberOffset");
2309 
2310  if(m_eFCoordSystem!=EFCS_ATLAS){
2311  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
2312  return 0.0;
2313  }
2314 
2315  switch(eFType){
2316  case EFT_UFIBER:
2317  if(GetUFiberParams(&FiberParams, eRPName, nPlateID, nFiberID)){
2318  fOffset=FiberParams.fcs_atlas.fOffset;
2319  }
2320  break;
2321  case EFT_VFIBER:
2322  if(GetVFiberParams(&FiberParams, eRPName, nPlateID, nFiberID)){
2323  fOffset=FiberParams.fcs_atlas.fOffset;
2324  }
2325  break;
2326  default:
2327  LogStream<<MSG::ERROR<<"Invalid fiber type"<<endmsg;
2328  break;
2329  }
2330 
2331  return fOffset;
2332 }

◆ GetMDFiberParams()

bool ALFA_GeometryReader::GetMDFiberParams ( PFIBERPARAMS  pFiberParams,
const eFiberType  eFType,
const eRPotName  eRPName,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 1985 of file ALFA_GeometryReader.cxx.

1986 {
1987  bool bRes=false;
1988 
1989  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetMDFiberParams");
1990 
1991  if(pFiberParams==nullptr)
1992  {
1993  LogStream<<MSG::ERROR<<"pFiberParams points to NULL"<<endmsg;
1994  }
1995  else if(m_eFCoordSystem!=EFCS_ATLAS)
1996  {
1997  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
1998  }
1999  else{
2000  switch(eFType){
2001  case EFT_UFIBER:
2002  bRes=GetUFiberParams(pFiberParams, eRPName, nPlateID, nFiberID);
2003  break;
2004  case EFT_VFIBER:
2005  bRes=GetVFiberParams(pFiberParams, eRPName, nPlateID, nFiberID);
2006  break;
2007  default:
2008  LogStream<<MSG::ERROR<<"Invalid fiber type"<<endmsg;
2009  break;
2010  }
2011  }
2012 
2013  return bRes;
2014 }

◆ GetMDFiberSlope()

double ALFA_GeometryReader::GetMDFiberSlope ( const eRPotName  eRPName,
const eFiberType  eFType,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 2272 of file ALFA_GeometryReader.cxx.

2273 {
2274  double fSlope=0.0;
2275  FIBERPARAMS FiberParams;
2276 
2277  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetMDFiberSlope");
2278 
2279  if(m_eFCoordSystem!=EFCS_ATLAS){
2280  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
2281  return 0.0;
2282  }
2283 
2284  switch(eFType){
2285  case EFT_UFIBER:
2286  if(GetUFiberParams(&FiberParams, eRPName, nPlateID, nFiberID)){
2287  fSlope=FiberParams.fcs_atlas.fSlope;
2288  }
2289  break;
2290  case EFT_VFIBER:
2291  if(GetVFiberParams(&FiberParams, eRPName, nPlateID, nFiberID)){
2292  fSlope=FiberParams.fcs_atlas.fSlope;
2293  }
2294  break;
2295  default:
2296  LogStream<<MSG::ERROR<<"Invalid fiber type"<<endmsg;
2297  break;
2298  }
2299 
2300  return fSlope;
2301 }

◆ GetMDFiberZPos()

double ALFA_GeometryReader::GetMDFiberZPos ( const eRPotName  eRPName,
const eFiberType  eFType,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 2334 of file ALFA_GeometryReader.cxx.

2335 {
2336  double fZPos=0.0;
2337  FIBERPARAMS FiberParams;
2338 
2339  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetMDFiberZPos");
2340 
2341  if(m_eFCoordSystem!=EFCS_ATLAS){
2342  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
2343  return 0.0;
2344  }
2345 
2346  switch(eFType){
2347  case EFT_UFIBER:
2348  if(GetUFiberParams(&FiberParams, eRPName, nPlateID, nFiberID)){
2349  fZPos=FiberParams.fcs_atlas.fZPos;
2350  }
2351  break;
2352  case EFT_VFIBER:
2353  if(GetVFiberParams(&FiberParams, eRPName, nPlateID, nFiberID)){
2354  fZPos=FiberParams.fcs_atlas.fZPos;
2355  }
2356  break;
2357  default:
2358  LogStream<<MSG::ERROR<<"Invalid fiber type"<<endmsg;
2359  break;
2360  }
2361 
2362  return fZPos;
2363 }

◆ GetODFiberAngle()

double ALFA_GeometryReader::GetODFiberAngle ( const eRPotName  eRPName,
const eFiberType  eFType,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 2253 of file ALFA_GeometryReader.cxx.

2254 {
2255  double fAngle=0.0;
2256  FIBERPARAMS FiberParams;
2257 
2258  if(m_eFCoordSystem!=EFCS_CLADDING){
2259  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetODFiberAngle");
2260  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
2261  return 0.0;
2262  }
2263 
2264  if(GetODFiberParams(&FiberParams, eFType, eRPName, nPlateID, nFiberID))
2265  {
2266  fAngle=FiberParams.fcs_cladding.fAngle;
2267  }
2268 
2269  return fAngle;
2270 }

◆ GetODFiberCentreYPos()

double ALFA_GeometryReader::GetODFiberCentreYPos ( const eRPotName  eRPName,
const eFiberType  eFType,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 2234 of file ALFA_GeometryReader.cxx.

2235 {
2236  double fYPos=0.0;
2237  FIBERPARAMS FiberParams;
2238 
2239  if(m_eFCoordSystem!=EFCS_CLADDING){
2240  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetODFiberCentreYPos");
2241  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
2242  return 0.0;
2243  }
2244 
2245  if(GetODFiberParams(&FiberParams, eFType, eRPName, nPlateID, nFiberID))
2246  {
2247  fYPos=FiberParams.fcs_cladding.fCentreYPos;
2248  }
2249 
2250  return fYPos;
2251 }

◆ GetODFiberOffset()

double ALFA_GeometryReader::GetODFiberOffset ( const eRPotName  eRPName,
const eFiberType  eFType,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 2384 of file ALFA_GeometryReader.cxx.

2385 {
2386  double fOffset=0.0;
2387  FIBERPARAMS FiberParams;
2388 
2389  if(m_eFCoordSystem!=EFCS_ATLAS){
2390  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetODFiberOffset");
2391  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
2392  return 0.0;
2393  }
2394 
2395  if(GetODFiberParams(&FiberParams, eFType, eRPName, nPlateID, nFiberID))
2396  {
2397  fOffset=FiberParams.fcs_atlas.fOffset;
2398  }
2399 
2400  return fOffset;
2401 }

◆ GetODFiberParams()

bool ALFA_GeometryReader::GetODFiberParams ( PFIBERPARAMS  pFiberParams,
const eFiberType  eFType,
const eRPotName  eRPName,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 2017 of file ALFA_GeometryReader.cxx.

2018 {
2019  bool bRes=false;
2020  std::list<FIBERPARAMS>::const_iterator iter;
2021  std::map<eRPotName, ROMAPOT>::const_iterator rpiter;
2022 
2023  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetODFiberParams");
2024 
2025  if ((rpiter=m_MapRPot.find(eRPName))!=m_MapRPot.end())
2026  {
2027  switch (eFType)
2028  {
2029  case EFT_ODFIBERU0:
2030  {
2031  for(iter=(*rpiter).second.ListODFibersU0.begin();iter!=(*rpiter).second.ListODFibersU0.end();++iter)
2032  {
2033  if (((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
2034  }
2035 
2036  if (iter==(*rpiter).second.ListODFibersU0.end())
2037  {
2038  LogStream<<MSG::ERROR<<"Cannot find ODFiberU0 PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
2039  //throw new G4Exception("Wrong ODFiberU0");
2040  }
2041  else
2042  {
2043  *pFiberParams = *iter;
2044  bRes=true;
2045  }
2046 
2047  break;
2048  }
2049  case EFT_ODFIBERV0:
2050  {
2051  for(iter=(*rpiter).second.ListODFibersV0.begin();iter!=(*rpiter).second.ListODFibersV0.end();++iter)
2052  {
2053  if (((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
2054  }
2055 
2056  if (iter==(*rpiter).second.ListODFibersV0.end())
2057  {
2058  LogStream<<MSG::ERROR<<"Cannot find ODFiberV0 PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
2059  //throw new G4Exception("Wrong ODFiberV0");
2060  }
2061  else
2062  {
2063  *pFiberParams = *iter;
2064  bRes=true;
2065  }
2066 
2067  break;
2068  }
2069  case EFT_ODFIBERU1:
2070  {
2071  for(iter=(*rpiter).second.ListODFibersU1.begin();iter!=(*rpiter).second.ListODFibersU1.end();++iter)
2072  {
2073  if (((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
2074  }
2075 
2076  if (iter==(*rpiter).second.ListODFibersU1.end())
2077  {
2078  LogStream<<MSG::ERROR<<"Cannot find ODFiberU1 PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
2079  //throw new G4Exception("Wrong ODFiberU1");
2080  }
2081  else
2082  {
2083  *pFiberParams = *iter;
2084  bRes=true;
2085  }
2086 
2087  break;
2088  }
2089  case EFT_ODFIBERV1:
2090  {
2091  for(iter=(*rpiter).second.ListODFibersV1.begin();iter!=(*rpiter).second.ListODFibersV1.end();++iter)
2092  {
2093  if (((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
2094  }
2095 
2096  if (iter==(*rpiter).second.ListODFibersV1.end())
2097  {
2098  LogStream<<MSG::ERROR<<"Cannot find ODFiberV1 PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
2099  //throw new G4Exception("Wrong ODFiberV1");
2100  }
2101  else
2102  {
2103  *pFiberParams = *iter;
2104  bRes=true;
2105  }
2106 
2107  break;
2108  }
2109  default:
2110  {
2111  LogStream<<MSG::ERROR<<"Unknown ODFiber eFType="<<eFType<<endmsg;
2112  break;
2113  }
2114  }
2115  }
2116  else
2117  {
2118  LogStream<<MSG::ERROR<<"Unknown Roma pot PotID="<<eRPName<<endmsg;
2119  }
2120 
2121  return bRes;
2122 }

◆ GetODFiberSlope()

double ALFA_GeometryReader::GetODFiberSlope ( const eRPotName  eRPName,
const eFiberType  eFType,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 2365 of file ALFA_GeometryReader.cxx.

2366 {
2367  double fSlope=0.0;
2368  FIBERPARAMS FiberParams;
2369 
2370  if(m_eFCoordSystem!=EFCS_ATLAS){
2371  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetODFiberSlope");
2372  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
2373  return 0.0;
2374  }
2375 
2376  if(GetODFiberParams(&FiberParams, eFType, eRPName, nPlateID, nFiberID))
2377  {
2378  fSlope=FiberParams.fcs_atlas.fSlope;
2379  }
2380 
2381  return fSlope;
2382 }

◆ GetODFiberZPos()

double ALFA_GeometryReader::GetODFiberZPos ( const eRPotName  eRPName,
const eFiberType  eFType,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 2403 of file ALFA_GeometryReader.cxx.

2404 {
2405  double fZPos=0.0;
2406  FIBERPARAMS FiberParams;
2407 
2408  if(m_eFCoordSystem!=EFCS_ATLAS){
2409  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetODFiberZPos");
2410  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
2411  return 0.0;
2412  }
2413 
2414  if(GetODFiberParams(&FiberParams, eFType, eRPName, nPlateID, nFiberID))
2415  {
2416  fZPos=FiberParams.fcs_atlas.fZPos;
2417  }
2418 
2419  return fZPos;
2420 }

◆ GetPlateParams()

bool ALFA_GeometryReader::GetPlateParams ( PPLATEPARAMS  pPlateParams,
const eRPotName  eRPName,
const int  nPlateID 
)

Definition at line 1609 of file ALFA_GeometryReader.cxx.

1610 {
1611  bool bRes=false;
1612  std::map<eRPotName, ROMAPOT>::iterator rpiter;
1613  std::map<int, PLATEPARAMS>::iterator pliter;
1614 
1615  MsgStream LogStream(Athena::getMessageSvc(),"ALFA_GeometryReader::GetPlateParams");
1616 
1617  if((rpiter=m_MapRPot.find(eRPName))!=m_MapRPot.end()){
1618  if((pliter=(*rpiter).second.MapPlates.find(nPlateID))!=(*rpiter).second.MapPlates.end()){
1619  *pPlateParams=(*pliter).second;
1620  bRes=true;
1621  }
1622  else{
1623  LogStream<<MSG::ERROR<<"Unknown Ti plate ID "<<nPlateID<<endmsg;
1624  }
1625  }
1626  else{
1627  LogStream<<MSG::ERROR<<"Unknown Roman pot PotID="<<eRPName<<endmsg;
1628  }
1629 
1630  return bRes;
1631 }

◆ GetPolyFitValue()

double ALFA_GeometryReader::GetPolyFitValue ( const double  fInputValue,
const std::vector< double > &  vecPolyFitParams 
)
private

Definition at line 2844 of file ALFA_GeometryReader.cxx.

2845 {
2846  int i,n;
2847  double fOutputValue=0.0;
2848 
2849  n=vecPolyFitParams.size();
2850 
2851  for(i=0;i<n;i++)
2852  {
2853  fOutputValue+=vecPolyFitParams[i]*pow(fInputValue,n-1-i);
2854  }
2855 
2856  return fOutputValue;
2857 }

◆ GetRPGeometryType()

eGeoSourceType ALFA_GeometryReader::GetRPGeometryType ( const eRPotName  eRPName,
eFiberType  eFType 
)

Definition at line 1968 of file ALFA_GeometryReader.cxx.

1969 {
1970  eGeoSourceType eGeoType=EGST_UNDEFINED;
1971 
1972  if(m_MapRPot.find(eRPName)!=m_MapRPot.end()){
1973  if(eFType==EFT_FIBERMD) eGeoType=m_MapRPot[eRPName].eMDGeometryType;
1974  else if(eFType==EFT_FIBEROD) eGeoType=m_MapRPot[eRPName].eODGeometryType;
1975  }
1976  else{
1977  MsgStream LogStream(Athena::getMessageSvc(),"ALFA_GeometryReader::GetRPGeometryType");
1978  LogStream<<MSG::ERROR<<"Unknown Roman pot ID="<<eRPName<<endmsg;
1979  }
1980 
1981 
1982  return eGeoType;
1983 }

◆ GetRPotCount()

int ALFA_GeometryReader::GetRPotCount ( ) const
inline

Definition at line 268 of file ALFA_GeometryReader.h.

268 { return (int)m_MapRPot.size(); }

◆ GetRPotLabel()

const char* ALFA_GeometryReader::GetRPotLabel ( const eRPotName  eRPName)
inline

Definition at line 279 of file ALFA_GeometryReader.h.

279 { return m_RPPosParams[eRPName].szLabel; }

◆ GetRPotZPosInAtlas()

double ALFA_GeometryReader::GetRPotZPosInAtlas ( const eRPotName  eRPName)

Definition at line 3041 of file ALFA_GeometryReader.cxx.

3042 {
3043  RPPOSPARAMS RPParams;
3044  GetRPPosParams(&RPParams, eRPName);
3045 
3046  return RPParams.RefPins.DCPInAtlasCS.z();
3047 }

◆ GetRPPosParams()

bool ALFA_GeometryReader::GetRPPosParams ( PRPPOSPARAMS  pRPosParams,
const eRPotName  eRPName 
)

Definition at line 1930 of file ALFA_GeometryReader.cxx.

1931 {
1932  bool bRes=false;
1933  std::map<eRPotName,RPPOSPARAMS>::iterator iter;
1934 
1935  MsgStream LogStream(Athena::getMessageSvc(),"ALFA_GeometryReader::GetRPPosParams");
1936 
1937  pRPPosParams->clear();
1938  if((iter=m_RPPosParams.find(eRPName))!=m_RPPosParams.end()){
1939  *pRPPosParams=(*iter).second;
1940  bRes=true;
1941  }
1942  else{
1943  LogStream<<MSG::ERROR<<"Unknown Roma pot ID="<<eRPName<<endmsg;
1944  }
1945 
1946  return bRes;
1947 }

◆ GetTransformMatrix()

HepGeom::Transform3D ALFA_GeometryReader::GetTransformMatrix ( const eRPotName  eRPName,
const eTransformElement  eMatrixType 
)

Definition at line 2996 of file ALFA_GeometryReader.cxx.

2997 {
2998  HepGeom::Transform3D TransMatrix;
2999  ASPOSPARAMS AParams;
3000  RPPOSPARAMS RPParams;
3001 
3002  HepGeom::Point3D<double> RPPin1=ms_NominalRPPin1;
3003  HepGeom::Point3D<double> MainPoint=ms_NominalRPMainPoint;
3004  HepGeom::Point3D<double> AlfaRefPoint=ms_NominalAlfaRefPoint;
3005 
3006  GetRPPosParams(&RPParams, eRPName);
3007  GetASPosParams(&AParams, RPParams.eASName);
3008 
3009  HepGeom::Vector3D<double> Shift1=RPPin1-MainPoint;
3010  HepGeom::Vector3D<double> Shift2=RPPin1-MainPoint+AlfaRefPoint;
3011  HepGeom::Vector3D<double> Shift3=0.5*(AParams.ShiftE+AParams.ShiftS);
3012 
3013  switch(eMatrixType)
3014  {
3015  case ETE_A1:
3016  TransMatrix=RPParams.RPTransformInStation;
3017  break;
3018  case ETE_A2:
3019  TransMatrix=RPParams.DetTransformInMainPoint;
3020  break;
3021  case ETE_A3:
3022  TransMatrix=AParams.ASTransformInATLAS;
3023  break;
3024  case ETE_T1:
3025  TransMatrix=HepGeom::Translate3D(-Shift1);
3026  break;
3027  case ETE_T2:
3028  TransMatrix=HepGeom::Translate3D(Shift2);
3029  break;
3030  case ETE_T3:
3031  TransMatrix=HepGeom::Translate3D(-Shift3);
3032  break;
3033  default:
3034  throw GaudiException(" Invalid matrix identificator ", "ALFA_GeometryReader::GetTransformMatrix", StatusCode::FAILURE);
3035  break;
3036  }
3037 
3038  return TransMatrix;
3039 }

◆ GetUFiberAngle()

double ALFA_GeometryReader::GetUFiberAngle ( const eRPotName  eRPName,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 1509 of file ALFA_GeometryReader.cxx.

1510 {
1511  double fAngle=0.0;
1512  FIBERPARAMS FiberParams;
1513 
1514  if(m_eFCoordSystem!=EFCS_CLADDING){
1515  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetUFiberAngle");
1516  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
1517  return 0.0;
1518  }
1519 
1520  if(GetUFiberParams(&FiberParams, eRPName, nPlateID, nFiberID)){
1521  fAngle=FiberParams.fcs_cladding.fAngle;
1522  }
1523 
1524  return fAngle;
1525 }

◆ GetUFiberCentreXPos()

double ALFA_GeometryReader::GetUFiberCentreXPos ( const eRPotName  eRPName,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 1473 of file ALFA_GeometryReader.cxx.

1474 {
1475  double fXPos=0.0;
1476  FIBERPARAMS FiberParams;
1477 
1478  if(m_eFCoordSystem!=EFCS_CLADDING){
1479  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetUFiberCentreXPos");
1480  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
1481  return 0.0;
1482  }
1483 
1484  if(GetUFiberParams(&FiberParams, eRPName, nPlateID, nFiberID)){
1485  fXPos=FiberParams.fcs_cladding.fCentreXPos;
1486  }
1487 
1488  return fXPos;
1489 }

◆ GetUFiberParams()

bool ALFA_GeometryReader::GetUFiberParams ( PFIBERPARAMS  pFiberParams,
const eRPotName  eRPName,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 1414 of file ALFA_GeometryReader.cxx.

1415 {
1416  bool bRes=false;
1417  std::list<FIBERPARAMS>::const_iterator iter;
1418  std::map<eRPotName, ROMAPOT>::const_iterator rpiter;
1419 
1420  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetUFiberParams");
1421 
1422  if((rpiter=m_MapRPot.find(eRPName))!=m_MapRPot.end()){
1423  for(iter=(*rpiter).second.ListUFibers.begin();iter!=(*rpiter).second.ListUFibers.end();++iter){
1424  if(((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
1425  }
1426 
1427  if(iter==(*rpiter).second.ListUFibers.end()){
1428  LogStream<<MSG::ERROR<<"Cannot find fiber PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
1429  //throw new Exception("Wrong U-fiber");
1430  }
1431  else{
1432  *pFiberParams = *iter;
1433  bRes=true;
1434  }
1435  }
1436  else{
1437  LogStream<<MSG::ERROR<<"Unknown Roman pot PotID="<<eRPName<<endmsg;
1438  }
1439 
1440  return bRes;
1441 }

◆ GetVFiberAngle()

double ALFA_GeometryReader::GetVFiberAngle ( const eRPotName  eRPName,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 1527 of file ALFA_GeometryReader.cxx.

1528 {
1529  double fAngle=0.0;
1530  FIBERPARAMS FiberParams;
1531 
1532  if(m_eFCoordSystem!=EFCS_CLADDING){
1533  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetVFiberAngle");
1534  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
1535  return 0.0;
1536  }
1537 
1538  if(GetVFiberParams(&FiberParams, eRPName, nPlateID, nFiberID)){
1539  fAngle=FiberParams.fcs_cladding.fAngle;
1540  }
1541 
1542  return fAngle;
1543 }

◆ GetVFiberCentreXPos()

double ALFA_GeometryReader::GetVFiberCentreXPos ( const eRPotName  eRPName,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 1491 of file ALFA_GeometryReader.cxx.

1492 {
1493  double fXPos=0.0;
1494  FIBERPARAMS FiberParams;
1495 
1496  if(m_eFCoordSystem!=EFCS_CLADDING){
1497  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetVFiberCentreXPos");
1498  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
1499  return 0.0;
1500  }
1501 
1502  if(GetVFiberParams(&FiberParams, eRPName, nPlateID, nFiberID)){
1503  fXPos=FiberParams.fcs_cladding.fCentreXPos;
1504  }
1505 
1506  return fXPos;
1507 }

◆ GetVFiberParams()

bool ALFA_GeometryReader::GetVFiberParams ( PFIBERPARAMS  pFiberParams,
const eRPotName  eRPName,
const int  nPlateID,
const int  nFiberID 
)

Definition at line 1443 of file ALFA_GeometryReader.cxx.

1444 {
1445  bool bRes=false;
1446  std::list<FIBERPARAMS>::const_iterator iter;
1447  std::map<eRPotName, ROMAPOT>::const_iterator rpiter;
1448 
1449  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::GetVFiberParams");
1450 
1451  if((rpiter=m_MapRPot.find(eRPName))!=m_MapRPot.end()){
1452  for(iter=(*rpiter).second.ListVFibers.begin();iter!=(*rpiter).second.ListVFibers.end();++iter){
1453  if(((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
1454  }
1455 
1456  if(iter==(*rpiter).second.ListVFibers.end()) {
1457  LogStream<<MSG::ERROR<<"Cannot find fiber PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
1458  //throw new Exception("Wrong U-fiber");
1459  }
1460  else{
1461  *pFiberParams = *iter;
1462  bRes=true;
1463  }
1464  }
1465  else{
1466  LogStream<<MSG::ERROR<<"Unknown Roman pot PotID="<<eRPName<<endmsg;
1467  }
1468 
1469 
1470  return bRes;
1471 }

◆ Initialize()

bool ALFA_GeometryReader::Initialize ( const PGEOMETRYCONFIGURATION  pConfig,
eFiberCoordSystem  eFCoordSystem 
)

Definition at line 688 of file ALFA_GeometryReader.cxx.

689 {
690  int i;
691  bool bRes=true;
692  std::string FilePath;
693  m_eFCoordSystem=eFCoordSystem;
694 
695  if(pConfig!=nullptr)
696  {
697  if(InitializeDefault(pConfig))
698  {
699  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::Initialize");
700  LogStream<<MSG::INFO<<"Metrology type:"<<pConfig->eRPMetrologyGeoType<<endmsg;
701  LogStream<<MSG::INFO<<"Metrology source:"<<pConfig->strRPMetrologyConnString<<endmsg;
702 
703  if(pConfig->bShiftToX97Pos)
704  {
705  m_ASPosParams[EASN_B7L1].ASTransformInATLAS=HepGeom::TranslateX3D(-97.0*CLHEP::mm)*m_ASPosParams[EASN_B7L1].ASTransformInATLAS;
706  m_ASPosParams[EASN_A7L1].ASTransformInATLAS=HepGeom::TranslateX3D(-97.0*CLHEP::mm)*m_ASPosParams[EASN_A7L1].ASTransformInATLAS;
707  m_ASPosParams[EASN_A7R1].ASTransformInATLAS=HepGeom::TranslateX3D(-97.0*CLHEP::mm)*m_ASPosParams[EASN_A7R1].ASTransformInATLAS;
708  m_ASPosParams[EASN_B7R1].ASTransformInATLAS=HepGeom::TranslateX3D(-97.0*CLHEP::mm)*m_ASPosParams[EASN_B7R1].ASTransformInATLAS;
709  }
710 
711  m_eMetrologyType=(eMetrologyType)pConfig->eRPMetrologyGeoType;
712  if(m_eMetrologyType==EMT_NOMINAL){
713  SetupUserCorrections(pConfig);
714  }
715  else if(m_eMetrologyType==EMT_METROLOGY) {
716  SetupCurrentLVDT(pConfig);
717 
718  if(pConfig->strRPMetrologyConnString==std::string("")) FilePath = PathResolver::find_file(METROLOGYFILE,"DATAPATH", PathResolver::RecursiveSearch);
719  else FilePath=pConfig->strRPMetrologyConnString;
720  LogStream<<MSG::INFO<<"Metrology data loaded from file "<<FilePath<<endmsg;
721  bRes=ParseRPMetrology(EGST_FILE,FilePath.c_str());
722  if(bRes) {
723  UpdateStationsPosParams();
724  }
725  else return false;
726  }
727  else if(m_eMetrologyType==EMT_SWCORRECTIONS){
728  SetupSWCorrections(pConfig);
729  }
730  else if(m_eMetrologyType==EMT_UNDEFINED){
731  //do nothing, there will be no shift to regular positions
732  }
733  else{
734  throw GaudiException(" Unknown metrology type ", "ALFA_GeometryReader::Initialize", StatusCode::FAILURE);
735  }
736 
737  for(i=1;i<=RPOTSCNT;i++)
738  {
739  eRPotName eName=(eRPotName)i;
740 
741  if(pConfig->eRPMetrologyGeoType!=EMT_UNDEFINED) UpdateSimRPPos(eName);
742  m_ListExistingRPots.push_back(eName);
743  }
744 
745  }
746  }
747  else
748  {
749  m_ListExistingRPots.push_back(ERPN_B7L1U);
750  m_ListExistingRPots.push_back(ERPN_B7L1L);
751  m_ListExistingRPots.push_back(ERPN_A7L1U);
752  m_ListExistingRPots.push_back(ERPN_A7L1L);
753  m_ListExistingRPots.push_back(ERPN_A7R1U);
754  m_ListExistingRPots.push_back(ERPN_A7R1L);
755  m_ListExistingRPots.push_back(ERPN_B7R1U);
756  m_ListExistingRPots.push_back(ERPN_B7R1L);
757  }
758 
759  //2010-11-04 (LN): ReadGeometry removed and it should be called by user due to SW transformation feature
760  //2012-08-03 (LN): back to call ReadGeometry because user corrections implemented to geometry consfiguration structure
761  //read fiber geometry
762  bRes=ReadFiberGeometry(pConfig);
763 
764  return bRes;
765 }

◆ InitializeDefault()

bool ALFA_GeometryReader::InitializeDefault ( const PGEOMETRYCONFIGURATION  pConfig)
private

Definition at line 446 of file ALFA_GeometryReader.cxx.

447 {
448  RPPOSPARAMS RPPosParams;
449  ASPOSPARAMS ASPosParams;
450 
451  m_MapRPot.clear();
452  m_RPPosParams.clear();
453  m_ListExistingRPots.clear();
454 
455  //double fGlobalYOffset=DETEDGEDISTANCE;
456  double fYOffset;
457 
458  // ALFA Station positions
459  //B7L1
460  ASPosParams.clear();
461  strcpy(ASPosParams.szLabel,"B7L1");
462  ASPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm,0.0*CLHEP::mm,pConfig->fNominalZPosB7L1+10.0*CLHEP::mm); //241538.0
463  ASPosParams.ASTransformInATLAS=HepGeom::Translate3D(0.0*CLHEP::mm,0.0*CLHEP::mm,ASPosParams.IdealMainPoint[2]);
464  m_ASPosParams.insert(std::pair<eAStationName,ASPOSPARAMS>(EASN_B7L1,ASPosParams));
465  //A7L1
466  ASPosParams.clear();
467  strcpy(ASPosParams.szLabel,"A7L1");
468  ASPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm,0.0*CLHEP::mm,pConfig->fNominalZPosA7L1+10.0*CLHEP::mm); //237398.0
469  ASPosParams.ASTransformInATLAS=HepGeom::Translate3D(0.0*CLHEP::mm,0.0*CLHEP::mm,ASPosParams.IdealMainPoint[2]);
470  m_ASPosParams.insert(std::pair<eAStationName,ASPOSPARAMS>(EASN_A7L1,ASPosParams));
471  //A7R1
472  ASPosParams.clear();
473  strcpy(ASPosParams.szLabel,"A7R1");
474  ASPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm,0.0*CLHEP::mm,pConfig->fNominalZPosA7R1+10.0*CLHEP::mm); //-237398 (old:-237418.0)
475  ASPosParams.ASTransformInATLAS=HepGeom::Translate3D(0.0*CLHEP::mm,0.0*CLHEP::mm,ASPosParams.IdealMainPoint[2]);
476  m_ASPosParams.insert(std::pair<eAStationName,ASPOSPARAMS>(EASN_A7R1,ASPosParams));
477  //B7R1
478  ASPosParams.clear();
479  strcpy(ASPosParams.szLabel,"B7R1");
480  ASPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm,0.0*CLHEP::mm,pConfig->fNominalZPosB7R1+10.0*CLHEP::mm); //-241538 (old:-241558.0)
481  ASPosParams.ASTransformInATLAS=HepGeom::Translate3D(0.0*CLHEP::mm,0.0*CLHEP::mm,ASPosParams.IdealMainPoint[2]);
482  m_ASPosParams.insert(std::pair<eAStationName,ASPOSPARAMS>(EASN_B7R1,ASPosParams));
483 
484  // Roma Pot positions
485  //B7L1U -1 --------------------------------------------
486  RPPosParams.clear();
487  strcpy(RPPosParams.szLabel,"B7L1U");
488  RPPosParams.eASName=EASN_B7L1;
489  RPPosParams.bIsLow=false;
490  fYOffset=(pConfig->CfgRPosParams[0].eRPPosType==ERPPT_ACTIVE)? DETEDGEDISTANCE:INACTIVEDETEGDEDISTANCE;
491  RPPosParams.IdealRefPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, 136.5*CLHEP::mm, m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2]-10.0*CLHEP::mm); //241528.0
492  RPPosParams.IdealMainPointInStation=HepGeom::Point3D<double>(0.0*CLHEP::mm, (29.525+fYOffset)*CLHEP::mm,18.0*CLHEP::mm);
493  RPPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, (29.525+fYOffset)*CLHEP::mm, RPPosParams.IdealRefPoint[2]+18.0*CLHEP::mm);
494  RPPosParams.RPIdealTransformInStation=HepGeom::Translate3D(RPPosParams.IdealMainPoint[0]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[0],
495  RPPosParams.IdealMainPoint[1]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[1],
496  RPPosParams.IdealMainPoint[2]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2])*HepGeom::RotateX3D(RPPosParams.bIsLow? 180*CLHEP::deg:0*CLHEP::deg);
497  //RPPosParams.RPTransformInStation=RPPosParams.RPIdealTransformInStation;
498  RPPosParams.RPTransformInStation=HepGeom::Transform3D();
499  RPPosParams.RPSWTransformInStation=HepGeom::Transform3D();
500  RPPosParams.DetTransformInMainPoint=HepGeom::Transform3D();
501  RPPosParams.DetIdealTransformInMainPoint=RPPosParams.DetTransformInMainPoint;
502  RPPosParams.DetSWTransformInMainPoint=HepGeom::Transform3D();
503  RPPosParams.RefPins.IdealRPPin1=HepGeom::Point3D<double>(+77.5*CLHEP::mm,+172.2*CLHEP::mm,-124.0*CLHEP::mm);
504  RPPosParams.RefPins.IdealRPPin2=HepGeom::Point3D<double>(-77.5*CLHEP::mm,+172.2*CLHEP::mm,+124.0*CLHEP::mm);
505  RPPosParams.RefPins.IdealRPPin3=HepGeom::Point3D<double>(-77.5*CLHEP::mm,+172.2*CLHEP::mm,-124.0*CLHEP::mm);
506  RPPosParams.RefPins.DTPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,0.0*CLHEP::mm);
507  RPPosParams.RefPins.DCPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,+10.0*CLHEP::mm);
508  m_RPPosParams.insert(std::pair<eRPotName,RPPOSPARAMS>(ERPN_B7L1U,RPPosParams));
509 
510  //B7L1L -2
511  RPPosParams.clear();
512  strcpy(RPPosParams.szLabel,"B7L1L");
513  RPPosParams.eASName=EASN_B7L1;
514  RPPosParams.bIsLow=true;
515  fYOffset=(pConfig->CfgRPosParams[1].eRPPosType==ERPPT_ACTIVE)? DETEDGEDISTANCE:INACTIVEDETEGDEDISTANCE;
516  RPPosParams.IdealRefPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, -136.5*CLHEP::mm, m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2]+10.0*CLHEP::mm); //241548.0
517  RPPosParams.IdealMainPointInStation=HepGeom::Point3D<double>(0.0*CLHEP::mm, -(29.525+fYOffset)*CLHEP::mm,-18.0*CLHEP::mm);
518  RPPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, -(29.525+fYOffset)*CLHEP::mm, RPPosParams.IdealRefPoint[2]-18.0*CLHEP::mm);
519  RPPosParams.RPIdealTransformInStation=HepGeom::Translate3D(RPPosParams.IdealMainPoint[0]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[0],
520  RPPosParams.IdealMainPoint[1]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[1],
521  RPPosParams.IdealMainPoint[2]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2])*HepGeom::RotateX3D(RPPosParams.bIsLow? 180*CLHEP::deg:0*CLHEP::deg);
522  //RPPosParams.RPTransformInStation=RPPosParams.RPIdealTransformInStation;
523  RPPosParams.RPTransformInStation=HepGeom::Transform3D();
524  RPPosParams.RPSWTransformInStation=HepGeom::Transform3D();
525  RPPosParams.DetTransformInMainPoint=HepGeom::Transform3D();
526  RPPosParams.DetIdealTransformInMainPoint=RPPosParams.DetTransformInMainPoint;
527  RPPosParams.DetSWTransformInMainPoint=HepGeom::Transform3D();
528  RPPosParams.RefPins.IdealRPPin1=HepGeom::Point3D<double>(+77.5*CLHEP::mm,-172.2*CLHEP::mm,+124.0*CLHEP::mm);
529  RPPosParams.RefPins.IdealRPPin2=HepGeom::Point3D<double>(-77.5*CLHEP::mm,-172.2*CLHEP::mm,-124.0*CLHEP::mm);
530  RPPosParams.RefPins.IdealRPPin3=HepGeom::Point3D<double>(-77.5*CLHEP::mm,-172.2*CLHEP::mm,+124.0*CLHEP::mm);
531  RPPosParams.RefPins.DTPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,0.0*CLHEP::mm);//HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.012*CLHEP::mm,0.0*CLHEP::mm);
532  RPPosParams.RefPins.DCPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,+10.0*CLHEP::mm);
533  m_RPPosParams.insert(std::pair<eRPotName,RPPOSPARAMS>(ERPN_B7L1L,RPPosParams));
534 
535  //A7L1U -3 --------------------------------------------
536  RPPosParams.clear();
537  strcpy(RPPosParams.szLabel,"A7L1U");
538  RPPosParams.eASName=EASN_A7L1;
539  RPPosParams.bIsLow=false;
540  fYOffset=(pConfig->CfgRPosParams[2].eRPPosType==ERPPT_ACTIVE)? DETEDGEDISTANCE:INACTIVEDETEGDEDISTANCE;
541  RPPosParams.IdealRefPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, 136.5*CLHEP::mm, m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2]-10.0*CLHEP::mm); //237388.0
542  RPPosParams.IdealMainPointInStation=HepGeom::Point3D<double>(0.0*CLHEP::mm, (29.525+fYOffset)*CLHEP::mm,+18.0*CLHEP::mm);
543  RPPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, (29.525+fYOffset)*CLHEP::mm, RPPosParams.IdealRefPoint[2]+18.0*CLHEP::mm);
544  RPPosParams.RPIdealTransformInStation=HepGeom::Translate3D(RPPosParams.IdealMainPoint[0]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[0],
545  RPPosParams.IdealMainPoint[1]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[1],
546  RPPosParams.IdealMainPoint[2]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2])*HepGeom::RotateX3D(RPPosParams.bIsLow? 180*CLHEP::deg:0*CLHEP::deg);
547  //RPPosParams.RPTransformInStation=RPPosParams.RPIdealTransformInStation;
548  RPPosParams.RPTransformInStation=HepGeom::Transform3D();
549  RPPosParams.RPSWTransformInStation=HepGeom::Transform3D();
550  RPPosParams.DetTransformInMainPoint=HepGeom::Transform3D();
551  RPPosParams.DetIdealTransformInMainPoint=RPPosParams.DetTransformInMainPoint;
552  RPPosParams.DetSWTransformInMainPoint=HepGeom::Transform3D();
553  RPPosParams.RefPins.IdealRPPin1=HepGeom::Point3D<double>(+77.5*CLHEP::mm,+172.2*CLHEP::mm,-124.0*CLHEP::mm);
554  RPPosParams.RefPins.IdealRPPin2=HepGeom::Point3D<double>(-77.5*CLHEP::mm,+172.2*CLHEP::mm,+124.0*CLHEP::mm);
555  RPPosParams.RefPins.IdealRPPin3=HepGeom::Point3D<double>(-77.5*CLHEP::mm,+172.2*CLHEP::mm,-124.0*CLHEP::mm);
556  RPPosParams.RefPins.DTPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,0.0*CLHEP::mm);//HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.034*CLHEP::mm,0.0*CLHEP::mm);
557  RPPosParams.RefPins.DCPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,+10.0*CLHEP::mm);
558  m_RPPosParams.insert(std::pair<eRPotName,RPPOSPARAMS>(ERPN_A7L1U,RPPosParams));
559 
560  //A7L1L -4
561  RPPosParams.clear();
562  strcpy(RPPosParams.szLabel,"A7L1L");
563  RPPosParams.eASName=EASN_A7L1;
564  RPPosParams.bIsLow=true;
565  fYOffset=(pConfig->CfgRPosParams[3].eRPPosType==ERPPT_ACTIVE)? DETEDGEDISTANCE:INACTIVEDETEGDEDISTANCE;
566  RPPosParams.IdealRefPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, -136.5*CLHEP::mm, m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2]+10.0*CLHEP::mm); //237408.0
567  RPPosParams.IdealMainPointInStation=HepGeom::Point3D<double>(0.0*CLHEP::mm, -(29.525+fYOffset)*CLHEP::mm,-18.0*CLHEP::mm);
568  RPPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, -(29.525+fYOffset)*CLHEP::mm, RPPosParams.IdealRefPoint[2]-18.0*CLHEP::mm);
569  RPPosParams.RPIdealTransformInStation=HepGeom::Translate3D(RPPosParams.IdealMainPoint[0]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[0],
570  RPPosParams.IdealMainPoint[1]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[1],
571  RPPosParams.IdealMainPoint[2]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2])*HepGeom::RotateX3D(RPPosParams.bIsLow? 180*CLHEP::deg:0*CLHEP::deg);
572  //RPPosParams.RPTransformInStation=RPPosParams.RPIdealTransformInStation;
573  RPPosParams.RPTransformInStation=HepGeom::Transform3D();
574  RPPosParams.RPSWTransformInStation=HepGeom::Transform3D();
575  RPPosParams.DetTransformInMainPoint=HepGeom::Transform3D();
576  RPPosParams.DetIdealTransformInMainPoint=RPPosParams.DetTransformInMainPoint;
577  RPPosParams.DetSWTransformInMainPoint=HepGeom::Transform3D();
578  RPPosParams.RefPins.IdealRPPin1=HepGeom::Point3D<double>(+77.5*CLHEP::mm,-172.2*CLHEP::mm,+124.0*CLHEP::mm);
579  RPPosParams.RefPins.IdealRPPin2=HepGeom::Point3D<double>(-77.5*CLHEP::mm,-172.2*CLHEP::mm,-124.0*CLHEP::mm);
580  RPPosParams.RefPins.IdealRPPin3=HepGeom::Point3D<double>(-77.5*CLHEP::mm,-172.2*CLHEP::mm,+124.0*CLHEP::mm);
581  RPPosParams.RefPins.DTPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,0.0*CLHEP::mm);//HepGeom::Point3D<double>(0.0*CLHEP::mm,-134.948*CLHEP::mm,0.0*CLHEP::mm);
582  RPPosParams.RefPins.DCPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,+10.0*CLHEP::mm);
583  m_RPPosParams.insert(std::pair<eRPotName,RPPOSPARAMS>(ERPN_A7L1L,RPPosParams));
584 
585  //A7R1U -5 --------------------------------------------
586  RPPosParams.clear();
587  strcpy(RPPosParams.szLabel,"A7R1U");
588  RPPosParams.eASName=EASN_A7R1;
589  RPPosParams.bIsLow=false;
590  fYOffset=(pConfig->CfgRPosParams[4].eRPPosType==ERPPT_ACTIVE)? DETEDGEDISTANCE:INACTIVEDETEGDEDISTANCE;
591  RPPosParams.IdealRefPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, 136.5*CLHEP::mm, m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2]-10.0*CLHEP::mm); //-237408.0
592  RPPosParams.IdealMainPointInStation=HepGeom::Point3D<double>(0.0*CLHEP::mm, (29.525+fYOffset)*CLHEP::mm,+18.0*CLHEP::mm);
593  RPPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, (29.525+fYOffset)*CLHEP::mm, RPPosParams.IdealRefPoint[2]+18.0*CLHEP::mm);
594  RPPosParams.RPIdealTransformInStation=HepGeom::Translate3D(RPPosParams.IdealMainPoint[0]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[0],
595  RPPosParams.IdealMainPoint[1]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[1],
596  RPPosParams.IdealMainPoint[2]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2])*HepGeom::RotateX3D(RPPosParams.bIsLow? 180*CLHEP::deg:0*CLHEP::deg);
597  //RPPosParams.RPTransformInStation=RPPosParams.RPIdealTransformInStation;
598  RPPosParams.RPTransformInStation=HepGeom::Transform3D();
599  RPPosParams.RPSWTransformInStation=HepGeom::Transform3D();
600  RPPosParams.DetTransformInMainPoint=HepGeom::Transform3D();
601  RPPosParams.DetIdealTransformInMainPoint=RPPosParams.DetTransformInMainPoint;
602  RPPosParams.DetSWTransformInMainPoint=HepGeom::Transform3D();
603  RPPosParams.RefPins.IdealRPPin1=HepGeom::Point3D<double>(+77.5*CLHEP::mm,+172.2*CLHEP::mm,-124.0*CLHEP::mm);
604  RPPosParams.RefPins.IdealRPPin2=HepGeom::Point3D<double>(-77.5*CLHEP::mm,+172.2*CLHEP::mm,+124.0*CLHEP::mm);
605  RPPosParams.RefPins.IdealRPPin3=HepGeom::Point3D<double>(-77.5*CLHEP::mm,+172.2*CLHEP::mm,-124.0*CLHEP::mm);
606  RPPosParams.RefPins.DTPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,0.0*CLHEP::mm);//HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.08*CLHEP::mm,0.0*CLHEP::mm);
607  RPPosParams.RefPins.DCPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,+10.0*CLHEP::mm);
608  m_RPPosParams.insert(std::pair<eRPotName,RPPOSPARAMS>(ERPN_A7R1U,RPPosParams));
609 
610  //A7R1L -6
611  RPPosParams.clear();
612  strcpy(RPPosParams.szLabel,"A7R1L");
613  RPPosParams.eASName=EASN_A7R1;
614  RPPosParams.bIsLow=true;
615  fYOffset=(pConfig->CfgRPosParams[5].eRPPosType==ERPPT_ACTIVE)? DETEDGEDISTANCE:INACTIVEDETEGDEDISTANCE;
616  RPPosParams.IdealRefPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, -136.5*CLHEP::mm, m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2]+10.0*CLHEP::mm); //-237388.0
617  RPPosParams.IdealMainPointInStation=HepGeom::Point3D<double>(0.0*CLHEP::mm, -(29.525+fYOffset)*CLHEP::mm,-18.0*CLHEP::mm);
618  RPPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, -(29.525+fYOffset)*CLHEP::mm, RPPosParams.IdealRefPoint[2]-18.0*CLHEP::mm);
619  RPPosParams.RPIdealTransformInStation=HepGeom::Translate3D(RPPosParams.IdealMainPoint[0]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[0],
620  RPPosParams.IdealMainPoint[1]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[1],
621  RPPosParams.IdealMainPoint[2]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2])*HepGeom::RotateX3D(RPPosParams.bIsLow? 180*CLHEP::deg:0*CLHEP::deg);
622  //RPPosParams.RPTransformInStation=RPPosParams.RPIdealTransformInStation;
623  RPPosParams.RPTransformInStation=HepGeom::Transform3D();
624  RPPosParams.RPSWTransformInStation=HepGeom::Transform3D();
625  RPPosParams.DetTransformInMainPoint=HepGeom::Transform3D();
626  RPPosParams.DetIdealTransformInMainPoint=RPPosParams.DetTransformInMainPoint;
627  RPPosParams.DetSWTransformInMainPoint=HepGeom::Transform3D();
628  RPPosParams.RefPins.IdealRPPin1=HepGeom::Point3D<double>(+77.5*CLHEP::mm,-172.2*CLHEP::mm,+124.0*CLHEP::mm);
629  RPPosParams.RefPins.IdealRPPin2=HepGeom::Point3D<double>(-77.5*CLHEP::mm,-172.2*CLHEP::mm,-124.0*CLHEP::mm);
630  RPPosParams.RefPins.IdealRPPin3=HepGeom::Point3D<double>(-77.5*CLHEP::mm,-172.2*CLHEP::mm,+124.0*CLHEP::mm);
631  RPPosParams.RefPins.DTPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,0.0*CLHEP::mm);//HepGeom::Point3D<double>(0.0*CLHEP::mm,-134.995*CLHEP::mm,0.0*CLHEP::mm);
632  RPPosParams.RefPins.DCPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,+10.0*CLHEP::mm);
633  m_RPPosParams.insert(std::pair<eRPotName,RPPOSPARAMS>(ERPN_A7R1L,RPPosParams));
634 
635  //B7R1U -7 --------------------------------------------
636  RPPosParams.clear();
637  strcpy(RPPosParams.szLabel,"B7R1U");
638  RPPosParams.eASName=EASN_B7R1;
639  RPPosParams.bIsLow=false;
640  fYOffset=(pConfig->CfgRPosParams[6].eRPPosType==ERPPT_ACTIVE)? DETEDGEDISTANCE:INACTIVEDETEGDEDISTANCE;
641  RPPosParams.IdealRefPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, 136.5*CLHEP::mm, m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2]-10.0*CLHEP::mm); //-241548.0
642  RPPosParams.IdealMainPointInStation=HepGeom::Point3D<double>(0.0*CLHEP::mm, (29.525+fYOffset)*CLHEP::mm,+18.0*CLHEP::mm);
643  RPPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, (29.525+fYOffset)*CLHEP::mm, RPPosParams.IdealRefPoint[2]+18.0*CLHEP::mm);
644  RPPosParams.RPIdealTransformInStation=HepGeom::Translate3D(RPPosParams.IdealMainPoint[0]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[0],
645  RPPosParams.IdealMainPoint[1]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[1],
646  RPPosParams.IdealMainPoint[2]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2])*HepGeom::RotateX3D(RPPosParams.bIsLow? 180*CLHEP::deg:0*CLHEP::deg);
647  //RPPosParams.RPTransformInStation=RPPosParams.RPIdealTransformInStation;
648  RPPosParams.RPTransformInStation=HepGeom::Transform3D();
649  RPPosParams.RPSWTransformInStation=HepGeom::Transform3D();
650  RPPosParams.DetTransformInMainPoint=HepGeom::Transform3D();
651  RPPosParams.DetIdealTransformInMainPoint=RPPosParams.DetTransformInMainPoint;
652  RPPosParams.DetSWTransformInMainPoint=HepGeom::Transform3D();
653  RPPosParams.RefPins.IdealRPPin1=HepGeom::Point3D<double>(+77.5*CLHEP::mm,+172.2*CLHEP::mm,-124.0*CLHEP::mm);
654  RPPosParams.RefPins.IdealRPPin2=HepGeom::Point3D<double>(-77.5*CLHEP::mm,+172.2*CLHEP::mm,+124.0*CLHEP::mm);
655  RPPosParams.RefPins.IdealRPPin3=HepGeom::Point3D<double>(-77.5*CLHEP::mm,+172.2*CLHEP::mm,-124.0*CLHEP::mm);
656  RPPosParams.RefPins.DTPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,0.0*CLHEP::mm);//HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.005*CLHEP::mm,0.0*CLHEP::mm);
657  RPPosParams.RefPins.DCPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,+10.0*CLHEP::mm);
658  m_RPPosParams.insert(std::pair<eRPotName,RPPOSPARAMS>(ERPN_B7R1U,RPPosParams));
659 
660  //B7R1L -8
661  RPPosParams.clear();
662  strcpy(RPPosParams.szLabel,"B7R1L");
663  RPPosParams.eASName=EASN_B7R1;
664  RPPosParams.bIsLow=true;
665  fYOffset=(pConfig->CfgRPosParams[7].eRPPosType==ERPPT_ACTIVE)? DETEDGEDISTANCE:INACTIVEDETEGDEDISTANCE;
666  RPPosParams.IdealRefPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, -136.5*CLHEP::mm, m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2]+10.0*CLHEP::mm); //-241528.0
667  RPPosParams.IdealMainPointInStation=HepGeom::Point3D<double>(0.0*CLHEP::mm, -(29.525+fYOffset)*CLHEP::mm,-18.0*CLHEP::mm);
668  RPPosParams.IdealMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm, -(29.525+fYOffset)*CLHEP::mm, RPPosParams.IdealRefPoint[2]-18.0*CLHEP::mm);
669  RPPosParams.RPIdealTransformInStation=HepGeom::Translate3D(RPPosParams.IdealMainPoint[0]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[0],
670  RPPosParams.IdealMainPoint[1]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[1],
671  RPPosParams.IdealMainPoint[2]-m_ASPosParams[RPPosParams.eASName].IdealMainPoint[2])*HepGeom::RotateX3D(RPPosParams.bIsLow? 180*CLHEP::deg:0*CLHEP::deg);
672  //RPPosParams.RPTransformInStation=RPPosParams.RPIdealTransformInStation;
673  RPPosParams.RPTransformInStation=HepGeom::Transform3D();
674  RPPosParams.RPSWTransformInStation=HepGeom::Transform3D();
675  RPPosParams.DetTransformInMainPoint=HepGeom::Transform3D();
676  RPPosParams.DetIdealTransformInMainPoint=RPPosParams.DetTransformInMainPoint;
677  RPPosParams.DetSWTransformInMainPoint=HepGeom::Transform3D();
678  RPPosParams.RefPins.IdealRPPin1=HepGeom::Point3D<double>(+77.5*CLHEP::mm,-172.2*CLHEP::mm,+124.0*CLHEP::mm);
679  RPPosParams.RefPins.IdealRPPin2=HepGeom::Point3D<double>(-77.5*CLHEP::mm,-172.2*CLHEP::mm,-124.0*CLHEP::mm);
680  RPPosParams.RefPins.IdealRPPin3=HepGeom::Point3D<double>(-77.5*CLHEP::mm,-172.2*CLHEP::mm,+124.0*CLHEP::mm);
681  RPPosParams.RefPins.DTPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,0.0*CLHEP::mm);//HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.021*CLHEP::mm,0.0*CLHEP::mm);
682  RPPosParams.RefPins.DCPInAlfaCS=HepGeom::Point3D<double>(0.0*CLHEP::mm,-135.0*CLHEP::mm,+10.0*CLHEP::mm);
683  m_RPPosParams.insert(std::pair<eRPotName,RPPOSPARAMS>(ERPN_B7R1L,RPPosParams));
684 
685  return true;
686 }

◆ ParseArrayOfValues()

bool ALFA_GeometryReader::ParseArrayOfValues ( const char *  szvalue,
std::vector< double > &  vecValues 
)
private

Definition at line 2591 of file ALFA_GeometryReader.cxx.

2592 {
2593  bool bRes=true;
2594  double faux;
2595  char *ppos1,*ppos2,*pstop;
2596  char szbuff[512];
2597 
2598  vecValues.clear();
2599  memset(szbuff,0,sizeof(szbuff));
2600  if(szvalue) strncpy(szbuff,szvalue,sizeof(szbuff)-1);
2601 
2602  ppos1=szbuff;
2603  ppos2=strchr(ppos1,',');
2604  if(ppos2!=nullptr){
2605  while(ppos2!=nullptr){
2606  *ppos2=0;
2607 
2608  faux=strtod(ppos1,&pstop);
2609  if(pstop==ppos2) vecValues.push_back(faux);
2610  else{
2611  bRes=false;
2612  break;
2613  }
2614 
2615  ppos1=ppos2+1;
2616  ppos2=strchr(ppos1,',');
2617  }
2618 
2619  //load last value
2620  faux=strtod(ppos1,&pstop);
2621  if(*pstop==0) vecValues.push_back(faux);
2622  else bRes=false;
2623  }
2624 
2625  if(!bRes) vecValues.clear();
2626 
2627  return bRes;
2628 }

◆ ParseRefPoints()

bool ALFA_GeometryReader::ParseRefPoints ( const char *  szvalue,
std::vector< HepGeom::Point3D< double > > &  vecRefPoints,
eMetrologyCoordSystem  eCSystem 
)
private

Definition at line 2515 of file ALFA_GeometryReader.cxx.

2516 {
2517  double fx,fy,fz,faux;
2518  char *ppos1,*ppos2,*ppos3,*ppos4,*pstop;
2519  char szbuff[513];
2520  HepGeom::Point3D<double> RefPoint;
2521 
2522  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::ParseRefPoints");
2523 
2524  memset(szbuff,0,sizeof(szbuff));
2525  strcpy(szbuff,szvalue);
2526 
2527  //get point count
2528  int i,nCnt=0;
2529  ppos2=szbuff;
2530  while((ppos1=strchr(ppos2,'['))!=nullptr){
2531  if(!(ppos2=strchr(ppos1+1,']'))) return false;
2532  ppos2++;
2533  nCnt++;
2534  }
2535 
2536  if(nCnt==0) return false;
2537  vecRefPoints.resize(nCnt);
2538 
2539  i=0;
2540  ppos2=szbuff;
2541  while((ppos1=strchr(ppos2,'['))!=nullptr){
2542  if(!(ppos2=strchr(ppos1,']'))) return false;
2543 
2544  //x-coordinate
2545  ppos3=ppos1+1;
2546  if(!(ppos4=strchr(ppos3+1,','))) return false;
2547  *ppos4=0;
2548  faux=strtod(ppos3,&pstop);
2549  if(pstop!=ppos4 && *pstop!=' ') return false;
2550  else fx=faux;
2551 
2552  //y-coordinate
2553  ppos3=ppos4+1;
2554  if(!(ppos4=strchr(ppos3+1,','))) return false;
2555  *ppos4=0;
2556  faux=strtod(ppos3,&pstop);
2557  if(pstop!=ppos4 && *pstop!=' ') return false;
2558  else fy=faux;
2559 
2560  //z-coordinate
2561  ppos3=ppos4+1;
2562  if(!(ppos4=strchr(ppos3+1,']'))) return false;
2563  *ppos4=0;
2564  faux=strtod(ppos3,&pstop);
2565  if(pstop!=ppos4 && *pstop!=' ') return false;
2566  else fz=faux;
2567 
2568  //rearanging coordinates to ATLAS scheme
2569  if(eCSystem==EMCS_ATLAS){
2570  RefPoint[0]=fx; RefPoint[1]=fy; RefPoint[2]=fz; // no swap
2571  }
2572  else if(eCSystem==EMCS_STATION){
2573  RefPoint[0]=fx; RefPoint[1]=fz; RefPoint[2]=-fy;
2574  }
2575  else if(eCSystem==EMCS_ROMANPOT){
2576  RefPoint[0]=fx; RefPoint[1]=-fz; RefPoint[2]=fy;
2577  }
2578  else if(eCSystem==EMCS_DETPIN1){
2579  RefPoint[0]=fx; RefPoint[1]=fy; RefPoint[2]=fz; // no swap
2580  }
2581  else throw new GaudiException("Invalid type of metrology coordinate system", "ALFA_GeometryReader::ParseRefPoints", StatusCode::FAILURE);
2582 
2583  vecRefPoints[i++]=RefPoint;
2584 
2585  ppos2++;
2586  }
2587 
2588  return true;
2589 }

◆ ParseRPMetrology()

bool ALFA_GeometryReader::ParseRPMetrology ( eGeoSourceType  eSourceType,
const char *  szDataSource 
)
private

Definition at line 2422 of file ALFA_GeometryReader.cxx.

2423 {
2424  bool bRes=false;
2425 
2426  eRPotName eRPName=ERPN_UNDEFINED;
2427  ALFA_ConfigParams CfgParams;
2428 
2429  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::ParseRPMetrology");
2430 
2431  if(eSourceType==EGST_FILE){
2432  // resolve ALFA Stations parameters
2433  if(CfgParams.Init(szDataSource,"[B7L1]")==0) return false;
2434  if(!SetupStationMetrologyPoints(CfgParams,EASN_B7L1)) return false;
2435 
2436  if(CfgParams.Init(szDataSource,"[A7L1]")==0) return false;
2437  if(!SetupStationMetrologyPoints(CfgParams,EASN_A7L1)) return false;
2438 
2439  if(CfgParams.Init(szDataSource,"[A7R1]")==0) return false;
2440  if(!SetupStationMetrologyPoints(CfgParams,EASN_A7R1)) return false;
2441 
2442  if(CfgParams.Init(szDataSource,"[B7R1]")==0) return false;
2443  if(!SetupStationMetrologyPoints(CfgParams,EASN_B7R1)) return false;
2444 
2445  // resolve Romain Pots parameters
2446  eRPName=ERPN_B7L1U;
2447  if(CfgParams.Init(szDataSource,"[B7L1U]")==0) return false;
2448  if(!SetupRPMetrologyPoints(CfgParams,eRPName)) return false;
2449  if(!SetupDetMetrologyPoints(CfgParams,eRPName)) return false;
2450 
2451  eRPName=ERPN_B7L1L;
2452  if(CfgParams.Init(szDataSource,"[B7L1L]")==0) return false;
2453  if(!SetupRPMetrologyPoints(CfgParams,eRPName)) return false;
2454  if(!SetupDetMetrologyPoints(CfgParams,eRPName)) return false;
2455 
2456  eRPName=ERPN_A7L1U;
2457  if(CfgParams.Init(szDataSource,"[A7L1U]")==0) return false;
2458  if(!SetupRPMetrologyPoints(CfgParams,eRPName)) return false;
2459  if(!SetupDetMetrologyPoints(CfgParams,eRPName)) return false;
2460 
2461  eRPName=ERPN_A7L1L;
2462  if(CfgParams.Init(szDataSource,"[A7L1L]")==0) return false;
2463  if(!SetupRPMetrologyPoints(CfgParams,eRPName)) return false;
2464  if(!SetupDetMetrologyPoints(CfgParams,eRPName)) return false;
2465 
2466  eRPName=ERPN_A7R1U;
2467  if(CfgParams.Init(szDataSource,"[A7R1U]")==0) return false;
2468  if(!SetupRPMetrologyPoints(CfgParams,eRPName)) return false;
2469  if(!SetupDetMetrologyPoints(CfgParams,eRPName)) return false;
2470 
2471  eRPName=ERPN_A7R1L;
2472  if(CfgParams.Init(szDataSource,"[A7R1L]")==0) return false;
2473  if(!SetupRPMetrologyPoints(CfgParams,eRPName)) return false;
2474  if(!SetupDetMetrologyPoints(CfgParams,eRPName)) return false;
2475 
2476  eRPName=ERPN_B7R1U;
2477  if(CfgParams.Init(szDataSource,"[B7R1U]")==0) return false;
2478  if(!SetupRPMetrologyPoints(CfgParams,eRPName)) return false;
2479  if(!SetupDetMetrologyPoints(CfgParams,eRPName)) return false;
2480 
2481  eRPName=ERPN_B7R1L;
2482  if(CfgParams.Init(szDataSource,"[B7R1L]")==0) return false;
2483  if(!SetupRPMetrologyPoints(CfgParams,eRPName)) return false;
2484  if(!SetupDetMetrologyPoints(CfgParams,eRPName)) return false;
2485 
2486  bRes=true;
2487  }
2488  else
2489  {
2490  LogStream<<MSG::ERROR<<"The file source is supported only."<<endmsg;
2491  bRes=false;
2492  }
2493 
2494  return bRes;
2495 }

◆ PrintFiberGeometry() [1/2]

void ALFA_GeometryReader::PrintFiberGeometry ( const char *  szOutFilename)

Definition at line 1634 of file ALFA_GeometryReader.cxx.

1635 {
1636  std::ofstream OutStream(szOutFilename);
1637  PrintFiberGeometry(OutStream);
1638  OutStream.close();
1639 }

◆ PrintFiberGeometry() [2/2]

void ALFA_GeometryReader::PrintFiberGeometry ( std::ostream &  OutStream)

Definition at line 1641 of file ALFA_GeometryReader.cxx.

1642 {
1643 
1644  std::list<FIBERPARAMS>::const_iterator iter;
1645  std::map<eRPotName, ROMAPOT>::const_iterator rpiter;
1646  FIBERPARAMS FiberParams;
1647 
1648  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::PrintGeometry");
1649 
1650  if(m_eFCoordSystem!=EFCS_CLADDING && m_eFCoordSystem!=EFCS_ATLAS){
1651  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
1652  return;
1653  }
1654 
1655  for(rpiter=m_MapRPot.begin();rpiter!=m_MapRPot.end();++rpiter){
1656  OutStream<<std::endl<<"Geometry of U-fibers in Roma Pot "<<(*rpiter).first<<std::endl;
1657  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<"nPotID\t\t\t\tnPlateID\t\t\t\tnFiberID\t\t\t\tnLayerID\t\t\t\tfCentreXPos\t\t\t\tfAngle"<<std::endl;
1658  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<"nPotID\t\t\t\tnPlateID\t\t\t\tnFiberID\t\t\t\tnLayerID\t\t\t\tfSlope\t\t\t\tfOffset\t\t\t\tfZPos"<<std::endl;
1659 
1660  for(iter=(*rpiter).second.ListUFibers.begin();iter!=(*rpiter).second.ListUFibers.end();++iter){
1661  OutStream<<(*rpiter).first<<"\t\t\t\t"<<(*iter).nPlateID<<"\t\t\t\t"<<(*iter).nFiberID<<"\t\t\t\t"<<(*iter).nLayerID<<"\t\t\t\t";
1662  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<(*iter).fcs_cladding.fCentreXPos<<"\t\t\t\t"<<(*iter).fcs_cladding.fAngle<<std::endl;
1663  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<(*iter).fcs_atlas.fSlope<<"\t\t\t\t"<<(*iter).fcs_atlas.fOffset<<(*iter).fcs_atlas.fZPos<<std::endl;
1664  }
1665 
1666  OutStream<<std::endl<<"Geometry of V-fibers in Roma Pot "<<(*rpiter).first<<std::endl;
1667  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<"nPotID\t\t\tnPlateID\t\t\tnFiberID\t\t\tnLayerID\t\t\tfCentreXPos\t\t\tfAngle\t\t\tfSlope\t\t\tfOffset\t\t\tfZPos"<<std::endl;
1668  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<"nPotID\t\t\t\tnPlateID\t\t\t\tnFiberID\t\t\t\tnLayerID\t\t\t\tfSlope\t\t\t\tfOffset\t\t\t\tfZPos"<<std::endl;
1669 
1670  for(iter=(*rpiter).second.ListVFibers.begin();iter!=(*rpiter).second.ListVFibers.end();++iter){
1671  OutStream<<(*rpiter).first<<"\t\t\t\t"<<(*iter).nPlateID<<"\t\t\t\t"<<(*iter).nFiberID<<"\t\t\t\t"<<(*iter).nLayerID<<"\t\t\t\t";
1672  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<(*iter).fcs_cladding.fCentreXPos<<"\t\t\t\t"<<(*iter).fcs_cladding.fAngle<<std::endl;
1673  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<(*iter).fcs_atlas.fSlope<<"\t\t\t\t"<<(*iter).fcs_atlas.fOffset<<(*iter).fcs_atlas.fZPos<<std::endl;
1674  }
1675 
1676  OutStream<<std::endl<<"Geometry of V0-ODFibers in Roma Pot "<<(*rpiter).first<<std::endl;
1677  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<"nPotID\t\t\tnPlateID\t\t\tnFiberID\t\t\tnLayerID\t\t\tfCentreXPos\t\t\tfAngle\t\t\tfSlope\t\t\tfOffset\t\t\tfZPos"<<std::endl;
1678  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<"nPotID\t\t\t\tnPlateID\t\t\t\tnFiberID\t\t\t\tnLayerID\t\t\t\tfSlope\t\t\t\tfOffset\t\t\t\tfZPos"<<std::endl;
1679 
1680  for(iter=(*rpiter).second.ListODFibersV0.begin();iter!=(*rpiter).second.ListODFibersV0.end();++iter){
1681  OutStream<<(*rpiter).first<<"\t\t\t\t"<<(*iter).nPlateID<<"\t\t\t\t"<<(*iter).nFiberID<<"\t\t\t\t"<<(*iter).nLayerID<<"\t\t\t\t";
1682  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<(*iter).fcs_cladding.fCentreYPos<<"\t\t\t\t"<<(*iter).fcs_cladding.fAngle<<std::endl;
1683  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<(*iter).fcs_atlas.fSlope<<"\t\t\t\t"<<(*iter).fcs_atlas.fOffset<<(*iter).fcs_atlas.fZPos<<std::endl;
1684  }
1685 
1686  OutStream<<std::endl<<"Geometry of U0-ODFibers in Roma Pot "<<(*rpiter).first<<std::endl;
1687  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<"nPotID\t\t\tnPlateID\t\t\tnFiberID\t\t\tnLayerID\t\t\tfCentreXPos\t\t\tfAngle\t\t\tfSlope\t\t\tfOffset\t\t\tfZPos"<<std::endl;
1688  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<"nPotID\t\t\t\tnPlateID\t\t\t\tnFiberID\t\t\t\tnLayerID\t\t\t\tfSlope\t\t\t\tfOffset\t\t\t\tfZPos"<<std::endl;
1689 
1690  for(iter=(*rpiter).second.ListODFibersU0.begin();iter!=(*rpiter).second.ListODFibersU0.end();++iter){
1691  OutStream<<(*rpiter).first<<"\t\t\t\t"<<(*iter).nPlateID<<"\t\t\t\t"<<(*iter).nFiberID<<"\t\t\t\t"<<(*iter).nLayerID<<"\t\t\t\t";
1692  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<(*iter).fcs_cladding.fCentreYPos<<"\t\t\t\t"<<(*iter).fcs_cladding.fAngle<<std::endl;
1693  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<(*iter).fcs_atlas.fSlope<<"\t\t\t\t"<<(*iter).fcs_atlas.fOffset<<(*iter).fcs_atlas.fZPos<<std::endl;
1694  }
1695 
1696  OutStream<<std::endl<<"Geometry of U1-ODFibers in Roma Pot "<<(*rpiter).first<<std::endl;
1697  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<"nPotID\t\t\tnPlateID\t\t\tnFiberID\t\t\tnLayerID\t\t\tfCentreXPos\t\t\tfAngle\t\t\tfSlope\t\t\tfOffset\t\t\tfZPos"<<std::endl;
1698  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<"nPotID\t\t\t\tnPlateID\t\t\t\tnFiberID\t\t\t\tnLayerID\t\t\t\tfSlope\t\t\t\tfOffset\t\t\t\tfZPos"<<std::endl;
1699 
1700  for(iter=(*rpiter).second.ListODFibersU1.begin();iter!=(*rpiter).second.ListODFibersU1.end();++iter){
1701  OutStream<<(*rpiter).first<<"\t\t\t\t"<<(*iter).nPlateID<<"\t\t\t\t"<<(*iter).nFiberID<<"\t\t\t\t"<<(*iter).nLayerID<<"\t\t\t\t";
1702  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<(*iter).fcs_cladding.fCentreYPos<<"\t\t\t\t"<<(*iter).fcs_cladding.fAngle<<std::endl;
1703  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<(*iter).fcs_atlas.fSlope<<"\t\t\t\t"<<(*iter).fcs_atlas.fOffset<<(*iter).fcs_atlas.fZPos<<std::endl;
1704  }
1705 
1706  OutStream<<std::endl<<"Geometry of V1-ODFibers in Roma Pot "<<(*rpiter).first<<std::endl;
1707  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<"nPotID\t\t\tnPlateID\t\t\tnFiberID\t\t\tnLayerID\t\t\tfCentreXPos\t\t\tfAngle\t\t\tfSlope\t\t\tfOffset\t\t\tfZPos"<<std::endl;
1708  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<"nPotID\t\t\t\tnPlateID\t\t\t\tnFiberID\t\t\t\tnLayerID\t\t\t\tfSlope\t\t\t\tfOffset\t\t\t\tfZPos"<<std::endl;
1709 
1710  for(iter=(*rpiter).second.ListODFibersV1.begin();iter!=(*rpiter).second.ListODFibersV1.end();++iter){
1711  OutStream<<(*rpiter).first<<"\t\t\t\t"<<(*iter).nPlateID<<"\t\t\t\t"<<(*iter).nFiberID<<"\t\t\t\t"<<(*iter).nLayerID<<"\t\t\t\t";
1712  if(m_eFCoordSystem==EFCS_CLADDING) OutStream<<(*iter).fcs_cladding.fCentreYPos<<"\t\t\t\t"<<(*iter).fcs_cladding.fAngle<<std::endl;
1713  else if(m_eFCoordSystem==EFCS_ATLAS) OutStream<<(*iter).fcs_atlas.fSlope<<"\t\t\t\t"<<(*iter).fcs_atlas.fOffset<<(*iter).fcs_atlas.fZPos<<std::endl;
1714  }
1715  }
1716 }

◆ ReadDatabase()

bool ALFA_GeometryReader::ReadDatabase ( const eRPotName  eRPName,
const eFiberType  eFType,
const char *  szDataSource 
)
private

Definition at line 1323 of file ALFA_GeometryReader.cxx.

1324 {
1325  bool bRes=false;
1326 
1327  //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::ReadDatabase");
1328 
1329  eFiberType eType=EFT_UNDEFINED;
1330  ROMAPOT RomaPot;
1331 
1332  std::vector<std::string> strDBElements;
1333  char szSource[64];
1334  char *pch;
1335 
1336  memset(szSource,0,sizeof(szSource));
1337  if(szDataSource) strncpy(szSource, szDataSource, sizeof(szSource)-1);
1338  char* strtok_ptr = nullptr;
1339  pch = strtok_r(szSource,":",&strtok_ptr);
1340  while (pch != nullptr)
1341  {
1342  strDBElements.emplace_back(pch);
1343  pch = strtok_r(nullptr, ":",&strtok_ptr);
1344  }
1345 
1346  // LogStream << MSG::INFO << "MARK - elements: " << strDBElements[0] << " " << strDBElements[1] << " " << strDBElements[2] << endmsg;
1347 
1348  ALFA_RDBAccess* p_DBAccess = new ALFA_RDBAccess();
1349 
1350  bRes = p_DBAccess->ReadGeometry(eRPName, eFType, strDBElements[2], strDBElements[1], strDBElements[0]);
1351 
1352  if(m_MapRPot.find(eRPName)==m_MapRPot.end()){
1353  //RP not yet defined
1354  RomaPot.ListUFibers.clear();
1355  RomaPot.ListVFibers.clear();
1356  RomaPot.ListODFibersU0.clear();
1357  RomaPot.ListODFibersU1.clear();
1358  RomaPot.ListODFibersV0.clear();
1359  RomaPot.ListODFibersV1.clear();
1360 
1361  m_MapRPot.insert(std::pair<eRPotName,ROMAPOT>(eRPName,RomaPot));
1362  }
1363 
1364  if(eFType==EFT_FIBERMD) m_MapRPot[eRPName].eMDGeometryType=EGST_DATABASE;
1365  else if(eFType==EFT_FIBEROD) m_MapRPot[eRPName].eODGeometryType=EGST_DATABASE;
1366 
1367  std::list<FIBERDATA>::const_iterator iter;
1368  for(iter = p_DBAccess->m_ListFiberData.begin(); iter != p_DBAccess->m_ListFiberData.end(); ++iter)
1369  {
1370  if (eRPName == (*iter).nPotID)
1371  {
1372  FIBERPARAMS FiberParams;
1373 
1374  FiberParams.nLayerID = (*iter).nLayerID;
1375  FiberParams.nFiberID = (*iter).nFiberID;
1376  FiberParams.fSlope = (*iter).fSlope;
1377  FiberParams.fOffset = (*iter).fOffset;
1378  FiberParams.fZPos = (*iter).fZPos;
1379 
1380  FiberParams.nPlateID=FiberParams.nLayerID/2+FiberParams.nLayerID%2;
1381 
1382  //Resolve fiber type
1383  if(eFType==EFT_FIBERMD)
1384  {
1385  eType=(FiberParams.fSlope<0)? EFT_UFIBER:EFT_VFIBER;
1386  }
1387  else if(eFType==EFT_FIBEROD)
1388  {
1389  if(FiberParams.nLayerID%2==1 && FiberParams.nFiberID<=15) eType=EFT_ODFIBERV0;
1390  if(FiberParams.nLayerID%2==1 && FiberParams.nFiberID>=16 && FiberParams.nFiberID<=30) eType=EFT_ODFIBERU0;
1391  if(FiberParams.nLayerID%2==0 && FiberParams.nFiberID<=15) eType=EFT_ODFIBERU1;
1392  if(FiberParams.nLayerID%2==0 && FiberParams.nFiberID>=16 && FiberParams.nFiberID<=30) eType=EFT_ODFIBERV1;
1393 
1394  // LogStream << MSG::INFO << "eType: " << eType << " fSlope: " << FiberParams.fSlope << endmsg;
1395  }
1396 
1397  //Transform & save values for RP
1398  TransformFiberPositions(&FiberParams, eRPName, eType, EGST_DATABASE);
1399 
1400  if(eType==EFT_UFIBER) m_MapRPot[eRPName].ListUFibers.push_back(FiberParams);
1401  if(eType==EFT_VFIBER) m_MapRPot[eRPName].ListVFibers.push_back(FiberParams);
1402  if(eType==EFT_ODFIBERU0) m_MapRPot[eRPName].ListODFibersU0.push_back(FiberParams);
1403  if(eType==EFT_ODFIBERV0) m_MapRPot[eRPName].ListODFibersV0.push_back(FiberParams);
1404  if(eType==EFT_ODFIBERV1) m_MapRPot[eRPName].ListODFibersV1.push_back(FiberParams);
1405  if(eType==EFT_ODFIBERU1) m_MapRPot[eRPName].ListODFibersU1.push_back(FiberParams);
1406  }
1407  }
1408 
1409  delete p_DBAccess;
1410 
1411  return bRes;
1412 }

◆ ReadFiberGeometry()

bool ALFA_GeometryReader::ReadFiberGeometry ( const PGEOMETRYCONFIGURATION  pConfig)

Definition at line 1004 of file ALFA_GeometryReader.cxx.

1005 {
1006  bool bFailRes=false;
1007  int nRPCfgIndex;
1008  std::list<eRPotName>::const_iterator iterRPName;
1009  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_DetectorReader::ReadGeometry");
1010 
1011  if(pConfig!=nullptr)
1012  {
1013  LogStream<<MSG::INFO<<"Number of active or inactive Romain Pots: "<<m_ListExistingRPots.size()<<endmsg;
1014 
1015  for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName){
1016  nRPCfgIndex=((int)(*iterRPName))-1;
1017  bFailRes|=!ReadSource((eGeoSourceType)pConfig->CfgRPosParams[nRPCfgIndex].eMDGeoType, *iterRPName, EFT_FIBERMD, pConfig->CfgRPosParams[nRPCfgIndex].strMDConnString.c_str());
1018  bFailRes|=!ReadSource((eGeoSourceType)pConfig->CfgRPosParams[nRPCfgIndex].eODGeoType, *iterRPName, EFT_FIBEROD, pConfig->CfgRPosParams[nRPCfgIndex].strODConnString.c_str());
1019  }
1020  }
1021  else //set ideal geometry if pConfig is not provided
1022  {
1023  for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName){
1024  bFailRes|=!ReadSource(EGST_IDEALGEOMETRY, *iterRPName, EFT_FIBERMD, nullptr);
1025  bFailRes|=!ReadSource(EGST_IDEALGEOMETRY, *iterRPName, EFT_FIBEROD, nullptr);
1026  }
1027  }
1028 
1029  return !bFailRes;
1030 }

◆ ReadFile()

bool ALFA_GeometryReader::ReadFile ( const eRPotName  eRPName,
const eFiberType  eFType,
const char *  szFilename 
)
private

Definition at line 1175 of file ALFA_GeometryReader.cxx.

1176 {
1177  if(eFType!=EFT_FIBERMD && eFType!=EFT_FIBEROD) return false;
1178 
1179  bool bRes=true;
1180  int i,nLine,nLength;
1181  char szLine[64];
1182  char* pch1, *pch2;
1183  FILE* pFile;
1184  eFiberType eType=EFT_UNDEFINED;
1185  ROMAPOT RomaPot;
1186 
1187  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::ReadFile");
1188 
1189  if(m_MapRPot.find(eRPName)==m_MapRPot.end()){
1190  //RP not yet defined
1191  RomaPot.ListUFibers.clear();
1192  RomaPot.ListVFibers.clear();
1193  RomaPot.ListODFibersU0.clear();
1194  RomaPot.ListODFibersU1.clear();
1195  RomaPot.ListODFibersV0.clear();
1196  RomaPot.ListODFibersV1.clear();
1197 
1198  m_MapRPot.insert(std::pair<eRPotName,ROMAPOT>(eRPName,RomaPot));
1199  }
1200 
1201  if(eFType==EFT_FIBERMD) m_MapRPot[eRPName].eMDGeometryType=EGST_FILE;
1202  else if(eFType==EFT_FIBEROD) m_MapRPot[eRPName].eODGeometryType=EGST_FILE;
1203 
1204  if((pFile=fopen(szFilename,"r"))==nullptr){
1205  LogStream<<MSG::ERROR<< "Could not open the file "<<szFilename<<endmsg;
1206  return false;
1207  }
1208 
1209  nLine=0;
1210  while(!feof(pFile)){
1211  if(fgets(szLine,sizeof(szLine),pFile)!=nullptr){
1212 
1213  FIBERPARAMS FiberParams;
1214 
1215  nLine++;
1216  if(nLine<6) continue;
1217 
1218  nLength=strlen(szLine);
1219 
1220  //1. column - Layer ID
1221  for(i=0;i<nLength;i++) { if(*(szLine+i)==' ') continue; else break; }
1222  pch1=szLine+i;
1223  pch2=strchr(pch1,' ');
1224  if(pch2!=nullptr){
1225  *pch2='\0';
1226  FiberParams.nLayerID=atoi(pch1);
1227  FiberParams.nPlateID=FiberParams.nLayerID/2+FiberParams.nLayerID%2;
1228  }
1229  else{
1230  LogStream<<MSG::ERROR<< "Error at line "<<nLine<<" while reading the data file "<<szFilename<<endmsg;
1231  bRes=false;
1232  break;
1233  }
1234 
1235  //2. column - Fiber ID
1236  pch2++;
1237  for(i=0;i<nLength;i++) { if(*(pch2+i)==' ') continue; else break;}
1238  pch1=pch2+i;
1239  pch2=strchr(pch1,' ');
1240  if(pch2!=nullptr){
1241  *pch2='\0';
1242  FiberParams.nFiberID=atoi(pch1);
1243  }
1244  else{
1245  LogStream<<MSG::ERROR<< "Error at line "<<nLine<<" while reading the data file "<<szFilename<<endmsg;
1246  bRes=false;
1247  break;
1248  }
1249 
1250  //3. column - Slope
1251  pch2++;
1252  for(i=0;i<nLength;i++) { if(*(pch2+i)==' ') continue; else break; }
1253  pch1=pch2+i;
1254  pch2=strchr(pch1,' ');
1255  if(pch2!=nullptr){
1256  *pch2='\0';
1257  FiberParams.fSlope=atof(pch1);
1258  }
1259  else{
1260  LogStream<<MSG::ERROR<< "Error at line "<<nLine<<" while reading the data file "<<szFilename<<endmsg;
1261  bRes=false;
1262  break;
1263  }
1264 
1265  //4. column - Offset
1266  pch2++;
1267  for(i=0;i<nLength;i++) { if(*(pch2+i)==' ') continue; else break; }
1268  pch1=pch2+i;
1269  pch2=strchr(pch1,' ');
1270  if(pch2!=nullptr){
1271  *pch2='\0';
1272  FiberParams.fOffset=atof(pch1);
1273  }
1274  else{
1275  LogStream<<MSG::ERROR<< "Error at line "<<nLine<<" while reading the data file "<<szFilename<<endmsg;
1276  bRes=false;
1277  break;
1278  }
1279 
1280  //5. column - Z position
1281  pch2++;
1282  for(i=0;i<nLength;i++) { if(*(pch2+i)==' ') continue; else break; }
1283  pch1=pch2+i;
1284  FiberParams.fZPos=atof(pch1);
1285 
1286  //Resolve fiber type
1287  if(eFType==EFT_FIBERMD)
1288  {
1289  eType=(FiberParams.fSlope<0)? EFT_UFIBER:EFT_VFIBER;
1290  }
1291  else if(eFType==EFT_FIBEROD)
1292  {
1293  if(FiberParams.nLayerID%2==1 && FiberParams.nFiberID<=15) eType=EFT_ODFIBERV0;
1294  if(FiberParams.nLayerID%2==1 && FiberParams.nFiberID>=16 && FiberParams.nFiberID<=30) eType=EFT_ODFIBERU0;
1295 
1296  //1.10.2010 LN: change of indexation scheme
1297  //if(FiberParams.nLayerID%2==0 && FiberParams.nFiberID<=15) eType=EFT_ODFIBERU1;
1298  //if(FiberParams.nLayerID%2==0 && FiberParams.nFiberID>=16 && FiberParams.nFiberID<=30) eType=EFT_ODFIBERV1;
1299  if(FiberParams.nLayerID%2==0 && FiberParams.nFiberID<=15) eType=EFT_ODFIBERV1;
1300  if(FiberParams.nLayerID%2==0 && FiberParams.nFiberID>=16 && FiberParams.nFiberID<=30) eType=EFT_ODFIBERU1;
1301  }
1302 
1303 
1304  //Transform & save values for RP
1305  TransformFiberPositions(&FiberParams, eRPName, eType, EGST_FILE);
1306 
1307  if(eType==EFT_UFIBER) m_MapRPot[eRPName].ListUFibers.push_back(FiberParams);
1308  if(eType==EFT_VFIBER) m_MapRPot[eRPName].ListVFibers.push_back(FiberParams);
1309  if(eType==EFT_ODFIBERU0) m_MapRPot[eRPName].ListODFibersU0.push_back(FiberParams);
1310  if(eType==EFT_ODFIBERV0) m_MapRPot[eRPName].ListODFibersV0.push_back(FiberParams);
1311  if(eType==EFT_ODFIBERV1) m_MapRPot[eRPName].ListODFibersV1.push_back(FiberParams);
1312  if(eType==EFT_ODFIBERU1) m_MapRPot[eRPName].ListODFibersU1.push_back(FiberParams);
1313 
1314  }
1315  }
1316 
1317  if(pFile) fclose(pFile);
1318  pFile=nullptr;
1319 
1320  return bRes;
1321 }

◆ ReadSource()

bool ALFA_GeometryReader::ReadSource ( const eGeoSourceType  eSourceType,
const eRPotName  eRPName,
const eFiberType  eFType,
const char *  szDataSource 
)
private

Definition at line 1032 of file ALFA_GeometryReader.cxx.

1033 {
1034  bool bRes=false;
1035  int i;
1036  std::string strDetType, FilePath, GeomFile;
1037  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_DetectorReader::ReadGeometry");
1038 
1039  if(eFType!=EFT_FIBERMD && eFType!=EFT_FIBEROD) return false;
1040 
1041  strDetType=(eFType==EFT_FIBERMD)? "MD":"OD";
1042 
1043  switch(eSourceType){
1044  case EGST_IDEALGEOMETRY:
1045  LogStream<<MSG::INFO<<"The IDEAL "<<strDetType<<" fiber geometry will be loaded for RP "<<GetRPotLabel(eRPName)<<endmsg;
1046  bRes=SetIdealGeometry(eRPName, eFType);
1047  break;
1048  case EGST_FILE:
1049 
1050  GeomFile=std::string("geom_")+strDetType+std::string("_")+std::string(GetRPotLabel(eRPName))+std::string(".dat");
1051  if(szDataSource==nullptr || !strcmp(szDataSource,"")) FilePath = PathResolver::find_file(GeomFile,"DATAPATH", PathResolver::RecursiveSearch);
1052  else FilePath=std::string(szDataSource);
1053 
1054  LogStream<<MSG::INFO<<"The "<<strDetType<<" fiber geometry will be loaded from FILE "<<FilePath.c_str()<<" for RP "<<GetRPotLabel(eRPName)<<endmsg;
1055  bRes=ReadFile(eRPName, eFType, FilePath.c_str());
1056  break;
1057  case EGST_DATABASE:
1058  LogStream<<MSG::INFO<<"The "<<strDetType<<" fiber geometry will be loaded from DATABASE for RP "<<GetRPotLabel(eRPName)<<endmsg;
1059  bRes=ReadDatabase(eRPName, eFType, szDataSource);
1060  break;
1061  default:
1062  bRes=false;
1063  break;
1064  }
1065 
1066  if(bRes){
1067  PLATEPARAMS PlateParams {0, 0};
1068  for(i=1;i<=ALFAFIBERSCNT;i++){
1069  m_MapRPot[eRPName].MapPlates.insert(std::pair<int,PLATEPARAMS>(i,PlateParams));
1070  }
1071 
1072  for(i=1;i<=ODFIBERSCNT;i++){
1073  m_MapRPot[eRPName].MapODPlates.insert(std::pair<int,PLATEPARAMS>(i,PlateParams));
1074  }
1075 
1076  UpdateGeometry();
1077  }
1078  else
1079  {
1080  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::ReadSource");
1081  LogStream << MSG::FATAL << " Could not load geometry! " << endmsg;
1082 
1083  throw GaudiException(" Could not load geometry ", "ALFA_GeometryReader::ReadSource", StatusCode::FAILURE);
1084  }
1085 
1086  return bRes;
1087 }

◆ ResolveRPotRefPoints()

bool ALFA_GeometryReader::ResolveRPotRefPoints ( const char *  szvalue,
eRPotName  eRPName,
eRefPointType  eRPointType 
)
private

Definition at line 2497 of file ALFA_GeometryReader.cxx.

2498 {
2499  bool bRes=false;
2500  std::vector<HepGeom::Point3D<double> > vecRefPoints;
2501 
2502  if(eRPointType==ERPT_IDEAL || eRPointType==ERPT_REAL) bRes=ParseRefPoints(szvalue,vecRefPoints,EMCS_STATION);
2503  else if(eRPointType==ERPT_DETIDEAL || eRPointType==ERPT_DETREAL) bRes=ParseRefPoints(szvalue,vecRefPoints,EMCS_ROMANPOT);
2504 
2505  if(bRes){
2506  if(eRPointType==ERPT_IDEAL) m_RPPosParams[eRPName].VecIdealRPRefPoints=vecRefPoints;
2507  else if(eRPointType==ERPT_REAL) m_RPPosParams[eRPName].VecRealRPRefPoints=vecRefPoints;
2508  else if(eRPointType==ERPT_DETIDEAL) m_RPPosParams[eRPName].VecIdealDetRefPoints=vecRefPoints;
2509  else if(eRPointType==ERPT_DETREAL) m_RPPosParams[eRPName].VecRealDetRefPoints=vecRefPoints;
2510  }
2511 
2512  return bRes;
2513 }

◆ SaveRPGeometryParams()

bool ALFA_GeometryReader::SaveRPGeometryParams ( const eRPotName  eRPName,
const char *  szDataDestination 
)

Definition at line 2927 of file ALFA_GeometryReader.cxx.

2928 {
2929  bool bRes= false;
2930  double fRotX,fRotY,fRotZ;
2931 
2932  FILE *pfile=fopen(szDataDestination,"w");
2933  if(pfile!=nullptr)
2934  {
2935  fprintf(pfile,"Romain pot geometry info: ----------------------------------------\r\n");
2936 
2937  fprintf(pfile,"LVDT: %.3f mm\r\n\r\n",m_RPPosParams[eRPName].fCurrentLVDTmm);
2938 
2939  fprintf(pfile,"Transformation matrix of RP in station MainPoint:\r\n");
2940  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].RPTransformInStation.xx(),m_RPPosParams[eRPName].RPTransformInStation.xy(),m_RPPosParams[eRPName].RPTransformInStation.xz(),m_RPPosParams[eRPName].RPTransformInStation.dx());
2941  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].RPTransformInStation.yx(),m_RPPosParams[eRPName].RPTransformInStation.yy(),m_RPPosParams[eRPName].RPTransformInStation.yz(),m_RPPosParams[eRPName].RPTransformInStation.dy());
2942  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].RPTransformInStation.zx(),m_RPPosParams[eRPName].RPTransformInStation.zy(),m_RPPosParams[eRPName].RPTransformInStation.zz(),m_RPPosParams[eRPName].RPTransformInStation.dz());
2943 
2944  fRotZ=atan2(m_RPPosParams[eRPName].RPTransformInStation.yx(),m_RPPosParams[eRPName].RPTransformInStation.xx());
2945  fRotY=atan2(-m_RPPosParams[eRPName].RPTransformInStation.zx(),sqrt(pow(m_RPPosParams[eRPName].RPTransformInStation.zy(),2)+pow(m_RPPosParams[eRPName].RPTransformInStation.zz(),2)));//asin(m_RPPosParams[eRPName].RPTransformInStation.zx());
2946  fRotX=atan2(m_RPPosParams[eRPName].RPTransformInStation.zy(),m_RPPosParams[eRPName].RPTransformInStation.zz());
2947  fprintf(pfile,"RotX=%.5f rad, RotY=%.5f rad, RotZ=%.5f rad\r\n",fRotX,fRotY,fRotZ);
2948 
2949  /*
2950  fprintf(pfile,"\r\nMetrology scale matrix of RP in station MainPoint:\r\n");
2951  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].RPScaleInStation.xx(),m_RPPosParams[eRPName].RPScaleInStation.xy(),m_RPPosParams[eRPName].RPScaleInStation.xz(),m_RPPosParams[eRPName].RPScaleInStation.dx());
2952  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].RPScaleInStation.yx(),m_RPPosParams[eRPName].RPScaleInStation.yy(),m_RPPosParams[eRPName].RPScaleInStation.yz(),m_RPPosParams[eRPName].RPScaleInStation.dy());
2953  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].RPScaleInStation.zx(),m_RPPosParams[eRPName].RPScaleInStation.zy(),m_RPPosParams[eRPName].RPScaleInStation.zz(),m_RPPosParams[eRPName].RPScaleInStation.dz());
2954  */
2955 
2956  fprintf(pfile,"\r\nDetector geometry info: ------------------------------------------\r\n");
2957  fprintf(pfile,"Transformation matrix of detector in RP MainPoint:\r\n");
2958  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].DetTransformInMainPoint.xx(),m_RPPosParams[eRPName].DetTransformInMainPoint.xy(),m_RPPosParams[eRPName].DetTransformInMainPoint.xz(),m_RPPosParams[eRPName].DetTransformInMainPoint.dx());
2959  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].DetTransformInMainPoint.yx(),m_RPPosParams[eRPName].DetTransformInMainPoint.yy(),m_RPPosParams[eRPName].DetTransformInMainPoint.yz(),m_RPPosParams[eRPName].DetTransformInMainPoint.dy());
2960  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].DetTransformInMainPoint.zx(),m_RPPosParams[eRPName].DetTransformInMainPoint.zy(),m_RPPosParams[eRPName].DetTransformInMainPoint.zz(),m_RPPosParams[eRPName].DetTransformInMainPoint.dz());
2961 
2962  fRotZ=atan2(m_RPPosParams[eRPName].DetTransformInMainPoint.yx(),m_RPPosParams[eRPName].DetTransformInMainPoint.xx());
2963  fRotY=atan2(-m_RPPosParams[eRPName].DetTransformInMainPoint.zx(),sqrt(pow(m_RPPosParams[eRPName].DetTransformInMainPoint.zy(),2)+pow(m_RPPosParams[eRPName].DetTransformInMainPoint.zz(),2)));//asin(m_RPPosParams[eRPName].RPTransformInStation.zx());
2964  fRotX=atan2(m_RPPosParams[eRPName].DetTransformInMainPoint.zy(),m_RPPosParams[eRPName].DetTransformInMainPoint.zz());
2965  fprintf(pfile,"RotX=%.5f rad, RotY=%.5f rad, RotZ=%.5f rad\r\n",fRotX,fRotY,fRotZ);
2966 
2967  /*
2968  fprintf(pfile,"\r\nMetrology scale matrix of detector in RP MainPoint:\r\n");
2969  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].DetScaleInRP.xx(),m_RPPosParams[eRPName].DetScaleInRP.xy(),m_RPPosParams[eRPName].DetScaleInRP.xz(),m_RPPosParams[eRPName].DetScaleInRP.dx());
2970  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].DetScaleInRP.yx(),m_RPPosParams[eRPName].DetScaleInRP.yy(),m_RPPosParams[eRPName].DetScaleInRP.yz(),m_RPPosParams[eRPName].DetScaleInRP.dy());
2971  fprintf(pfile,"%+.5f %+.5f %+.5f %+.5f\r\n",m_RPPosParams[eRPName].DetScaleInRP.zx(),m_RPPosParams[eRPName].DetScaleInRP.zy(),m_RPPosParams[eRPName].DetScaleInRP.zz(),m_RPPosParams[eRPName].DetScaleInRP.dz());
2972  */
2973  fprintf(pfile,"\r\nReference pins and Track point info: ------------------------------------------\r\n");
2974  fprintf(pfile,"RPPin1: nominal=[%.3f,%.3f,%.3f], real=[%.3f,%.3f,%.3f] (Station CS)\r\n",m_RPPosParams[eRPName].RefPins.IdealRPPin1.x(),m_RPPosParams[eRPName].RefPins.IdealRPPin1.y(),m_RPPosParams[eRPName].RefPins.IdealRPPin1.z(),
2975  m_RPPosParams[eRPName].RefPins.RealRPPin1.x(),m_RPPosParams[eRPName].RefPins.RealRPPin1.y(),m_RPPosParams[eRPName].RefPins.RealRPPin1.z());
2976  fprintf(pfile,"RPPin2: nominal=[%.3f,%.3f,%.3f], real=[%.3f,%.3f,%.3f] (Station CS)\r\n",m_RPPosParams[eRPName].RefPins.IdealRPPin2.x(),m_RPPosParams[eRPName].RefPins.IdealRPPin2.y(),m_RPPosParams[eRPName].RefPins.IdealRPPin2.z(),
2977  m_RPPosParams[eRPName].RefPins.RealRPPin2.x(),m_RPPosParams[eRPName].RefPins.RealRPPin2.y(),m_RPPosParams[eRPName].RefPins.RealRPPin2.z());
2978  fprintf(pfile,"RPPin3: nominal=[%.3f,%.3f,%.3f], real=[%.3f,%.3f,%.3f] (Station CS)\r\n",m_RPPosParams[eRPName].RefPins.IdealRPPin3.x(),m_RPPosParams[eRPName].RefPins.IdealRPPin3.y(),m_RPPosParams[eRPName].RefPins.IdealRPPin3.z(),
2979  m_RPPosParams[eRPName].RefPins.RealRPPin3.x(),m_RPPosParams[eRPName].RefPins.RealRPPin3.y(),m_RPPosParams[eRPName].RefPins.RealRPPin3.z());
2980  fprintf(pfile,"Detector TrackPoint: [%.3f,%.3f,%.3f] (ALFA CS), [%.3f,%.3f,%.3f] (RPot CS), [%.3f,%.3f,%.3f] (ATLAS CS)\r\n",m_RPPosParams[eRPName].RefPins.DTPInAlfaCS.x(),m_RPPosParams[eRPName].RefPins.DTPInAlfaCS.y(),m_RPPosParams[eRPName].RefPins.DTPInAlfaCS.z(),
2981  m_RPPosParams[eRPName].RefPins.DTPInRPotCS.x(),m_RPPosParams[eRPName].RefPins.DTPInRPotCS.y(),m_RPPosParams[eRPName].RefPins.DTPInRPotCS.z(),
2982  m_RPPosParams[eRPName].RefPins.DTPInAtlasCS.x(),m_RPPosParams[eRPName].RefPins.DTPInAtlasCS.y(),m_RPPosParams[eRPName].RefPins.DTPInAtlasCS.z());
2983  fprintf(pfile,"Detector CentrePoint: [%.3f,%.3f,%.3f] (ALFA CS), [%.3f,%.3f,%.3f] (RPot CS), [%.3f,%.3f,%.3f] (ATLAS CS)\r\n",m_RPPosParams[eRPName].RefPins.DCPInAlfaCS.x(),m_RPPosParams[eRPName].RefPins.DCPInAlfaCS.y(),m_RPPosParams[eRPName].RefPins.DCPInAlfaCS.z(),
2984  m_RPPosParams[eRPName].RefPins.DCPInRPotCS.x(),m_RPPosParams[eRPName].RefPins.DCPInRPotCS.y(),m_RPPosParams[eRPName].RefPins.DCPInRPotCS.z(),
2985  m_RPPosParams[eRPName].RefPins.DCPInAtlasCS.x(),m_RPPosParams[eRPName].RefPins.DCPInAtlasCS.y(),m_RPPosParams[eRPName].RefPins.DCPInAtlasCS.z());
2986 
2987 
2988  fclose(pfile);
2989 
2990  bRes=true;
2991  }
2992 
2993  return bRes;
2994 }

◆ SetIdealGeometry()

bool ALFA_GeometryReader::SetIdealGeometry ( const eRPotName  eRPName,
const eFiberType  eFType 
)
private

Definition at line 1089 of file ALFA_GeometryReader.cxx.

1090 {
1091  if(eFType!=EFT_FIBERMD && eFType!=EFT_FIBEROD) return false;
1092 
1093  int i,j;
1094  bool bRes=true;
1095  eFiberType eFiberAlfaType;
1096  ROMAPOT RomaPot;
1097 
1098  //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::SetIdealGeometry");
1099 
1100  if(m_MapRPot.find(eRPName)==m_MapRPot.end())
1101  {
1102  //RP not yet defined
1103  RomaPot.ListUFibers.clear();
1104  RomaPot.ListVFibers.clear();
1105  RomaPot.ListODFibersU0.clear();
1106  RomaPot.ListODFibersU1.clear();
1107  RomaPot.ListODFibersV0.clear();
1108  RomaPot.ListODFibersV1.clear();
1109 
1110  m_MapRPot.insert(std::pair<eRPotName,ROMAPOT>(eRPName,RomaPot));
1111  }
1112 
1113  if(eFType==EFT_FIBERMD) m_MapRPot[eRPName].eMDGeometryType=EGST_IDEALGEOMETRY;
1114  else if(eFType==EFT_FIBEROD) m_MapRPot[eRPName].eODGeometryType=EGST_IDEALGEOMETRY;
1115 
1116  if (eFType==EFT_FIBERMD)
1117  {
1118  for(i=1;i<=ALFALAYERSCNT*ALFAPLATESCNT;i++){
1119  for(j=1;j<=ALFAFIBERSCNT;j++){
1120  FIBERPARAMS FiberParams;
1121 
1122  eFiberAlfaType=(i%2==0)? EFT_VFIBER:EFT_UFIBER;
1123  FiberParams.nLayerID=i;
1124  FiberParams.nFiberID=j;
1125  FiberParams.fSlope=(eFiberAlfaType==EFT_VFIBER)? 1.0:-1.0;
1126  FiberParams.nPlateID=FiberParams.nLayerID/2+FiberParams.nLayerID%2;
1127  TransformFiberPositions(&FiberParams, eRPName, eFiberAlfaType, EGST_IDEALGEOMETRY);
1128 
1129  if(eFiberAlfaType==EFT_UFIBER) m_MapRPot[eRPName].ListUFibers.push_back(FiberParams);
1130  if(eFiberAlfaType==EFT_VFIBER) m_MapRPot[eRPName].ListVFibers.push_back(FiberParams);
1131  }
1132  }
1133  }
1134  else if (eFType==EFT_FIBEROD)
1135  {
1136  for(i=1;i<=ODLAYERSCNT*ODPLATESCNT;i++)
1137  {
1138  for(j=1;j<=ODFIBERSCNT;j++)
1139  {
1140  FIBERPARAMS FiberParams;
1141 
1142  FiberParams.nLayerID=i;
1143  FiberParams.nPlateID=FiberParams.nLayerID/2+FiberParams.nLayerID%2;
1144  FiberParams.fSlope = 0;
1145 
1146  if (i%2==0)
1147  { //for V0 and V1 ODFibers
1148  FiberParams.nFiberID=j;
1149  TransformFiberPositions(&FiberParams, eRPName, EFT_ODFIBERV0, EGST_IDEALGEOMETRY);
1150  m_MapRPot[eRPName].ListODFibersV0.push_back(FiberParams);
1151 
1152  //1.10.2010 LN: change of indexation scheme
1153  FiberParams.nFiberID=j;//j+15;
1154  TransformFiberPositions(&FiberParams, eRPName, EFT_ODFIBERV1, EGST_IDEALGEOMETRY);
1155  m_MapRPot[eRPName].ListODFibersV1.push_back(FiberParams);
1156  }
1157  else if (i%2==1)
1158  { //for U0 and U1 ODFibers
1159  FiberParams.nFiberID=j+15;
1160  TransformFiberPositions(&FiberParams, eRPName, EFT_ODFIBERU0, EGST_IDEALGEOMETRY);
1161  m_MapRPot[eRPName].ListODFibersU0.push_back(FiberParams);
1162 
1163  //1.10.2010 LN: change of indexation scheme
1164  FiberParams.nFiberID=j+15;//j;
1165  TransformFiberPositions(&FiberParams, eRPName, EFT_ODFIBERU1, EGST_IDEALGEOMETRY);
1166  m_MapRPot[eRPName].ListODFibersU1.push_back(FiberParams);
1167  }
1168  }
1169  }
1170  }
1171 
1172  return bRes;
1173 }

◆ SetODFiberPositionToMainReference()

void ALFA_GeometryReader::SetODFiberPositionToMainReference ( const eRPotName  eRPName,
const eFiberType  eFType,
const int  nPlateID,
const int  nFiberID,
const HepGeom::Point3D< float > &  TransPoint,
const double  fTransSlope 
)

Definition at line 2124 of file ALFA_GeometryReader.cxx.

2125 {
2126  std::list<FIBERPARAMS>::iterator iter;
2127  std::map<eRPotName, ROMAPOT>::iterator rpiter;
2128 
2129  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::SetODFiberPositionToMainReference");
2130 
2131  if(m_eFCoordSystem!=EFCS_CLADDING){
2132  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
2133  return;
2134  }
2135 
2136  if ((rpiter=m_MapRPot.find(eRPName))!=m_MapRPot.end())
2137  {
2138  switch (eFType)
2139  {
2140  case EFT_ODFIBERU0:
2141  {
2142  for(iter=(*rpiter).second.ListODFibersU0.begin();iter!=(*rpiter).second.ListODFibersU0.end();++iter)
2143  {
2144  if (((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
2145  }
2146 
2147  if (iter==(*rpiter).second.ListODFibersU0.end())
2148  {
2149  LogStream<<MSG::ERROR<<"Cannot find ODFiberU0 PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
2150  //throw new G4Exception("Wrong ODFiberU0");
2151  }
2152  else
2153  {
2154  (*iter).MainRefPointPos=TransPoint;
2155  (*iter).fMainRefPointSlope=fTransSlope;
2156  }
2157 
2158  break;
2159  }
2160  case EFT_ODFIBERV0:
2161  {
2162  for(iter=(*rpiter).second.ListODFibersV0.begin();iter!=(*rpiter).second.ListODFibersV0.end();++iter)
2163  {
2164  if (((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
2165  }
2166 
2167  if (iter==(*rpiter).second.ListODFibersV0.end())
2168  {
2169  LogStream<<MSG::ERROR<<"Cannot find ODFiberV0 PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
2170  //throw new G4Exception("Wrong ODFiberV0");
2171  }
2172  else
2173  {
2174  (*iter).MainRefPointPos=TransPoint;
2175  (*iter).fMainRefPointSlope=fTransSlope;
2176  }
2177 
2178  break;
2179  }
2180  case EFT_ODFIBERU1:
2181  {
2182  for(iter=(*rpiter).second.ListODFibersU1.begin();iter!=(*rpiter).second.ListODFibersU1.end();++iter)
2183  {
2184  if (((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
2185  }
2186 
2187  if (iter==(*rpiter).second.ListODFibersU1.end())
2188  {
2189  LogStream<<MSG::ERROR<<"Cannot find ODFiberU1 PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
2190  //throw new G4Exception("Wrong ODFiberU1");
2191  }
2192  else
2193  {
2194  (*iter).MainRefPointPos=TransPoint;
2195  (*iter).fMainRefPointSlope=fTransSlope;
2196  }
2197 
2198  break;
2199  }
2200  case EFT_ODFIBERV1:
2201  {
2202  for(iter=(*rpiter).second.ListODFibersV1.begin();iter!=(*rpiter).second.ListODFibersV1.end();++iter)
2203  {
2204  if (((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
2205  }
2206 
2207  if (iter==(*rpiter).second.ListODFibersV1.end())
2208  {
2209  LogStream<<MSG::ERROR<<"Cannot find ODFiberV1 PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
2210  //throw new G4Exception("Wrong ODFiberV1");
2211  }
2212  else
2213  {
2214  (*iter).MainRefPointPos=TransPoint;
2215  (*iter).fMainRefPointSlope=fTransSlope;
2216  }
2217 
2218  break;
2219  }
2220  default:
2221  {
2222  LogStream<<MSG::ERROR<<"Unknown ODFiber eFType="<<eFType<<endmsg;
2223  break;
2224  }
2225  }
2226  }
2227  else
2228  {
2229  LogStream<<MSG::ERROR<<"Unknown Roman pot PotID="<<eRPName<<endmsg;
2230  }
2231 
2232 }

◆ SetUFiberPositionToMainReference()

void ALFA_GeometryReader::SetUFiberPositionToMainReference ( const eRPotName  eRPName,
const int  nPlateID,
const int  nFiberID,
const HepGeom::Point3D< float > &  TransPoint,
const double  fTransSlope 
)

Definition at line 1545 of file ALFA_GeometryReader.cxx.

1546 {
1547  std::list<FIBERPARAMS>::iterator iter;
1548  std::map<eRPotName, ROMAPOT>::iterator rpiter;
1549  FIBERPARAMS FiberParams;
1550 
1551  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::SetUFiberPositionToMainReference");
1552 
1553  if(m_eFCoordSystem!=EFCS_CLADDING){
1554  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
1555  return;
1556  }
1557 
1558  if((rpiter=m_MapRPot.find(eRPName))!=m_MapRPot.end()){
1559  for(iter=(*rpiter).second.ListUFibers.begin();iter!=(*rpiter).second.ListUFibers.end();++iter){
1560  if(((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
1561  }
1562 
1563  if(iter==(*rpiter).second.ListUFibers.end()) {
1564  LogStream<<MSG::ERROR<<"Cannot find fiber PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
1565  //throw new Exception("Wrong U-fiber");
1566  }
1567  else{
1568  (*iter).MainRefPointPos=TransPoint;
1569  (*iter).fMainRefPointSlope=fTransSlope;
1570  }
1571  }
1572  else{
1573  LogStream<<MSG::ERROR<<"Unknown Roman pot PotID="<<eRPName<<endmsg;
1574  }
1575 }

◆ SetupCurrentLVDT()

void ALFA_GeometryReader::SetupCurrentLVDT ( const PGEOMETRYCONFIGURATION  pConfig)
private

Definition at line 3049 of file ALFA_GeometryReader.cxx.

3050 {
3051  m_RPPosParams[ERPN_B7L1U].fCurrentLVDTmm=pConfig->CfgRPosParams[0].fCurrentLVDTmm;
3052  m_RPPosParams[ERPN_B7L1L].fCurrentLVDTmm=pConfig->CfgRPosParams[1].fCurrentLVDTmm;
3053  m_RPPosParams[ERPN_A7L1U].fCurrentLVDTmm=pConfig->CfgRPosParams[2].fCurrentLVDTmm;
3054  m_RPPosParams[ERPN_A7L1L].fCurrentLVDTmm=pConfig->CfgRPosParams[3].fCurrentLVDTmm;
3055  m_RPPosParams[ERPN_A7R1U].fCurrentLVDTmm=pConfig->CfgRPosParams[4].fCurrentLVDTmm;
3056  m_RPPosParams[ERPN_A7R1L].fCurrentLVDTmm=pConfig->CfgRPosParams[5].fCurrentLVDTmm;
3057  m_RPPosParams[ERPN_B7R1U].fCurrentLVDTmm=pConfig->CfgRPosParams[6].fCurrentLVDTmm;
3058  m_RPPosParams[ERPN_B7R1L].fCurrentLVDTmm=pConfig->CfgRPosParams[7].fCurrentLVDTmm;
3059 }

◆ SetupDetMetrologyPoints()

bool ALFA_GeometryReader::SetupDetMetrologyPoints ( ALFA_ConfigParams &  CfgParams,
eRPotName  eRPName 
)
private

Definition at line 2630 of file ALFA_GeometryReader.cxx.

2631 {
2632  //bool bIsLightMetrology=true;
2633 
2634  double fZc;
2635  //double a1,a2;
2636  double a3,a4;
2637  double xp1,yp1;
2638  //double xp2,yp2,xp3,yp3,xr3;
2639  double xr1,yr1,xr2,yr2;//,yr3;
2640  HepGeom::Point3D<double> PointIdealD3, PointRealD3;
2641  HepGeom::Point3D<double> PointIdealD4, PointRealD4;
2642  HepGeom::Point3D<double> PointIdealD5, PointRealD5;
2643 
2644  std::vector<double> vecDetEdges;
2645  std::vector<HepGeom::Point3D<double> > vecNominalDetPoints;
2646  std::vector<HepGeom::Point3D<double> > vecRealDetPoints;
2647 
2648  // load nominal & real position of PSx in RP CS
2649  if(!CfgParams.IsKey("idealrefdetpoints")) return false;
2650  if(!ParseRefPoints(CfgParams.GetParameter("idealrefdetpoints"),vecNominalDetPoints,EMCS_ROMANPOT)) return false;
2651  if(!CfgParams.IsKey("realrefdetpoints")) return false;
2652  if(!ParseRefPoints(CfgParams.GetParameter("realrefdetpoints"),vecRealDetPoints,EMCS_ROMANPOT)) return false;
2653 
2654  if(!CfgParams.IsKey("realdetedgeypos")) return false;
2655  if(!ParseArrayOfValues(CfgParams.GetParameter("realdetedgeypos"),vecDetEdges)) return false;
2656 
2657  fZc=0.5*(vecDetEdges[0]+vecDetEdges[1]);
2658  PointIdealD3=HepGeom::Point3D<double>(10.0,0.0,0.0);
2659  PointIdealD4=HepGeom::Point3D<double>(0.0,10.0,0.0);
2660  PointIdealD5=HepGeom::Point3D<double>(0.0,0.0,10.0);
2661 
2662  //compute in-plane transformation matrix (deformation not included)
2663  xp1=vecNominalDetPoints[0].x();
2664  yp1=vecNominalDetPoints[0].y();
2665  //xp2=vecNominalDetPoints[1].x();
2666  //yp2=vecNominalDetPoints[1].y();
2667  //xp3=vecNominalDetPoints[2].x();
2668  //yp3=vecNominalDetPoints[2].y();
2669 
2670  xr1=vecRealDetPoints[0].x();
2671  yr1=vecRealDetPoints[0].y();
2672  xr2=vecRealDetPoints[1].x();
2673  yr2=vecRealDetPoints[1].y();
2674  //xr3=vecRealDetPoints[2].x();
2675  //yr3=vecRealDetPoints[2].y();
2676 
2677  double alpha=-atan((xr2-xr1)/(yr2-yr1));
2678  //a1=cos(alpha); a2=-sin(alpha);
2679  a3=xr1-xp1;//a3=0.5*(xr1+xr2);
2680  a4=yr1-yp1;//a4=0.5*(yr1+yr2);
2681 
2682  //double beta=-asin((vecDetEdges[1]-vecDetEdges[0])/90.0);
2683  //double gamma=asin((yr3-yr1)/8.0);
2684  //double dz=135.0*sin(gamma);
2685 
2686  //-----------------------------------------
2687  HepGeom::Transform3D CorrectionInMainPoint, CorrectionInDetPin1;
2688 
2689  //HepGeom::Transform3D CorrectionInDetPin1=HepTransform3D();
2690  //use light metrology
2691  CorrectionInDetPin1=HepGeom::Translate3D(a3,a4,fZc-113.0*CLHEP::mm)*HepGeom::RotateZ3D(alpha);
2692  //CorrectionInDetPin1=HepGeom::RotateX3D(gamma)*HepGeom::RotateY3D(beta)*HepGeom::Translate3D(a3,a4,dz+fZc-113.0*CLHEP::mm)*HepGeom::RotateZ3D(alpha);
2693 
2694  //HepGeom::Point3D<double> MainPoint=m_RPPosParams[eRPName].RPIdealTransformInStation*HepGeom::Point3D<double>(0.0,0.0,0.0);
2695  HepGeom::Point3D<double> MainPoint=ms_NominalRPMainPoint;
2696  HepGeom::Point3D<double> RPPin1=ms_NominalRPPin1;
2697  HepGeom::Point3D<double> DetPin1=ms_NominalDetPin1;
2698 
2699  //recalculate SW transform in MainPoint
2700  HepGeom::Vector3D<double> OriginShift=RPPin1+DetPin1-MainPoint;
2701 
2702  CLHEP::Hep3Vector TranslationInMainPoint=CorrectionInDetPin1.getTranslation()-CorrectionInDetPin1*OriginShift+OriginShift;
2703 
2704  CLHEP::HepRotation RotationInMainPoint=CorrectionInDetPin1.getRotation();
2705  CorrectionInMainPoint=HepGeom::Transform3D(RotationInMainPoint,TranslationInMainPoint);
2706 
2707  PointRealD3=CorrectionInMainPoint*PointIdealD3;
2708  PointRealD4=CorrectionInMainPoint*PointIdealD4;
2709  PointRealD5=CorrectionInMainPoint*PointIdealD5;
2710 
2711  m_RPPosParams[eRPName].VecIdealDetRefPoints.resize(3);
2712  m_RPPosParams[eRPName].VecRealDetRefPoints.resize(3);
2713 
2714  m_RPPosParams[eRPName].VecIdealDetRefPoints[0]=PointIdealD5;
2715  m_RPPosParams[eRPName].VecRealDetRefPoints[0]=PointRealD5;
2716 
2717  m_RPPosParams[eRPName].VecIdealDetRefPoints[1]=PointIdealD4;
2718  m_RPPosParams[eRPName].VecRealDetRefPoints[1]=PointRealD4;
2719 
2720  m_RPPosParams[eRPName].VecIdealDetRefPoints[2]=PointIdealD3;
2721  m_RPPosParams[eRPName].VecRealDetRefPoints[2]=PointRealD3;
2722 
2723  return true;
2724 }

◆ SetupRPMetrologyPoints()

bool ALFA_GeometryReader::SetupRPMetrologyPoints ( ALFA_ConfigParams &  CfgParams,
eRPotName  eRPName 
)
private

Definition at line 2726 of file ALFA_GeometryReader.cxx.

2727 {
2728  bool bRes=true;
2729  const int nCnt=3;
2730  int i;
2731  double fx,fy,fz;
2732  double fCurrentLVDTmm;
2733  HepGeom::Point3D<double> PSinStation, RPPinNominal;
2734  double fCurrentLVDT=0.0;
2735  std::vector<double> vecPolyFitParams;
2736  std::vector<HepGeom::Point3D<double> > vecPSinRPCS;
2737  std::vector<HepGeom::Point3D<double> > vecNominalPSinStationCS;
2738  std::vector<HepGeom::Point3D<double> > vecRealPSinStationCS;
2739  RPPOSPARAMS RPPosParams;
2740 
2741  GetRPPosParams(&RPPosParams,eRPName);
2742  if(!RPPosParams.bIsLow){
2743  RPPinNominal=HepGeom::Point3D<double>(77.5*CLHEP::mm,172.2*CLHEP::mm,-124.0*CLHEP::mm);
2744  }
2745  else{
2746  RPPinNominal=HepGeom::Point3D<double>(77.5*CLHEP::mm,-172.2*CLHEP::mm,+124.0*CLHEP::mm);
2747  }
2748 
2749  vecNominalPSinStationCS.resize(nCnt);
2750  vecRealPSinStationCS.resize(nCnt);
2751 
2752  // load nominal position of PSx in RP CS
2753  if(!CfgParams.IsKey("psinrpss")) return false;
2754  if(!ParseRefPoints(CfgParams.GetParameter("psinrpss"),vecPSinRPCS,EMCS_ROMANPOT)) return false;
2755 
2756  //compute nominal position of PSx in Station CS
2757  for(i=0;i<nCnt;i++){
2758  vecNominalPSinStationCS[i]=RPPinNominal+HepGeom::RotateX3D(RPPosParams.bIsLow? 180*CLHEP::deg:0.0)*vecPSinRPCS[i];
2759  //HepGeom::Point3D<double> auxPoint=vecNominalPSinStationCS[i];
2760  //int a=0;
2761  }
2762 
2763  //----- test
2764  // if(RPPosParams.bIsLow){
2765  // vecNominalPSinStationCS[0]=HepGeom::Point3D<double>(+132.0*CLHEP::mm,-170.0*CLHEP::mm,-132.0*CLHEP::mm);
2766  // vecNominalPSinStationCS[1]=HepGeom::Point3D<double>(+132.0*CLHEP::mm,-170.0*CLHEP::mm,+132.0*CLHEP::mm);
2767  // vecNominalPSinStationCS[2]=HepGeom::Point3D<double>(-132.0*CLHEP::mm,-170.0*CLHEP::mm,+132.0*CLHEP::mm);
2768  // }
2769  // else{
2770  // vecNominalPSinStationCS[0]=HepGeom::Point3D<double>(+132.0*CLHEP::mm,-170.0*CLHEP::mm,+132.0*CLHEP::mm);
2771  // vecNominalPSinStationCS[1]=HepGeom::Point3D<double>(+132.0*CLHEP::mm,-170.0*CLHEP::mm,-132.0*CLHEP::mm);
2772  // vecNominalPSinStationCS[2]=HepGeom::Point3D<double>(-132.0*CLHEP::mm,-170.0*CLHEP::mm,+132.0*CLHEP::mm);
2773  // }
2774  //----- test
2775 
2776  //calculate LVDT position from position in [mm]
2777  fCurrentLVDTmm=RPPosParams.fCurrentLVDTmm;
2778  //if(m_bIsUserLVDTEnabled) fCurrentLVDTmm=RPPosParams.fCurrentLVDTmm;
2779  //else fCurrentLVDTmm=atof(CfgParams.GetParameter("currentlvdt")); //value in [mm] !
2780 
2781  ParseArrayOfValues(CfgParams.GetParameter("mm2lvdtfit"),vecPolyFitParams);
2782  fCurrentLVDT=GetPolyFitValue(fCurrentLVDTmm,vecPolyFitParams); // true LVDT value
2783 
2784  //compute real position of PSx in Station CS from LVDT parametrization
2785  ParseArrayOfValues(CfgParams.GetParameter("ps1xlvdtpolyfit"),vecPolyFitParams);
2786  fx=GetPolyFitValue(fCurrentLVDT,vecPolyFitParams);
2787  ParseArrayOfValues(CfgParams.GetParameter("ps1ylvdtpolyfit"),vecPolyFitParams);
2788  fy=GetPolyFitValue(fCurrentLVDT,vecPolyFitParams);
2789  ParseArrayOfValues(CfgParams.GetParameter("ps1zlvdtpolyfit"),vecPolyFitParams);
2790  fz=GetPolyFitValue(fCurrentLVDT,vecPolyFitParams);
2791  PSinStation.set(fx,fy,fz);
2792  vecRealPSinStationCS[0]=PSinStation;
2793 
2794  ParseArrayOfValues(CfgParams.GetParameter("ps2xlvdtpolyfit"),vecPolyFitParams);
2795  fx=GetPolyFitValue(fCurrentLVDT,vecPolyFitParams);
2796  ParseArrayOfValues(CfgParams.GetParameter("ps2ylvdtpolyfit"),vecPolyFitParams);
2797  fy=GetPolyFitValue(fCurrentLVDT,vecPolyFitParams);
2798  ParseArrayOfValues(CfgParams.GetParameter("ps2zlvdtpolyfit"),vecPolyFitParams);
2799  fz=GetPolyFitValue(fCurrentLVDT,vecPolyFitParams);
2800  PSinStation.set(fx,fy,fz);
2801  vecRealPSinStationCS[1]=PSinStation;
2802 
2803  ParseArrayOfValues(CfgParams.GetParameter("ps3xlvdtpolyfit"),vecPolyFitParams);
2804  fx=GetPolyFitValue(fCurrentLVDT,vecPolyFitParams);
2805  ParseArrayOfValues(CfgParams.GetParameter("ps3ylvdtpolyfit"),vecPolyFitParams);
2806  fy=GetPolyFitValue(fCurrentLVDT,vecPolyFitParams);
2807  ParseArrayOfValues(CfgParams.GetParameter("ps3zlvdtpolyfit"),vecPolyFitParams);
2808  fz=GetPolyFitValue(fCurrentLVDT,vecPolyFitParams);
2809  PSinStation.set(fx,fy,fz);
2810  vecRealPSinStationCS[2]=PSinStation;
2811 
2812  //----- test
2813  //vecRealPSinStationCS[0]=vecNominalPSinStationCS[0]+HepGeom::Point3D<double>(0.0*CLHEP::mm,0.0*CLHEP::mm,0.0*CLHEP::mm);
2814  //vecRealPSinStationCS[1]=vecNominalPSinStationCS[1]+HepGeom::Point3D<double>(0.0*CLHEP::mm,0.0*CLHEP::mm,0.0*CLHEP::mm);
2815  //vecRealPSinStationCS[2]=vecNominalPSinStationCS[2]+HepGeom::Point3D<double>(0.0*CLHEP::mm,0.1*CLHEP::mm,0.0*CLHEP::mm);
2816  //----- test
2817 
2818  //m_RPPosParams[eRPName].fCurrentLVDTmm=fCurrentLVDTmm;
2819  m_RPPosParams[eRPName].VecIdealRPRefPoints=vecNominalPSinStationCS;
2820  m_RPPosParams[eRPName].VecRealRPRefPoints=vecRealPSinStationCS;
2821 
2822  bRes=true;
2823 
2824  return bRes;
2825 }

◆ SetupStationMetrologyPoints()

bool ALFA_GeometryReader::SetupStationMetrologyPoints ( ALFA_ConfigParams &  CfgParams,
eAStationName  eASName 
)
private

Definition at line 2827 of file ALFA_GeometryReader.cxx.

2828 {
2829  std::vector<HepGeom::Point3D<double> > vecShiftPoints;
2830 
2831  // load shift E
2832  if(!CfgParams.IsKey("shifte")) return false;
2833  if(!ParseRefPoints(CfgParams.GetParameter("shifte"),vecShiftPoints,EMCS_ATLAS)) return false;
2834  m_ASPosParams[eASName].ShiftE=vecShiftPoints[0];
2835 
2836  // load shift S
2837  if(!CfgParams.IsKey("shifts")) return false;
2838  if(!ParseRefPoints(CfgParams.GetParameter("shifts"),vecShiftPoints,EMCS_ATLAS)) return false;
2839  m_ASPosParams[eASName].ShiftS=vecShiftPoints[0];
2840 
2841  return true;
2842 }

◆ SetupSWCorrections()

void ALFA_GeometryReader::SetupSWCorrections ( const PGEOMETRYCONFIGURATION  pConfig)
private

Definition at line 3061 of file ALFA_GeometryReader.cxx.

3062 {
3063  int i, nSign;
3064  double fTotYOffset;
3065  //double arrFWDistance[8]={0.000, 0.020, -0.050, 0.003, -0.054, 0.012, -0.046, 0.045};
3066 
3067  for(i=0;i<RPOTSCNT;i++){
3068  nSign=(i%2==0)? +1:-1;
3069  fTotYOffset=pConfig->CfgRPosParams[i].swcorr.fYOffset-nSign*(2.0*CLHEP::mm);//+nSign*arrFWDistance[i];
3070  //fTotYOffset=pConfig->CfgRPosParams[i].swcorr.fYOffset;
3071 
3072  m_RPPosParams[(eRPotName)(i+1)].OriginOfDetSWTransform=HepGeom::Point3D<double>(-77.5*CLHEP::mm+pConfig->CfgRPosParams[i].swcorr.fXOffset,-170.2*CLHEP::mm,114.0*CLHEP::mm);
3073  m_RPPosParams[(eRPotName)(i+1)].DetSWTransform=HepGeom::RotateZ3D(nSign*pConfig->CfgRPosParams[i].swcorr.fTheta);
3074  m_RPPosParams[(eRPotName)(i+1)].RPSWTransformInStation=HepGeom::Translate3D(-pConfig->CfgRPosParams[i].swcorr.fXOffset,fTotYOffset,0.0*CLHEP::mm);
3075  }
3076 }

◆ SetupUserCorrections()

void ALFA_GeometryReader::SetupUserCorrections ( const PGEOMETRYCONFIGURATION  pConfig)
private

Definition at line 3078 of file ALFA_GeometryReader.cxx.

3079 {
3080  if(m_eMetrologyType==EMT_NOMINAL){
3081  for(int i=0;i<RPOTSCNT;i++){
3082  if(pConfig->CfgRPosParams[i].usercorr.bIsEnabledUserTranform){
3083  m_RPPosParams[(eRPotName)(i+1)].OriginOfDetSWTransform=pConfig->CfgRPosParams[i].usercorr.UserOriginOfDetTransInRPot;
3084  m_RPPosParams[(eRPotName)(i+1)].DetSWTransform=pConfig->CfgRPosParams[i].usercorr.UserTransformOfDetInRPot;
3085  m_RPPosParams[(eRPotName)(i+1)].RPSWTransformInStation=pConfig->CfgRPosParams[i].usercorr.UserTransformOfRPInStation;
3086  }
3087  }
3088  }
3089 }

◆ SetVFiberPositionToMainReference()

void ALFA_GeometryReader::SetVFiberPositionToMainReference ( const eRPotName  eRPName,
const int  nPlateID,
const int  nFiberID,
const HepGeom::Point3D< float > &  TransPoint,
const double  fTransSlope 
)

Definition at line 1577 of file ALFA_GeometryReader.cxx.

1578 {
1579  std::list<FIBERPARAMS>::iterator iter;
1580  std::map<eRPotName, ROMAPOT>::iterator rpiter;
1581  FIBERPARAMS FiberParams;
1582 
1583  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::SetVFiberPositionToMainReference");
1584 
1585  if(m_eFCoordSystem!=EFCS_CLADDING){
1586  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
1587  return;
1588  }
1589 
1590  if((rpiter=m_MapRPot.find(eRPName))!=m_MapRPot.end()){
1591  for(iter=(*rpiter).second.ListVFibers.begin();iter!=(*rpiter).second.ListVFibers.end();++iter){
1592  if(((*iter).nPlateID==nPlateID) && ((*iter).nFiberID==nFiberID)) break;
1593  }
1594 
1595  if(iter==(*rpiter).second.ListVFibers.end()){
1596  LogStream<<MSG::ERROR<<"Cannot find fiber PotID="<<eRPName<<", PlateID="<<nPlateID<<" and FiberID="<<nFiberID<<endmsg;
1597  //throw new Exception("Wrong U-fiber");
1598  }
1599  else{
1600  (*iter).MainRefPointPos=TransPoint;
1601  (*iter).fMainRefPointSlope=fTransSlope;
1602  }
1603  }
1604  else{
1605  LogStream<<MSG::ERROR<<"Unknown Roman pot PotID="<<eRPName<<endmsg;
1606  }
1607 }

◆ StoreReconstructionGeometry()

bool ALFA_GeometryReader::StoreReconstructionGeometry ( const eRPotName  eRPName,
const eFiberType  eFType,
const char *  szDataDestination 
)

Definition at line 1718 of file ALFA_GeometryReader.cxx.

1719 {
1720  int i,j;
1721  double fParamB, fY, fX, fZ, fSlope;
1722  FILE * pFile;
1723  FIBERPARAMS FiberParams;
1724 
1725  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::StoreReconstructionGeometry");
1726 
1727  if(!(m_eFCoordSystem==EFCS_CLADDING || m_eFCoordSystem==EFCS_ATLAS)){
1728  LogStream<<MSG::ERROR<<"Invalid coordinate system"<<endmsg;
1729  return false;
1730  }
1731 
1732  pFile = fopen(szDataDestination, "w");
1733  if(pFile==nullptr) return false;
1734 
1735  fprintf(pFile, "xxxxxxxxxxxxxxxxxxx\n");
1736 
1737 
1738  if (eFType==EFT_FIBERMD)
1739  {
1740  fprintf(pFile, "20\n");
1741 
1742  for(i=1;i<=ALFAPLATESCNT;i++){
1743  //U-fiber
1744  for(j=1;j<=ALFAFIBERSCNT;j++){
1745  if(GetUFiberParams(&FiberParams, eRPName, i, j)){
1746  if(m_eFCoordSystem==EFCS_CLADDING){
1747  fX=FiberParams.MainRefPointPos.x();
1748  fY=FiberParams.MainRefPointPos.y();
1749  fZ=FiberParams.MainRefPointPos.z();
1750  fSlope=FiberParams.fMainRefPointSlope;
1751  //fSlope=FiberParams.fSlope;
1752  fParamB=fY-fSlope*fX;
1753  }
1754  else {
1755  fSlope=FiberParams.fcs_atlas.fSlope;
1756  fParamB=FiberParams.fcs_atlas.fOffset;
1757  fZ=FiberParams.fcs_atlas.fZPos;
1758  }
1759 
1760  fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", (i*2-1), j, fSlope, fParamB, fZ);
1761  }
1762  }
1763 
1764  //V-fiber
1765  for(j=1;j<=ALFAFIBERSCNT;j++){
1766  if(GetVFiberParams(&FiberParams, eRPName, i, j)){
1767  if(m_eFCoordSystem==EFCS_CLADDING){
1768  fX=FiberParams.MainRefPointPos.x();
1769  fY=FiberParams.MainRefPointPos.y();
1770  fZ=FiberParams.MainRefPointPos.z();
1771  fSlope=FiberParams.fMainRefPointSlope;
1772  //fSlope=FiberParams.fSlope;
1773  fParamB=fY-fSlope*fX;
1774  }
1775  else {
1776  fSlope=FiberParams.fcs_atlas.fSlope;
1777  fParamB=FiberParams.fcs_atlas.fOffset;
1778  fZ=FiberParams.fcs_atlas.fZPos;
1779  }
1780 
1781  fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", (i*2), j, fSlope, fParamB, fZ);
1782  }
1783  }
1784  }
1785  }
1786  else if (eFType==EFT_FIBEROD)
1787  {
1788  fprintf(pFile, "6\n");
1789 
1790  for(int i=1; i<=ODPLATESCNT; i++)
1791  {
1792  //V0-ODFiber
1793  for(j=1;j<=ODFIBERSCNT;j++)
1794  {
1795  if(GetODFiberParams(&FiberParams, EFT_ODFIBERV0, eRPName, i, j))
1796  {
1797  if(m_eFCoordSystem==EFCS_CLADDING){
1798  fX=FiberParams.MainRefPointPos.x();
1799  fY=FiberParams.MainRefPointPos.y();
1800  fZ=FiberParams.MainRefPointPos.z();
1801  fSlope=FiberParams.fMainRefPointSlope;
1802  fParamB=fY-fSlope*fX;
1803  }
1804  else {
1805  fSlope=FiberParams.fcs_atlas.fSlope;
1806  fParamB=FiberParams.fcs_atlas.fOffset;
1807  fZ=FiberParams.fcs_atlas.fZPos;
1808  }
1809 
1810  fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", (i*2-1), j, fSlope, fParamB, fZ);
1811  }
1812  }
1813 
1814  //U0-ODFiber (note: U0-nFiberID is indexed from 16 to 30)
1815  for(j=ODFIBERSCNT+1;j<=ODFIBERSCNT+15;j++)
1816  {
1817  if(GetODFiberParams(&FiberParams, EFT_ODFIBERU0, eRPName, i, j))
1818  {
1819  if(m_eFCoordSystem==EFCS_CLADDING){
1820  fX=FiberParams.MainRefPointPos.x();
1821  fY=FiberParams.MainRefPointPos.y();
1822  fZ=FiberParams.MainRefPointPos.z();
1823  fSlope=FiberParams.fMainRefPointSlope;
1824  fParamB=fY-fSlope*fX;
1825  }
1826  else {
1827  fSlope=FiberParams.fcs_atlas.fSlope;
1828  fParamB=FiberParams.fcs_atlas.fOffset;
1829  fZ=FiberParams.fcs_atlas.fZPos;
1830  }
1831 
1832  fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", (i*2-1), j, fSlope, fParamB, fZ);
1833  }
1834  }
1835 
1836  //1.10.2010 LN: change of indexation scheme
1837  //V1-ODFiber (note: V1-nFiberID is indexed from 16 to 30)
1838  //for(j=ODFIBERSCNT+1;j<=ODFIBERSCNT+15;j++)
1839  for(j=1;j<=ODFIBERSCNT;j++)
1840  {
1841  if(GetODFiberParams(&FiberParams, EFT_ODFIBERV1, eRPName, i, j))
1842  {
1843  if(m_eFCoordSystem==EFCS_CLADDING){
1844  fX=FiberParams.MainRefPointPos.x();
1845  fY=FiberParams.MainRefPointPos.y();
1846  fZ=FiberParams.MainRefPointPos.z();
1847  fSlope=FiberParams.fMainRefPointSlope;
1848  fParamB=fY-fSlope*fX;
1849  }
1850  else {
1851  fSlope=FiberParams.fcs_atlas.fSlope;
1852  fParamB=FiberParams.fcs_atlas.fOffset;
1853  fZ=FiberParams.fcs_atlas.fZPos;
1854  }
1855  fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", (i*2), j, fSlope, fParamB, fZ);
1856  }
1857  }
1858 
1859  //U1-ODFiber
1860  //1.10.2010 LN: change of indexation scheme
1861  //for(j=1;j<=ODFIBERSCNT;j++)
1862  for(j=ODFIBERSCNT+1;j<=ODFIBERSCNT+15;j++)
1863  {
1864  if(GetODFiberParams(&FiberParams, EFT_ODFIBERU1, eRPName, i, j))
1865  {
1866  if(m_eFCoordSystem==EFCS_CLADDING){
1867  fX=FiberParams.MainRefPointPos.x();
1868  fY=FiberParams.MainRefPointPos.y();
1869  fZ=FiberParams.MainRefPointPos.z();
1870  fSlope=FiberParams.fMainRefPointSlope;
1871  fParamB=fY-fSlope*fX;
1872  }
1873  else {
1874  fSlope=FiberParams.fcs_atlas.fSlope;
1875  fParamB=FiberParams.fcs_atlas.fOffset;
1876  fZ=FiberParams.fcs_atlas.fZPos;
1877  }
1878  fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", (i*2), j, fSlope, fParamB, fZ);
1879  }
1880  }
1881 
1882  }
1883  }
1884 
1885  fclose(pFile);
1886 
1887  return true;
1888 }

◆ TransformFiberPositions()

void ALFA_GeometryReader::TransformFiberPositions ( PFIBERPARAMS  pFiberParams,
eRPotName  eRPName,
const eFiberType  eType,
const eGeoSourceType  eSourceType 
)
private

Definition at line 120 of file ALFA_GeometryReader.cxx.

121 {
122  switch(m_eFCoordSystem)
123  {
124  case EFCS_CLADDING:
125  TransformFiberPositionsFCSCladding(pFiberParams, eRPName, eType, eSourceType);
126  break;
127  case EFCS_ATLAS:
128  TransformFiberPositionsFCSAtlas(pFiberParams, eRPName, eType, eSourceType);
129  break;
130  default:
131  break;
132  }
133 }

◆ TransformFiberPositionsFCSAtlas()

void ALFA_GeometryReader::TransformFiberPositionsFCSAtlas ( PFIBERPARAMS  pFiberParams,
eRPotName  eRPName,
const eFiberType  eType,
const eGeoSourceType  eSourceType 
)
private

Definition at line 274 of file ALFA_GeometryReader.cxx.

275 {
276  HepGeom::Transform3D TotTrans;
277  RPPOSPARAMS RPPosParams;
278  ASPOSPARAMS ASPosParams;
279  GetRPPosParams(&RPPosParams, eRPName);
280  GetASPosParams(&ASPosParams, RPPosParams.eASName);
281 
282  const double MD_stagger[10] = {0.0, 0.283, -0.141, 0.141, -0.283, 0.354, -0.071, 0.212, -0.212, 0.071};
283  const double OD_stagger[3] = {0.0, -0.167, -0.334};
284  const double fSCY=-126.3765+0.0045;
285 
286  const double fSCY_ODFiberU=-106.333;
287  const double fSCY_ODFiberV=-113.833;
288 
289  //const double fSCX_ODFiber00=-23.00;
290  //const double fSCX_ODFiber01=+23.00;
291 
292  //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::TransformFiberPositionsFCSAtlas");
293 
294  //HepGeom::Point3D<double> RealDetRefPointInATLAS=RPPosParams.RPTransformInATLAS*RPPosParams.IdealRefPoint;
295  double fCentrePos=0.0, fZOffset=0.0;
296  double fStagger=0.0;
297 
298  switch(eType)
299  {
300  case EFT_VFIBER:
301  case EFT_UFIBER:
302  fStagger=MD_stagger[pFiberParams->nPlateID-1]*CLHEP::mm;
303 
304  if(eSourceType==EGST_IDEALGEOMETRY){
305  if(eType==EFT_VFIBER){
306  fCentrePos=(+15.75-0.5*(pFiberParams->nFiberID-1))*CLHEP::mm;
307  pFiberParams->fOffset=-1.414213562*fCentrePos+fSCY-fStagger;
308  }
309  else if(eType==EFT_UFIBER){
310  fCentrePos=(+15.75-0.5*(pFiberParams->nFiberID-1))*CLHEP::mm;
311  pFiberParams->fOffset=+1.414213562*fCentrePos+fSCY+fStagger;
312  }
313  }
314 
315  if(!RPPosParams.bIsLow) fZOffset=(pFiberParams->nLayerID-1)*CLHEP::mm;
316  else fZOffset=-(pFiberParams->nLayerID-1)*CLHEP::mm;
317 
318  break;
319  case EFT_ODFIBERV0:
320  case EFT_ODFIBERV1:
321  fStagger=OD_stagger[pFiberParams->nPlateID-1]*CLHEP::mm;
322 
323  if(eSourceType==EGST_IDEALGEOMETRY){
324  if(eType==EFT_ODFIBERV0){
325  fCentrePos=(-29.75+0.5*(pFiberParams->nFiberID-1))*CLHEP::mm;
326  pFiberParams->fOffset=fCentrePos+fSCY_ODFiberV+fStagger;
327  }
328  else if(eType==EFT_ODFIBERV1){
329 
330  //1.10.2010 LN: change of indexation scheme
331  //fCentrePos=(-22.75-0.5*(pFiberParams->nFiberID-16))*CLHEP::mm;
332  fCentrePos=(-29.75+0.5*(pFiberParams->nFiberID-1))*CLHEP::mm;
333 
334  pFiberParams->fOffset=fCentrePos+fSCY_ODFiberV+fStagger;
335  }
336  }
337 
338  if(!RPPosParams.bIsLow) fZOffset=2*(pFiberParams->nPlateID-1)*CLHEP::mm+33.65*CLHEP::mm;
339  else fZOffset=-2*(pFiberParams->nPlateID-1)*CLHEP::mm-33.65*CLHEP::mm;
340  break;
341  case EFT_ODFIBERU0:
342  case EFT_ODFIBERU1:
343  fStagger=OD_stagger[pFiberParams->nPlateID-1]*CLHEP::mm;
344 
345  if(eSourceType==EGST_IDEALGEOMETRY){
346  if(eType==EFT_ODFIBERU0){
347  fCentrePos=(-29.75+0.5*(pFiberParams->nFiberID-16))*CLHEP::mm;
348  pFiberParams->fOffset=fCentrePos+fSCY_ODFiberU+fStagger;
349  }
350  else if(eType==EFT_ODFIBERU1){
351 
352  //1.10.2010 LN: change of indexation scheme
353  //fCentrePos=(-22.75-0.5*(pFiberParams->nFiberID-1))*CLHEP::mm;
354  fCentrePos=(-29.75+0.5*(pFiberParams->nFiberID-16))*CLHEP::mm;
355 
356  pFiberParams->fOffset=fCentrePos+fSCY_ODFiberU+fStagger;
357  }
358  }
359 
360  if(!RPPosParams.bIsLow) fZOffset=2*(pFiberParams->nPlateID-1)*CLHEP::mm+32.35*CLHEP::mm;
361  else fZOffset=-2*(pFiberParams->nPlateID-1)*CLHEP::mm-32.35*CLHEP::mm;
362  break;
363  default:
364  break;
365  }
366 
367  HepGeom::Point3D<double> DetFiberPoint1, DetFiberPoint2, DetPin1Point;
368  HepGeom::Point3D<double> AtlFiberPoint1, AtlFiberPoint2, AtlDetPin1Point;
369  HepGeom::Point3D<double> AtlProjFiberPoint1, AtlProjFiberPoint2;
370 
371  DetPin1Point=HepGeom::Point3D<double>(0.0,0.0,0.0);
372  DetFiberPoint1=HepGeom::Point3D<double>(0.0,pFiberParams->fOffset,(RPPosParams.bIsLow)? -fZOffset:+fZOffset);
373  DetFiberPoint2=HepGeom::Point3D<double>(-pFiberParams->fOffset/pFiberParams->fSlope,0.0,(RPPosParams.bIsLow)? -fZOffset:+fZOffset);
374 
375  AtlDetPin1Point=GetDetPointInAtlas(eRPName,AtlDetPin1Point);
376  AtlFiberPoint1=GetDetPointInAtlas(eRPName,DetFiberPoint1);
377  AtlFiberPoint2=GetDetPointInAtlas(eRPName,DetFiberPoint2);
378 
379  AtlProjFiberPoint1=HepGeom::Point3D<double>(AtlFiberPoint1[0],AtlFiberPoint1[1],AtlDetPin1Point[2]+fZOffset);
380  AtlProjFiberPoint2=HepGeom::Point3D<double>(AtlFiberPoint2[0],AtlFiberPoint2[1],AtlDetPin1Point[2]+fZOffset);
381 
382  double fx2=AtlProjFiberPoint1[0]+AtlProjFiberPoint1[1]*(AtlProjFiberPoint2[0]-AtlProjFiberPoint1[0])/(AtlProjFiberPoint1[1]-AtlProjFiberPoint2[1]);
383  double fy1=AtlProjFiberPoint1[1]+AtlProjFiberPoint1[0]*(AtlProjFiberPoint2[1]-AtlProjFiberPoint1[1])/(AtlProjFiberPoint1[0]-AtlProjFiberPoint2[0]);
384 
385  pFiberParams->fcs_atlas.fSlope=-fy1/fx2;
386  pFiberParams->fcs_atlas.fOffset=fy1;
387  pFiberParams->fcs_atlas.fZPos=AtlDetPin1Point[2]+fZOffset;
388 
389  //add full space parameters
390  HepGeom::Vector3D<double> DirVector=AtlFiberPoint2-AtlFiberPoint1;
391 
392  pFiberParams->fcs_atlas_full.fOriginX=AtlFiberPoint1[0];
393  pFiberParams->fcs_atlas_full.fOriginY=AtlFiberPoint1[1];
394  pFiberParams->fcs_atlas_full.fOriginZ=AtlFiberPoint1[2];
395  pFiberParams->fcs_atlas_full.fDirX=DirVector[0]/DirVector.mag();
396  pFiberParams->fcs_atlas_full.fDirY=DirVector[1]/DirVector.mag();
397  pFiberParams->fcs_atlas_full.fDirZ=DirVector[2]/DirVector.mag();
398 
399  /* 2013-01-23: LN - old fashioned calculationfiber slope and offset in atlas cs
400  //TotTrans=ASPosParams.ASTransformInATLAS*ASPosParams.ASTransformInMainPoint*RPPosParams.RPTransformInStation*RPPosParams.DetTransformInMainPoint;
401  TotTrans=ASPosParams.ASTransformInATLAS*RPPosParams.RPTransformInStation*RPPosParams.DetTransformInMainPoint;
402 
403  HepGeom::Point3D<double> IdealDetRefPointInMainPoint;
404  if(RPPosParams.bIsLow==false) {
405  IdealDetRefPointInMainPoint=HepGeom::Point3D<double>(RPPosParams.IdealRefPoint[0]-RPPosParams.IdealMainPoint[0],RPPosParams.IdealRefPoint[1]-RPPosParams.IdealMainPoint[1],RPPosParams.IdealRefPoint[2]+fZOffset-RPPosParams.IdealMainPoint[2]);
406  }
407  else{
408  IdealDetRefPointInMainPoint=HepGeom::Point3D<double>(RPPosParams.IdealRefPoint[0]-RPPosParams.IdealMainPoint[0],-(RPPosParams.IdealRefPoint[1]-RPPosParams.IdealMainPoint[1]),-(RPPosParams.IdealRefPoint[2]+fZOffset-RPPosParams.IdealMainPoint[2]));
409  }
410 
411  HepGeom::Point3D<double> RealDetRefPointInATLAS=TotTrans*IdealDetRefPointInMainPoint;
412 
413  HepGeom::Point3D<double> FiberPointX, FiberPointY;
414  switch(eType)
415  {
416  case EFT_VFIBER:
417  case EFT_UFIBER:
418  FiberPointX=HepGeom::Point3D<double>(IdealDetRefPointInMainPoint[0]+0.0,IdealDetRefPointInMainPoint[1]+pFiberParams->fOffset,IdealDetRefPointInMainPoint[2]);
419  FiberPointY=HepGeom::Point3D<double>(IdealDetRefPointInMainPoint[0]-pFiberParams->fOffset/pFiberParams->fSlope,IdealDetRefPointInMainPoint[1]+0.0,IdealDetRefPointInMainPoint[2]);
420  break;
421  case EFT_ODFIBERV0:
422  case EFT_ODFIBERV1:
423  case EFT_ODFIBERU0:
424  case EFT_ODFIBERU1:
425  FiberPointX=HepGeom::Point3D<double>(IdealDetRefPointInMainPoint[0]+0.0,IdealDetRefPointInMainPoint[1]+pFiberParams->fOffset,IdealDetRefPointInMainPoint[2]);
426  FiberPointY=HepGeom::Point3D<double>(IdealDetRefPointInMainPoint[0]+100.0,IdealDetRefPointInMainPoint[1]+100.0*pFiberParams->fSlope+pFiberParams->fOffset,IdealDetRefPointInMainPoint[2]);
427  break;
428  default:
429  break;
430  }
431 
432  HepGeom::Point3D<double> RealFiberPointXInATLAS=TotTrans*FiberPointX;
433  HepGeom::Point3D<double> RealFiberPointYInATLAS=TotTrans*FiberPointY;
434  HepGeom::Point3D<double> RealProjectedFiberPointXInATLAS=HepGeom::Point3D<double>(RealFiberPointXInATLAS[0],RealFiberPointXInATLAS[1],RealDetRefPointInATLAS[2]);
435  HepGeom::Point3D<double> RealProjectedFiberPointYInATLAS=HepGeom::Point3D<double>(RealFiberPointYInATLAS[0],RealFiberPointYInATLAS[1],RealDetRefPointInATLAS[2]);
436 
437  pFiberParams->fcs_atlas.fSlope=(RealProjectedFiberPointYInATLAS[1]-RealProjectedFiberPointXInATLAS[1])/(RealProjectedFiberPointYInATLAS[0]-RealProjectedFiberPointXInATLAS[0]);
438  //pFiberParams->fcs_atlas.fOffset=RealProjectedFiberPointXInATLAS[1]-pFiberParams->fcs_atlas.fSlope*RealProjectedFiberPointXInATLAS[0];
439  HepGeom::Point3D<double> FiberPointYInAtlas=GetDetPointInAtlas(eRPName,FiberPointY);
440  pFiberParams->fcs_atlas.fOffset=FiberPointYInAtlas[1];
441  pFiberParams->fcs_atlas.fZPos=RealDetRefPointInATLAS[2];
442  */
443 }

◆ TransformFiberPositionsFCSCladding()

void ALFA_GeometryReader::TransformFiberPositionsFCSCladding ( PFIBERPARAMS  pFiberParams,
eRPotName  eRPName,
const eFiberType  eType,
const eGeoSourceType  eSourceType 
)
private

Definition at line 135 of file ALFA_GeometryReader.cxx.

136 {
137  const double ALFA_stagger[10] = {0.0, 0.283, -0.141, 0.141, -0.283, 0.354, -0.071, 0.212, -0.212, 0.071};
138  const double OD_stagger[3] = {0.0, -0.167, -0.334};
139  const double fSCY=-126.3765+0.0045;
140 
141  const double fSCY_ODFiberU=-106.333;
142  const double fSCY_ODFiberV=-113.833;
143 
144  const double fSCX_ODFiber00=-23.00;
145  const double fSCX_ODFiber01=+23.00;
146 
147  double fStagger=0.0;
148 
149  MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::TransformFiberPositions");
150 
151  switch(eType)
152  {
153  case EFT_UFIBER:
154  case EFT_VFIBER:
155  if(pFiberParams->nPlateID<1 || pFiberParams->nPlateID>10)
156  {
157  LogStream<<MSG::ERROR<<"Wrong PlateID "<<pFiberParams->nPlateID<<" (RP no."<<eRPName<<")"<<endmsg;
158  return;
159  }
160  else
161  {
162  fStagger=ALFA_stagger[pFiberParams->nPlateID-1]*CLHEP::mm;
163  }
164  break;
165  case EFT_ODFIBERU0:
166  case EFT_ODFIBERU1:
167  case EFT_ODFIBERV0:
168  case EFT_ODFIBERV1:
169  if(pFiberParams->nPlateID<1 || pFiberParams->nPlateID>3)
170  {
171  LogStream<<MSG::ERROR<<"Wrong ODPlateID "<<pFiberParams->nPlateID<<" (RP no."<<eRPName<<")"<<endmsg;
172  return;
173  }
174  else
175  {
176  fStagger=OD_stagger[pFiberParams->nPlateID-1]*CLHEP::mm;
177  }
178  break;
179  default:
180  break;
181  }
182 
183  switch(eSourceType){
184  case EGST_IDEALGEOMETRY:
185  if(eType==EFT_VFIBER){
186  pFiberParams->fcs_cladding.fAngle=(+90*CLHEP::deg-atan(pFiberParams->fSlope))-(+45*CLHEP::deg);
187  pFiberParams->fcs_cladding.fCentreXPos=(+15.75-0.5*(pFiberParams->nFiberID-1))*CLHEP::mm;
188 
189  //adjust fiber offset
190  pFiberParams->fOffset=-1.414213562*pFiberParams->fcs_cladding.fCentreXPos+fSCY-fStagger;
191  }
192  if(eType==EFT_UFIBER){
193  pFiberParams->fcs_cladding.fAngle=(-90*CLHEP::deg-atan(pFiberParams->fSlope))-(-45*CLHEP::deg);
194  pFiberParams->fcs_cladding.fCentreXPos=(+15.75-0.5*(pFiberParams->nFiberID-1))*CLHEP::mm;
195 
196  //adjust fiber offset
197  pFiberParams->fOffset=+1.414213562*pFiberParams->fcs_cladding.fCentreXPos+fSCY+fStagger;
198  }
199  if(eType==EFT_ODFIBERV0)
200  {
201  pFiberParams->fcs_cladding.fAngle=0*CLHEP::deg;
202  pFiberParams->fcs_cladding.fCentreYPos=(-29.75+0.5*(pFiberParams->nFiberID-1))*CLHEP::mm;
203 
204  //adjust fiber offset
205  pFiberParams->fOffset=pFiberParams->fcs_cladding.fCentreYPos+fSCY_ODFiberV+fStagger;
206  }
207  if(eType==EFT_ODFIBERU0)
208  {
209  pFiberParams->fcs_cladding.fAngle=0*CLHEP::deg;
210  pFiberParams->fcs_cladding.fCentreYPos=(-29.75+0.5*(pFiberParams->nFiberID-16))*CLHEP::mm;
211 
212  //adjust fiber offset
213  pFiberParams->fOffset=pFiberParams->fcs_cladding.fCentreYPos+fSCY_ODFiberU+fStagger;
214  }
215  if(eType==EFT_ODFIBERU1)
216  {
217  pFiberParams->fcs_cladding.fAngle=0*CLHEP::deg;
218  //1.10.2010 LN: change of indexation scheme
219  //pFiberParams->fcs_cladding.fCentreYPos=(-22.75-0.5*(pFiberParams->nFiberID-1))*CLHEP::mm;
220  pFiberParams->fcs_cladding.fCentreYPos=(-29.75+0.5*(pFiberParams->nFiberID-16))*CLHEP::mm;
221 
222  //adjust fiber offset
223  pFiberParams->fOffset=pFiberParams->fcs_cladding.fCentreYPos+fSCY_ODFiberU+fStagger;
224  }
225  if (eType==EFT_ODFIBERV1)
226  {
227  pFiberParams->fcs_cladding.fAngle=0*CLHEP::deg;
228  //1.10.2010 LN: change of indexation scheme
229  //pFiberParams->fcs_cladding.fCentreYPos=(-22.75-0.5*(pFiberParams->nFiberID-16))*CLHEP::mm;
230  pFiberParams->fcs_cladding.fCentreYPos=(-29.75+0.5*(pFiberParams->nFiberID-1))*CLHEP::mm;
231 
232  //adjust fiber offset
233  pFiberParams->fOffset=pFiberParams->fcs_cladding.fCentreYPos+fSCY_ODFiberV+fStagger;
234  }
235  break;
236  case EGST_FILE:
237  case EGST_DATABASE:
238  if(eType==EFT_VFIBER){
239  //Geant4: pFiberParams->fAngle=(+90*deg-atan(pFiberParams->fSlope))-(+45*deg);
240  pFiberParams->fcs_cladding.fAngle=(+90*CLHEP::deg-atan(pFiberParams->fSlope))-(+45*CLHEP::deg);
241  pFiberParams->fcs_cladding.fCentreXPos=1.414213562*((fStagger+fSCY-pFiberParams->fOffset)/(pFiberParams->fSlope+1)-fStagger);
242  }
243  if(eType==EFT_UFIBER){
244  //Geant4: pFiberParams->fAngle=(-90*deg-atan(pFiberParams->fSlope))-(-45*deg);
245  pFiberParams->fcs_cladding.fAngle=(-90*CLHEP::deg-atan(pFiberParams->fSlope))-(-45*CLHEP::deg);
246  pFiberParams->fcs_cladding.fCentreXPos=1.414213562*((-fStagger+fSCY-pFiberParams->fOffset)/(pFiberParams->fSlope-1)-fStagger);
247  }
248  if(eType==EFT_ODFIBERV0)
249  {
250  pFiberParams->fcs_cladding.fAngle=atan(pFiberParams->fSlope);
251  pFiberParams->fcs_cladding.fCentreYPos=pFiberParams->fSlope*fSCX_ODFiber00+pFiberParams->fOffset-fSCY_ODFiberV-fStagger;
252  }
253  if(eType==EFT_ODFIBERV1)
254  {
255  pFiberParams->fcs_cladding.fAngle=(-1)*atan(pFiberParams->fSlope);
256  pFiberParams->fcs_cladding.fCentreYPos=pFiberParams->fSlope*fSCX_ODFiber01+pFiberParams->fOffset-fSCY_ODFiberV-fStagger;
257  }
258  if(eType==EFT_ODFIBERU0)
259  {
260  pFiberParams->fcs_cladding.fAngle=atan(pFiberParams->fSlope);
261  pFiberParams->fcs_cladding.fCentreYPos=pFiberParams->fSlope*fSCX_ODFiber00+pFiberParams->fOffset-fSCY_ODFiberU-fStagger;
262  }
263  if(eType==EFT_ODFIBERU1)
264  {
265  pFiberParams->fcs_cladding.fAngle=(-1)*atan(pFiberParams->fSlope);
266  pFiberParams->fcs_cladding.fCentreYPos=pFiberParams->fSlope*fSCX_ODFiber01+pFiberParams->fOffset-fSCY_ODFiberU-fStagger;
267  }
268  break;
269  default:
270  break;
271  }
272 }

◆ UpdateGeometry()

void ALFA_GeometryReader::UpdateGeometry ( )
private

Definition at line 1890 of file ALFA_GeometryReader.cxx.

1891 {
1892  int i;
1893  std::map<eRPotName,ROMAPOT>::iterator rpiter;
1894  std::list<FIBERPARAMS>::const_iterator iter;
1895  FIBERPARAMS Fiber01Params,Fiber64Params;
1896 
1897  for(rpiter=m_MapRPot.begin();rpiter!=m_MapRPot.end();++rpiter){
1898  for(i=1;i<=10;i++){
1899  GetUFiberParams(&Fiber01Params,(*rpiter).first,i,1);
1900  GetUFiberParams(&Fiber64Params,(*rpiter).first,i,64);
1901  (*rpiter).second.MapPlates[i].fUCladdingSizeX=2.0*(fmax(fabs(Fiber01Params.fcs_cladding.fCentreXPos),fabs(Fiber64Params.fcs_cladding.fCentreXPos))+0.24);
1902 
1903  GetVFiberParams(&Fiber01Params,(*rpiter).first,i,1);
1904  GetVFiberParams(&Fiber64Params,(*rpiter).first,i,64);
1905  (*rpiter).second.MapPlates[i].fVCladdingSizeX=2.0*(fmax(fabs(Fiber01Params.fcs_cladding.fCentreXPos),fabs(Fiber64Params.fcs_cladding.fCentreXPos))+0.24);
1906  }
1907  }
1908 }

◆ UpdateSimRPPos()

void ALFA_GeometryReader::UpdateSimRPPos ( const eRPotName  eRPName)
private

Definition at line 798 of file ALFA_GeometryReader.cxx.

799 {
800  int i, nCnt;
801  HepGeom::Transform3D CorrTransform;
802  HepGeom::Scale3D AuxScale;
803  RPPOSPARAMS& Params=m_RPPosParams[eRPName];
804 
805  //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_GeometryReader::UpdateSimRPPos");
806 
807  //correct position of the RP in the station due to metrology data -------------------------------------------------------------------
808  nCnt=Params.VecIdealRPRefPoints.size();
809  HepGeom::Transform3D IdealTransform=Params.RPIdealTransformInStation;
810  if(m_eMetrologyType==EMT_METROLOGY) CorrTransform=ComputeTransformMatrix(Params.VecIdealRPRefPoints,Params.VecRealRPRefPoints, nCnt, AuxScale,true);
811  else CorrTransform=HepGeom::Transform3D();
812 
813  //----------------------------------------------
814  //double fRotZ=atan2(CorrTransform.yx(),CorrTransform.xx());
815  //HepGeom::Transform3D auxTransform=HepGeom::Transform3D(HepRotationZ(fRotZ),CorrTransform.getTranslation());
816  //CorrTransform=auxTransform;
817  //----------------------------------------------
818 
819  //note: SW Corrections are set either via EMT_SWCORRECTIONS flag or by user with EMT_NOMINAL flag
820  m_RPPosParams[eRPName].RPTransformInStation=m_ASPosParams[Params.eASName].ASTransformInMainPoint*CorrTransform*Params.RPSWTransformInStation*IdealTransform;
821  m_RPPosParams[eRPName].RPScaleInStation=AuxScale;
822 
823  m_RPPosParams[eRPName].RefPins.RealRPPin1=CorrTransform*Params.RPSWTransformInStation*m_RPPosParams[eRPName].RefPins.IdealRPPin1;
824  m_RPPosParams[eRPName].RefPins.RealRPPin2=CorrTransform*Params.RPSWTransformInStation*m_RPPosParams[eRPName].RefPins.IdealRPPin2;
825  m_RPPosParams[eRPName].RefPins.RealRPPin3=CorrTransform*Params.RPSWTransformInStation*m_RPPosParams[eRPName].RefPins.IdealRPPin3;
826 
827  HepGeom::Vector3D<double> NominalDetNormal=HepGeom::Vector3D<double>(0.0,0.0,1.0);
828  m_RPPosParams[eRPName].DetectorNormal=m_RPPosParams[eRPName].RPTransformInStation*NominalDetNormal;
829 
830  //----------------------------------------------
831  //important - false for left side, use true for right side (swapped PS points)
832  //double alphaid, alphare;
833  //double alpha=1000.0*atan((m_RPPosParams[eRPName].RefPins.RealRPPin3.y()-m_RPPosParams[eRPName].RefPins.RealRPPin1.y())/(m_RPPosParams[eRPName].RefPins.RealRPPin3.x()-m_RPPosParams[eRPName].RefPins.RealRPPin1.x()));
834  // bool bCond=(eRPName==ERPN_B7L1U || eRPName==ERPN_B7L1L || eRPName==ERPN_A7L1U || eRPName==ERPN_A7L1L)? false:true;
835  // if(Params.bIsLow==bCond){
836  // alphaid=1000.0*atan((Params.VecIdealRPRefPoints[2].y()-Params.VecIdealRPRefPoints[0].y())/(Params.VecIdealRPRefPoints[2].x()-Params.VecIdealRPRefPoints[0].x()));
837  // alphare=1000.0*atan((Params.VecRealRPRefPoints[2].y()-Params.VecRealRPRefPoints[0].y())/(Params.VecRealRPRefPoints[2].x()-Params.VecRealRPRefPoints[0].x()));
838  // }
839  // else{
840  // alphaid=1000.0*atan((Params.VecIdealRPRefPoints[2].y()-Params.VecIdealRPRefPoints[1].y())/(Params.VecIdealRPRefPoints[2].x()-Params.VecIdealRPRefPoints[1].x()));
841  // alphare=1000.0*atan((Params.VecRealRPRefPoints[2].y()-Params.VecRealRPRefPoints[1].y())/(Params.VecRealRPRefPoints[2].x()-Params.VecRealRPRefPoints[1].x()));
842  // }
843  //----------------------------------------------
844 
845  //correct position of the RP's detector in the RP due to metrology data --------------------------------------------------------------
846  IdealTransform=Params.DetIdealTransformInMainPoint;
847 
848  HepGeom::Point3D<double> RPPin1,MainPoint; //point relative to the station
849  //MainPoint=HepGeom::RotateX3D(Params.bIsLow? -180.0*CLHEP::deg:0.0*CLHEP::deg)*m_RPPosParams[eRPName].RPTransformInStation*IdealTransform*HepGeom::Point3D<double>(0.0,0.0,0.0);
850  //RPPin1=HepGeom::Point3D<double>(77.5,+172.2,-124.0); //actually origin of Pot CS
851  // HepGeom::Vector3D<double> CoordShift=RPPin1-MainPoint;
852  RPPin1=ms_NominalRPPin1;
853  MainPoint=ms_NominalRPMainPoint;
854 
855  if(m_eMetrologyType==EMT_METROLOGY){
856  nCnt=Params.VecIdealDetRefPoints.size();
857  std::vector<HepGeom::Point3D<double> > VecIdealDetRefPoints(nCnt);
858  std::vector<HepGeom::Point3D<double> > VecRealDetRefPoints(nCnt);
859 
860  for(i=0;i<(int)Params.VecIdealDetRefPoints.size();i++){
861  VecIdealDetRefPoints[i]=m_RPPosParams[eRPName].VecIdealDetRefPoints[i];//+CoordShift;
862  VecRealDetRefPoints[i]=m_RPPosParams[eRPName].VecRealDetRefPoints[i];//+CoordShift;
863  }
864 
865  CorrTransform=ComputeTransformMatrix(VecIdealDetRefPoints,VecRealDetRefPoints, nCnt, AuxScale);
866  }
867  else{
868  CorrTransform=HepGeom::Transform3D();
869  }
870 
871  //recalculate SW transform in MainPoint
872  HepGeom::Vector3D<double> OriginShift=(RPPin1-MainPoint)+Params.OriginOfDetSWTransform;
873  CLHEP::Hep3Vector TranslationInMainPoint=Params.DetSWTransform.getTranslation()-Params.DetSWTransform*OriginShift+OriginShift;
874  CLHEP::HepRotation RotationInMainPoint=Params.DetSWTransform.getRotation();
875  m_RPPosParams[eRPName].DetSWTransformInMainPoint=HepGeom::Transform3D(RotationInMainPoint,TranslationInMainPoint);
876  //HepGeom::Transform3D AuxTrans=m_RPPosParams[eRPName].DetSWTransformInMainPoint;
877 
878  m_RPPosParams[eRPName].DetTransformInMainPoint=m_RPPosParams[eRPName].DetSWTransformInMainPoint*CorrTransform*IdealTransform;
879  m_RPPosParams[eRPName].RPScaleInStation=AuxScale;
880 
881  m_RPPosParams[eRPName].RefPins.DTPInAtlasCS=GetDetPointInAtlas(eRPName,m_RPPosParams[eRPName].RefPins.DTPInAlfaCS);
882  m_RPPosParams[eRPName].RefPins.DTPInRPotCS=GetDetPointInRPot(eRPName,m_RPPosParams[eRPName].RefPins.DTPInAlfaCS);
883  m_RPPosParams[eRPName].RefPins.DCPInAtlasCS=GetDetPointInAtlas(eRPName,m_RPPosParams[eRPName].RefPins.DCPInAlfaCS);
884  m_RPPosParams[eRPName].RefPins.DCPInRPotCS=GetDetPointInRPot(eRPName,m_RPPosParams[eRPName].RefPins.DCPInAlfaCS);
885 }

◆ UpdateStationsPosParams()

void ALFA_GeometryReader::UpdateStationsPosParams ( )
private

Definition at line 767 of file ALFA_GeometryReader.cxx.

768 {
769  ASPOSPARAMS Params;
770  eAStationName eASName;
771  HepGeom::Vector3D<double> MeanShift;
772 
773  //EASN_B7L1
774  eASName=EASN_B7L1;
775  GetASPosParams(&Params,eASName);
776  MeanShift=0.5*(Params.ShiftE+Params.ShiftS);
777  m_ASPosParams[eASName].ASTransformInMainPoint=HepGeom::Translate3D(MeanShift);
778 
779  //EASN_A7L1
780  eASName=EASN_A7L1;
781  GetASPosParams(&Params,eASName);
782  MeanShift=0.5*(Params.ShiftE+Params.ShiftS);
783  m_ASPosParams[eASName].ASTransformInMainPoint=HepGeom::Translate3D(MeanShift);
784 
785  //EASN_A7R1
786  eASName=EASN_A7R1;
787  GetASPosParams(&Params,eASName);
788  MeanShift=0.5*(Params.ShiftE+Params.ShiftS);
789  m_ASPosParams[eASName].ASTransformInMainPoint=HepGeom::Translate3D(MeanShift);
790 
791  //EASN_B7R1
792  eASName=EASN_B7R1;
793  GetASPosParams(&Params,eASName);
794  MeanShift=0.5*(Params.ShiftE+Params.ShiftS);
795  m_ASPosParams[eASName].ASTransformInMainPoint=HepGeom::Translate3D(MeanShift);
796 }

Member Data Documentation

◆ m_ASPosParams

std::map<eAStationName,ASPOSPARAMS> ALFA_GeometryReader::m_ASPosParams

Definition at line 230 of file ALFA_GeometryReader.h.

◆ m_ConfigOpts

GEOMETRYCONFIGURATION ALFA_GeometryReader::m_ConfigOpts
private

Definition at line 225 of file ALFA_GeometryReader.h.

◆ m_eFCoordSystem

eFiberCoordSystem ALFA_GeometryReader::m_eFCoordSystem
private

Definition at line 224 of file ALFA_GeometryReader.h.

◆ m_eMetrologyType

eMetrologyType ALFA_GeometryReader::m_eMetrologyType
private

Definition at line 226 of file ALFA_GeometryReader.h.

◆ m_ListExistingRPots

std::list<eRPotName> ALFA_GeometryReader::m_ListExistingRPots
private

Definition at line 234 of file ALFA_GeometryReader.h.

◆ m_MapRPot

std::map<eRPotName,ROMAPOT> ALFA_GeometryReader::m_MapRPot
private

Definition at line 233 of file ALFA_GeometryReader.h.

◆ m_RPPosParams

std::map<eRPotName,RPPOSPARAMS> ALFA_GeometryReader::m_RPPosParams

Definition at line 229 of file ALFA_GeometryReader.h.

◆ ms_NominalAlfaRefPoint

const HepGeom::Point3D< double > ALFA_GeometryReader::ms_NominalAlfaRefPoint =HepGeom::Point3D<double>(-77.5*CLHEP::mm,-35.2*CLHEP::mm,114.0*CLHEP::mm)
static

Definition at line 220 of file ALFA_GeometryReader.h.

◆ ms_NominalDetPin1

const HepGeom::Point3D< double > ALFA_GeometryReader::ms_NominalDetPin1 =HepGeom::Point3D<double>(-77.5*CLHEP::mm,-35.0*CLHEP::mm,114.0*CLHEP::mm)
static

Definition at line 221 of file ALFA_GeometryReader.h.

◆ ms_NominalRPMainPoint

const HepGeom::Point3D< double > ALFA_GeometryReader::ms_NominalRPMainPoint =HepGeom::Point3D<double>(0.0*CLHEP::mm,31.525*CLHEP::mm,8.0*CLHEP::mm)
static

Definition at line 219 of file ALFA_GeometryReader.h.

◆ ms_NominalRPPin1

const HepGeom::Point3D< double > ALFA_GeometryReader::ms_NominalRPPin1 =HepGeom::Point3D<double>(+77.5*CLHEP::mm,+172.2*CLHEP::mm,-124.0*CLHEP::mm)
static

Definition at line 218 of file ALFA_GeometryReader.h.

The documentation for this class was generated from the following files:
GEOMETRYCONFIGURATION::fNominalZPosB7R1
double fNominalZPosB7R1
Definition: ALFA_GeometryReader.h:205
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
ERPT_IDEAL
@ ERPT_IDEAL
Definition: ALFA_GeometryReader.h:31
ALFA_GeometryReader::TransformFiberPositions
void TransformFiberPositions(PFIBERPARAMS pFiberParams, eRPotName eRPName, const eFiberType eType, const eGeoSourceType eSourceType)
Definition: ALFA_GeometryReader.cxx:120
CFGRPPOSPARAMS::fYOffset
double fYOffset
Definition: ALFA_GeometryReader.h:183
eFiberType
eFiberType
Definition: ALFA_GeometryReader.h:26
RPPINS::DTPInAlfaCS
HepGeom::Point3D< double > DTPInAlfaCS
Definition: ALFA_GeometryReader.h:43
RPPOSPARAMS
Definition: ALFA_GeometryReader.h:50
ALFA_GeometryReader::ReadFile
bool ReadFile(const eRPotName eRPName, const eFiberType eFType, const char *szFilename)
Definition: ALFA_GeometryReader.cxx:1175
RPPOSPARAMS::IdealMainPointInStation
HepGeom::Point3D< double > IdealMainPointInStation
Definition: ALFA_GeometryReader.h:53
FIBERPARAMS::nLayerID
int nLayerID
Definition: ALFA_GeometryReader.h:102
PathResolver::RecursiveSearch
@ RecursiveSearch
Definition: PathResolver.h:28
ALFA_ConfigParams::Init
int Init(const char *szFile, const char *szSection)
Definition: ALFA_ConfigParams.cxx:36
METROLOGYFILE
#define METROLOGYFILE
Definition: ALFA_constants.h:36
python.Constants.FATAL
int FATAL
Definition: Control/AthenaCommon/python/Constants.py:19
IDTPM::R
float R(const U &p)
Definition: TrackParametersHelper.h:101
dsvd
int dsvd(double **a, int m, int n, double *w, double **v)
Definition: ALFA_SvdCalc.cxx:38
ALFA_ConfigParams::GetParameter
const char * GetParameter(const char *szKey) const
Definition: ALFA_ConfigParams.cxx:82
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
Definition: PathResolver.cxx:251
EFT_ODFIBERV0
@ EFT_ODFIBERV0
Definition: ALFA_GeometryReader.h:26
ODLAYERSCNT
#define ODLAYERSCNT
Definition: ALFA_CLinkAlg.h:30
ROMAPOT::ListODFibersU1
std::list< FIBERPARAMS > ListODFibersU1
Definition: ALFA_GeometryReader.h:153
RPPOSPARAMS::IdealMainPoint
HepGeom::Point3D< double > IdealMainPoint
Definition: ALFA_GeometryReader.h:52
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
FIBERPARAMS::fOriginY
double fOriginY
Definition: ALFA_GeometryReader.h:119
ROMAPOT::ListVFibers
std::list< FIBERPARAMS > ListVFibers
Definition: ALFA_GeometryReader.h:150
ASPOSPARAMS::clear
void clear()
Definition: ALFA_GeometryReader.cxx:35
FIBERPARAMS::fcs_atlas_full
struct FIBERPARAMS::@49 fcs_atlas_full
CFGRPPOSPARAMS::swcorr
struct CFGRPPOSPARAMS::@52 swcorr
EGST_IDEALGEOMETRY
@ EGST_IDEALGEOMETRY
Definition: ALFA_GeometryReader.h:24
JetTiledMap::W
@ W
Definition: TiledEtaPhiMap.h:44
RPPINS::IdealRPPin3
HepGeom::Point3D< double > IdealRPPin3
Definition: ALFA_GeometryReader.h:40
RPPINS::DCPInAlfaCS
HepGeom::Point3D< double > DCPInAlfaCS
Definition: ALFA_GeometryReader.h:44
EMCS_STATION
@ EMCS_STATION
Definition: ALFA_GeometryReader.h:32
ALFA_GeometryReader::SetupCurrentLVDT
void SetupCurrentLVDT(const PGEOMETRYCONFIGURATION pConfig)
Definition: ALFA_GeometryReader.cxx:3049
ALFA_RDBAccess::ReadGeometry
bool ReadGeometry(const eRPotName eRPName, eFiberType eFType, const std::string &element, const std::string &tag, const std::string &node)
Definition: ALFA_RDBAccess.cxx:19
ERPN_B7R1U
@ ERPN_B7R1U
Definition: ALFA_GeometryReader.h:28
ALFA_GeometryReader::SetupUserCorrections
void SetupUserCorrections(const PGEOMETRYCONFIGURATION pConfig)
Definition: ALFA_GeometryReader.cxx:3078
ALFA_GeometryReader::ReadDatabase
bool ReadDatabase(const eRPotName eRPName, const eFiberType eFType, const char *szDataSource)
Definition: ALFA_GeometryReader.cxx:1323
FIBERPARAMS::fOffset
double fOffset
Definition: ALFA_GeometryReader.h:114
FIBERPARAMS::fZPos
double fZPos
Definition: ALFA_GeometryReader.h:115
ALFA_ConfigParams
Definition: ALFA_ConfigParams.h:21
INACTIVEDETEGDEDISTANCE
#define INACTIVEDETEGDEDISTANCE
Definition: ALFA_constants.h:32
ALFA_GeometryReader::SetIdealGeometry
bool SetIdealGeometry(const eRPotName eRPName, const eFiberType eFType)
Definition: ALFA_GeometryReader.cxx:1089
ALFAFIBERSCNT
#define ALFAFIBERSCNT
Definition: ALFA_constants.h:10
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
eRPotName
eRPotName
Definition: ALFA_GeometryReader.h:28
DMTest::C
C_v1 C
Definition: C.h:26
EMT_SWCORRECTIONS
@ EMT_SWCORRECTIONS
Definition: ALFA_GeometryReader.h:25
ALFA_GeometryReader::m_eFCoordSystem
eFiberCoordSystem m_eFCoordSystem
Definition: ALFA_GeometryReader.h:224
RPPOSPARAMS::IdealRefPoint
HepGeom::Point3D< double > IdealRefPoint
Definition: ALFA_GeometryReader.h:54
ALFA_GeometryReader::TransformFiberPositionsFCSAtlas
void TransformFiberPositionsFCSAtlas(PFIBERPARAMS pFiberParams, eRPotName eRPName, const eFiberType eType, const eGeoSourceType eSourceType)
Definition: ALFA_GeometryReader.cxx:274
ALFA_GeometryReader::GetRPotLabel
const char * GetRPotLabel(const eRPotName eRPName)
Definition: ALFA_GeometryReader.h:279
FIBERPARAMS::fAngle
double fAngle
Definition: ALFA_GeometryReader.h:109
ERPN_A7L1U
@ ERPN_A7L1U
Definition: ALFA_GeometryReader.h:28
ROMAPOT::ListODFibersU0
std::list< FIBERPARAMS > ListODFibersU0
Definition: ALFA_GeometryReader.h:151
ALFA_GeometryReader::GetVFiberParams
bool GetVFiberParams(PFIBERPARAMS pFiberParams, const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1443
ASPOSPARAMS::IdealMainPoint
HepGeom::Point3D< double > IdealMainPoint
Definition: ALFA_GeometryReader.h:86
RPOTSCNT
#define RPOTSCNT
Definition: ALFA_CLinkAlg.h:26
FIBERPARAMS::fOriginX
double fOriginX
Definition: ALFA_GeometryReader.h:119
ASPOSPARAMS::ASTransformInATLAS
HepGeom::Transform3D ASTransformInATLAS
Definition: ALFA_GeometryReader.h:93
deg
#define deg
Definition: SbPolyhedron.cxx:17
RPPOSPARAMS::RefPins
RPPINS RefPins
Definition: ALFA_GeometryReader.h:57
FIBERPARAMS::fCentreYPos
double fCentreYPos
Definition: ALFA_GeometryReader.h:107
ERPN_B7R1L
@ ERPN_B7R1L
Definition: ALFA_GeometryReader.h:28
RunActsMaterialMapping.FilePath
FilePath
Definition: RunActsMaterialMapping.py:99
CFGRPPOSPARAMS::fTheta
double fTheta
Definition: ALFA_GeometryReader.h:185
EASN_A7R1
@ EASN_A7R1
Definition: ALFA_GeometryReader.h:27
RPPOSPARAMS::eASName
eAStationName eASName
Definition: ALFA_GeometryReader.h:56
ALFA_GeometryReader::GetDetPointInRPot
HepGeom::Point3D< double > GetDetPointInRPot(eRPotName eRPName, const HepGeom::Point3D< double > &PointInDetCS)
Definition: ALFA_GeometryReader.cxx:2904
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
RPPOSPARAMS::VecRealRPRefPoints
std::vector< HepGeom::Point3D< double > > VecRealRPRefPoints
Definition: ALFA_GeometryReader.h:63
GEOMETRYCONFIGURATION::fNominalZPosB7L1
double fNominalZPosB7L1
Definition: ALFA_GeometryReader.h:203
ALFA_GeometryReader::ParseRefPoints
bool ParseRefPoints(const char *szvalue, std::vector< HepGeom::Point3D< double > > &vecRefPoints, eMetrologyCoordSystem eCSystem)
Definition: ALFA_GeometryReader.cxx:2515
CFGRPPOSPARAMS::fXOffset
double fXOffset
Definition: ALFA_GeometryReader.h:184
ERPT_REAL
@ ERPT_REAL
Definition: ALFA_GeometryReader.h:31
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
RPPOSPARAMS::DetTransformInMainPoint
HepGeom::Transform3D DetTransformInMainPoint
Definition: ALFA_GeometryReader.h:77
RPPOSPARAMS::VecIdealRPRefPoints
std::vector< HepGeom::Point3D< double > > VecIdealRPRefPoints
Definition: ALFA_GeometryReader.h:62
EFCS_CLADDING
@ EFCS_CLADDING
Definition: ALFA_GeometryReader.h:30
EFT_FIBERMD
@ EFT_FIBERMD
Definition: ALFA_GeometryReader.h:26
FIBERPARAMS::fcs_atlas
struct FIBERPARAMS::@48 fcs_atlas
ALFA_ConfigParams::IsKey
bool IsKey(const char *szKey) const
Definition: ALFA_ConfigParams.cxx:98
RPPOSPARAMS::szLabel
char szLabel[8]
Definition: ALFA_GeometryReader.h:51
x
#define x
CFGRPPOSPARAMS::usercorr
struct CFGRPPOSPARAMS::@53 usercorr
FIBERPARAMS
Definition: ALFA_GeometryReader.h:99
ETE_T3
@ ETE_T3
Definition: ALFA_GeometryReader.h:33
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
ETE_A1
@ ETE_A1
Definition: ALFA_GeometryReader.h:33
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
ROMAPOT
Definition: ALFA_GeometryReader.h:140
EMT_NOMINAL
@ EMT_NOMINAL
Definition: ALFA_GeometryReader.h:25
eAStationName
eAStationName
Definition: ALFA_GeometryReader.h:27
CFGRPPOSPARAMS::strODConnString
std::string strODConnString
Definition: ALFA_GeometryReader.h:179
ALFA_GeometryReader::GetASPosParams
bool GetASPosParams(PASPOSPARAMS pRPosParams, const eAStationName eASName)
Definition: ALFA_GeometryReader.cxx:1949
CFGRPPOSPARAMS::strMDConnString
std::string strMDConnString
Definition: ALFA_GeometryReader.h:178
ASPOSPARAMS
Definition: ALFA_GeometryReader.h:84
CFGRPPOSPARAMS::fCurrentLVDTmm
double fCurrentLVDTmm
Definition: ALFA_GeometryReader.h:181
EMT_METROLOGY
@ EMT_METROLOGY
Definition: ALFA_GeometryReader.h:25
CFGRPPOSPARAMS::UserTransformOfDetInRPot
HepGeom::Transform3D UserTransformOfDetInRPot
Definition: ALFA_GeometryReader.h:191
FIBERPARAMS::fMainRefPointSlope
double fMainRefPointSlope
Definition: ALFA_GeometryReader.h:127
ALFA_GeometryReader::m_ASPosParams
std::map< eAStationName, ASPOSPARAMS > m_ASPosParams
Definition: ALFA_GeometryReader.h:230
ALFA_GeometryReader::PrintFiberGeometry
void PrintFiberGeometry(std::ostream &OutStream)
Definition: ALFA_GeometryReader.cxx:1641
FIBERPARAMS::fOriginZ
double fOriginZ
Definition: ALFA_GeometryReader.h:119
ALFA_RDBAccess::m_ListFiberData
std::list< FIBERDATA > m_ListFiberData
Definition: ALFA_RDBAccess.h:60
ALFA_GeometryReader::m_eMetrologyType
eMetrologyType m_eMetrologyType
Definition: ALFA_GeometryReader.h:226
ETE_A2
@ ETE_A2
Definition: ALFA_GeometryReader.h:33
CFGRPPOSPARAMS::bIsEnabledUserTranform
bool bIsEnabledUserTranform
Definition: ALFA_GeometryReader.h:189
RPPOSPARAMS::VecIdealDetRefPoints
std::vector< HepGeom::Point3D< double > > VecIdealDetRefPoints
Definition: ALFA_GeometryReader.h:70
ALFA_GeometryReader::m_RPPosParams
std::map< eRPotName, RPPOSPARAMS > m_RPPosParams
Definition: ALFA_GeometryReader.h:229
eMetrologyType
eMetrologyType
Definition: ALFA_GeometryReader.h:25
EASN_B7L1
@ EASN_B7L1
Definition: ALFA_GeometryReader.h:27
ROMAPOT::ListUFibers
std::list< FIBERPARAMS > ListUFibers
Definition: ALFA_GeometryReader.h:149
ALFA_GeometryReader::ReadSource
bool ReadSource(const eGeoSourceType eSourceType, const eRPotName eRPName, const eFiberType eFType, const char *szDataSource)
Definition: ALFA_GeometryReader.cxx:1032
RPPINS::DCPInAtlasCS
HepGeom::Point3D< double > DCPInAtlasCS
Definition: ALFA_GeometryReader.h:44
RPPOSPARAMS::RPSWTransformInStation
HepGeom::Transform3D RPSWTransformInStation
Definition: ALFA_GeometryReader.h:65
ERPPT_ACTIVE
@ ERPPT_ACTIVE
Definition: ALFA_GeometryReader.h:29
RPPOSPARAMS::DetSWTransformInMainPoint
HepGeom::Transform3D DetSWTransformInMainPoint
Definition: ALFA_GeometryReader.h:73
DETEDGEDISTANCE
#define DETEDGEDISTANCE
Definition: ALFA_constants.h:31
ERPN_B7L1U
@ ERPN_B7L1U
Definition: ALFA_GeometryReader.h:28
lumiFormat.i
int i
Definition: lumiFormat.py:92
ERPN_UNDEFINED
@ ERPN_UNDEFINED
Definition: ALFA_GeometryReader.h:28
ALFA_GeometryReader::ms_NominalDetPin1
static const HepGeom::Point3D< double > ms_NominalDetPin1
Definition: ALFA_GeometryReader.h:221
z
#define z
ALFA_GeometryReader::SetupSWCorrections
void SetupSWCorrections(const PGEOMETRYCONFIGURATION pConfig)
Definition: ALFA_GeometryReader.cxx:3061
ASPOSPARAMS::ShiftE
HepGeom::Vector3D< double > ShiftE
Definition: ALFA_GeometryReader.h:90
RPPOSPARAMS::RPTransformInStation
HepGeom::Transform3D RPTransformInStation
Definition: ALFA_GeometryReader.h:66
beamspotman.n
n
Definition: beamspotman.py:731
ASPOSPARAMS::ShiftS
HepGeom::Vector3D< double > ShiftS
Definition: ALFA_GeometryReader.h:91
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EFT_ODFIBERU1
@ EFT_ODFIBERU1
Definition: ALFA_GeometryReader.h:26
EGST_UNDEFINED
@ EGST_UNDEFINED
Definition: ALFA_GeometryReader.h:24
EFT_VFIBER
@ EFT_VFIBER
Definition: ALFA_GeometryReader.h:26
ALFA_GeometryReader::SetupStationMetrologyPoints
bool SetupStationMetrologyPoints(ALFA_ConfigParams &CfgParams, eAStationName eASName)
Definition: ALFA_GeometryReader.cxx:2827
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
FIBERPARAMS::fDirX
double fDirX
Definition: ALFA_GeometryReader.h:120
FIBERPARAMS::fcs_cladding
struct FIBERPARAMS::@47 fcs_cladding
RPPOSPARAMS::DetIdealTransformInMainPoint
HepGeom::Transform3D DetIdealTransformInMainPoint
Definition: ALFA_GeometryReader.h:72
ALFA_GeometryReader::ms_NominalAlfaRefPoint
static const HepGeom::Point3D< double > ms_NominalAlfaRefPoint
Definition: ALFA_GeometryReader.h:220
ERPN_B7L1L
@ ERPN_B7L1L
Definition: ALFA_GeometryReader.h:28
RPPINS::IdealRPPin1
HepGeom::Point3D< double > IdealRPPin1
Definition: ALFA_GeometryReader.h:38
RPPOSPARAMS::clear
void clear()
Definition: ALFA_GeometryReader.cxx:45
RPPOSPARAMS::RPIdealTransformInStation
HepGeom::Transform3D RPIdealTransformInStation
Definition: ALFA_GeometryReader.h:64
FIBERPARAMS::fDirZ
double fDirZ
Definition: ALFA_GeometryReader.h:120
GEOMETRYCONFIGURATION::CfgRPosParams
CFGRPPOSPARAMS CfgRPosParams[RPOTSCNT]
Definition: ALFA_GeometryReader.h:206
ASPOSPARAMS::szLabel
char szLabel[8]
Definition: ALFA_GeometryReader.h:85
FIBERPARAMS::MainRefPointPos
HepGeom::Point3D< float > MainRefPointPos
Definition: ALFA_GeometryReader.h:128
Scale
void Scale(TH1 *h, double d=1)
Definition: comparitor.cxx:76
ALFALAYERSCNT
#define ALFALAYERSCNT
Definition: ALFA_constants.h:8
FIBERPARAMS::nPlateID
int nPlateID
Definition: ALFA_GeometryReader.h:100
CxxUtils::atof
double atof(std::string_view str)
Converts a string into a double / float.
Definition: Control/CxxUtils/Root/StringUtils.cxx:91
EFT_UFIBER
@ EFT_UFIBER
Definition: ALFA_GeometryReader.h:26
ALFA_GeometryReader::GetRPPosParams
bool GetRPPosParams(PRPPOSPARAMS pRPosParams, const eRPotName eRPName)
Definition: ALFA_GeometryReader.cxx:1930
ALFA_GeometryReader::m_ListExistingRPots
std::list< eRPotName > m_ListExistingRPots
Definition: ALFA_GeometryReader.h:234
ERPN_A7R1L
@ ERPN_A7R1L
Definition: ALFA_GeometryReader.h:28
FIBERPARAMS::fCentreXPos
double fCentreXPos
Definition: ALFA_GeometryReader.h:106
GEOMETRYCONFIGURATION::eRPMetrologyGeoType
int eRPMetrologyGeoType
Definition: ALFA_GeometryReader.h:198
FIBERPARAMS::nFiberID
int nFiberID
Definition: ALFA_GeometryReader.h:101
EFT_UNDEFINED
@ EFT_UNDEFINED
Definition: ALFA_GeometryReader.h:26
ALFA_GeometryReader::GetDetPointInAtlas
HepGeom::Point3D< double > GetDetPointInAtlas(eRPotName eRPName, const HepGeom::Point3D< double > &PointInDetCS)
Definition: ALFA_GeometryReader.cxx:2859
EGST_DATABASE
@ EGST_DATABASE
Definition: ALFA_GeometryReader.h:24
ALFA_GeometryReader::ms_NominalRPPin1
static const HepGeom::Point3D< double > ms_NominalRPPin1
Definition: ALFA_GeometryReader.h:218
ROMAPOT::ListODFibersV1
std::list< FIBERPARAMS > ListODFibersV1
Definition: ALFA_GeometryReader.h:154
RPPOSPARAMS::fCurrentLVDTmm
double fCurrentLVDTmm
Definition: ALFA_GeometryReader.h:58
ROMAPOT::ListODFibersV0
std::list< FIBERPARAMS > ListODFibersV0
Definition: ALFA_GeometryReader.h:152
ALFA_GeometryReader::GetODFiberParams
bool GetODFiberParams(PFIBERPARAMS pFiberParams, const eFiberType eFType, const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:2017
ALFA_GeometryReader::ms_NominalRPMainPoint
static const HepGeom::Point3D< double > ms_NominalRPMainPoint
Definition: ALFA_GeometryReader.h:219
RPPOSPARAMS::OriginOfDetSWTransform
HepGeom::Point3D< double > OriginOfDetSWTransform
Definition: ALFA_GeometryReader.h:76
GEOMETRYCONFIGURATION::fNominalZPosA7L1
double fNominalZPosA7L1
Definition: ALFA_GeometryReader.h:202
EASN_A7L1
@ EASN_A7L1
Definition: ALFA_GeometryReader.h:27
CFGRPPOSPARAMS::UserOriginOfDetTransInRPot
HepGeom::Point3D< double > UserOriginOfDetTransInRPot
Definition: ALFA_GeometryReader.h:190
EMCS_ROMANPOT
@ EMCS_ROMANPOT
Definition: ALFA_GeometryReader.h:32
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
CFGRPPOSPARAMS::eODGeoType
int eODGeoType
Definition: ALFA_GeometryReader.h:177
ERPN_A7R1U
@ ERPN_A7R1U
Definition: ALFA_GeometryReader.h:28
ODPLATESCNT
#define ODPLATESCNT
Definition: ALFA_CLinkAlg.h:31
ALFA_GeometryReader::GetUFiberParams
bool GetUFiberParams(PFIBERPARAMS pFiberParams, const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1414
y
#define y
lumiFormat.fill
fill
Definition: lumiFormat.py:111
EFCS_ATLAS
@ EFCS_ATLAS
Definition: ALFA_GeometryReader.h:30
ODFIBERSCNT
#define ODFIBERSCNT
Definition: ALFA_CLinkAlg.h:32
CFGRPPOSPARAMS::eRPPosType
int eRPPosType
Definition: ALFA_GeometryReader.h:175
ALFA_GeometryReader::ParseRPMetrology
bool ParseRPMetrology(eGeoSourceType eSourceType, const char *szDataSource)
Definition: ALFA_GeometryReader.cxx:2422
ALFA_GeometryReader::m_MapRPot
std::map< eRPotName, ROMAPOT > m_MapRPot
Definition: ALFA_GeometryReader.h:233
ALFA_GeometryReader::ReadFiberGeometry
bool ReadFiberGeometry(const PGEOMETRYCONFIGURATION pConfig)
Definition: ALFA_GeometryReader.cxx:1004
GEOMETRYCONFIGURATION::bShiftToX97Pos
bool bShiftToX97Pos
Definition: ALFA_GeometryReader.h:200
ERPT_DETIDEAL
@ ERPT_DETIDEAL
Definition: ALFA_GeometryReader.h:31
FIBERPARAMS::fSlope
double fSlope
Definition: ALFA_GeometryReader.h:113
EFT_ODFIBERU0
@ EFT_ODFIBERU0
Definition: ALFA_GeometryReader.h:26
RPPOSPARAMS::bIsLow
bool bIsLow
Definition: ALFA_GeometryReader.h:55
CFGRPPOSPARAMS::UserTransformOfRPInStation
HepGeom::Transform3D UserTransformOfRPInStation
Definition: ALFA_GeometryReader.h:192
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
ALFA_GeometryReader::InitializeDefault
bool InitializeDefault(const PGEOMETRYCONFIGURATION pConfig)
Definition: ALFA_GeometryReader.cxx:446
RPPOSPARAMS::DetSWTransform
HepGeom::Transform3D DetSWTransform
Definition: ALFA_GeometryReader.h:75
EGST_FILE
@ EGST_FILE
Definition: ALFA_GeometryReader.h:24
FIBERPARAMS::fDirY
double fDirY
Definition: ALFA_GeometryReader.h:120
eGeoSourceType
eGeoSourceType
Definition: ALFA_GeometryReader.h:24
ALFA_GeometryReader::UpdateGeometry
void UpdateGeometry()
Definition: ALFA_GeometryReader.cxx:1890
ALFA_GeometryReader::TransformFiberPositionsFCSCladding
void TransformFiberPositionsFCSCladding(PFIBERPARAMS pFiberParams, eRPotName eRPName, const eFiberType eType, const eGeoSourceType eSourceType)
Definition: ALFA_GeometryReader.cxx:135
EFT_ODFIBERV1
@ EFT_ODFIBERV1
Definition: ALFA_GeometryReader.h:26
AthenaPoolTestStep2WriteDoubleSelector.OutStream
OutStream
Definition: AthenaPoolTestStep2WriteDoubleSelector.py:77
ALFA_RDBAccess
Definition: ALFA_RDBAccess.h:40
GEOMETRYCONFIGURATION::strRPMetrologyConnString
std::string strRPMetrologyConnString
Definition: ALFA_GeometryReader.h:199
ERPN_A7L1L
@ ERPN_A7L1L
Definition: ALFA_GeometryReader.h:28
EFT_FIBEROD
@ EFT_FIBEROD
Definition: ALFA_GeometryReader.h:26
EMT_UNDEFINED
@ EMT_UNDEFINED
Definition: ALFA_GeometryReader.h:25
EMCS_DETPIN1
@ EMCS_DETPIN1
Definition: ALFA_GeometryReader.h:32
Shift
@ Shift
Definition: CMAparameters.h:19
ALFA_GeometryReader::SetupRPMetrologyPoints
bool SetupRPMetrologyPoints(ALFA_ConfigParams &CfgParams, eRPotName eRPName)
Definition: ALFA_GeometryReader.cxx:2726
ALFA_GeometryReader::ComputeTransformMatrix
HepGeom::Transform3D ComputeTransformMatrix(const std::vector< HepGeom::Point3D< double > > &VecIdealRefPoints, const std::vector< HepGeom::Point3D< double > > &VecRealRefPoints, const int nPointCnt, HepGeom::Scale3D &Scale, bool bForceUseSVD=false)
Definition: ALFA_GeometryReader.cxx:887
RPPINS::IdealRPPin2
HepGeom::Point3D< double > IdealRPPin2
Definition: ALFA_GeometryReader.h:39
GEOMETRYCONFIGURATION::fNominalZPosA7R1
double fNominalZPosA7R1
Definition: ALFA_GeometryReader.h:204
EFCS_UNDEFINED
@ EFCS_UNDEFINED
Definition: ALFA_GeometryReader.h:30
CFGRPPOSPARAMS::eMDGeoType
int eMDGeoType
Definition: ALFA_GeometryReader.h:176
ERPT_DETREAL
@ ERPT_DETREAL
Definition: ALFA_GeometryReader.h:31
ALFA_GeometryReader::UpdateStationsPosParams
void UpdateStationsPosParams()
Definition: ALFA_GeometryReader.cxx:767
ALFA_GeometryReader::SetupDetMetrologyPoints
bool SetupDetMetrologyPoints(ALFA_ConfigParams &CfgParams, eRPotName eRPName)
Definition: ALFA_GeometryReader.cxx:2630
ALFAPLATESCNT
#define ALFAPLATESCNT
Definition: ALFA_constants.h:9
ALFA_GeometryReader::GetPolyFitValue
double GetPolyFitValue(const double fInputValue, const std::vector< double > &vecPolyFitParams)
Definition: ALFA_GeometryReader.cxx:2844
ALFA_GeometryReader::UpdateSimRPPos
void UpdateSimRPPos(const eRPotName eRPName)
Definition: ALFA_GeometryReader.cxx:798
EASN_B7R1
@ EASN_B7R1
Definition: ALFA_GeometryReader.h:27
ALFA_GeometryReader::ParseArrayOfValues
bool ParseArrayOfValues(const char *szvalue, std::vector< double > &vecValues)
Definition: ALFA_GeometryReader.cxx:2591
EMCS_ATLAS
@ EMCS_ATLAS
Definition: ALFA_GeometryReader.h:32
ETE_A3
@ ETE_A3
Definition: ALFA_GeometryReader.h:33
ETE_T1
@ ETE_T1
Definition: ALFA_GeometryReader.h:33
PLATEPARAMS
Definition: ALFA_GeometryReader.h:134
ETE_T2
@ ETE_T2
Definition: ALFA_GeometryReader.h:33
Generated on Thu Jul 4 2024 21:37:10 for ATLAS Offline Software by   doxygen 1.8.18