ATLAS Offline Software
ALFA_GeometryReader.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 
6 
7 #include "StoreGate/StoreGateSvc.h"
8 #include "GaudiKernel/MsgStream.h"
9 #include "AthenaKernel/getMessageSvc.h"
10 #include "PathResolver/PathResolver.h"
11 
12 #include <CLHEP/Matrix/Matrix.h>
13 #include <CLHEP/Matrix/Vector.h>
14 
15 #include "ALFA_Geometry/ALFA_GeometryReader.h"
16 #include "ALFA_Geometry/ALFA_RDBAccess.h"
17 #include "ALFA_Geometry/ALFA_SvdCalc.h"
18 
19 #include <cstdlib>
20 #include <cstdio>
21 #include <fstream>
22 #include <algorithm>
23 #include <cmath>
24 
25 void RPPINS::clear()
26 {
27  IdealRPPin1=RealRPPin1=HepGeom::Point3D<double>();
28  IdealRPPin2=RealRPPin2=HepGeom::Point3D<double>();
29  IdealRPPin3=RealRPPin3=HepGeom::Point3D<double>();
30  DTPInAlfaCS=HepGeom::Point3D<double>();
31  DTPInRPotCS=HepGeom::Point3D<double>();
32  DTPInAtlasCS=HepGeom::Point3D<double>();
33 }
34 
35 void ASPOSPARAMS::clear()
36 {
37  memset(szLabel,0,sizeof(szLabel));
38  IdealMainPoint=HepGeom::Point3D<double>();
39  ShiftE=HepGeom::Vector3D<double>();
40  ShiftS=HepGeom::Vector3D<double>();
41  ASTransformInMainPoint=HepGeom::Transform3D();
42  ASTransformInATLAS=HepGeom::Transform3D();
43 }
44 
45 void RPPOSPARAMS::clear()
46 {
47  memset(szLabel,0,sizeof(szLabel));
48  IdealRefPoint=HepGeom::Point3D<double>();
49  IdealMainPoint=HepGeom::Point3D<double>();
50  IdealMainPointInStation=HepGeom::Point3D<double>();
51 
52  VecIdealRPRefPoints.clear();
53  VecRealRPRefPoints.clear();
54  RPIdealTransformInStation=HepGeom::Transform3D();
55  RPSWTransformInStation=HepGeom::Transform3D();
56  RPTransformInStation=HepGeom::Transform3D();
57 
58  VecIdealDetRefPoints.clear();
59  VecRealDetRefPoints.clear();
60  DetIdealTransformInMainPoint=HepGeom::Transform3D();
61  DetSWTransformInMainPoint=HepGeom::Transform3D();
62  DetTransformInMainPoint=HepGeom::Transform3D();
63 
64  bIsLow=false;
65  eASName=EASN_UNDEFINED;
66  fCurrentLVDTmm=0.0;
67  DetectorNormal=HepGeom::Vector3D<double>();
68 
69  RefPins.clear();
70 }
71 
72 void GEOMETRYCONFIGURATION::clear()
73 {
74  eRPMetrologyGeoType=EGST_UNDEFINED;
75  strRPMetrologyConnString=std::string("");
76  bShiftToX97Pos=false;
77 
78  fNominalZPosA7L1=237388*CLHEP::mm;
79  fNominalZPosB7L1=241528*CLHEP::mm;
80  fNominalZPosA7R1=-237408*CLHEP::mm;
81  fNominalZPosB7R1=-241548*CLHEP::mm;
82 
83  for(int i=0;i<RPOTSCNT;i++){
84  CfgRPosParams[i].eRPPosType=ERPPT_UNSET;
85  CfgRPosParams[i].eMDGeoType=EGST_UNDEFINED;
86  CfgRPosParams[i].eODGeoType=EGST_UNDEFINED;
87  CfgRPosParams[i].strMDConnString=std::string("");
88  CfgRPosParams[i].strODConnString=std::string("");
89 
90  CfgRPosParams[i].fCurrentLVDTmm=0.0*CLHEP::mm;
91 
92  CfgRPosParams[i].swcorr.fYOffset=(i%2==0)? 2.0*CLHEP::mm:-2.0*CLHEP::mm;
93  CfgRPosParams[i].swcorr.fXOffset=0.0*CLHEP::mm;
94  CfgRPosParams[i].swcorr.fTheta=0.0*CLHEP::mm;
95 
96  CfgRPosParams[i].usercorr.bIsEnabledUserTranform=false;
97  CfgRPosParams[i].usercorr.UserOriginOfDetTransInRPot=HepGeom::Point3D<double>();
98  CfgRPosParams[i].usercorr.UserTransformOfDetInRPot=HepGeom::Transform3D();
99  CfgRPosParams[i].usercorr.UserTransformOfRPInStation=HepGeom::Transform3D();
100  }
101 }
102 
103 const HepGeom::Point3D<double> ALFA_GeometryReader::ms_NominalRPPin1=HepGeom::Point3D<double>(+77.5*CLHEP::mm,+172.2*CLHEP::mm,-124.0*CLHEP::mm);
104 const HepGeom::Point3D<double> ALFA_GeometryReader::ms_NominalRPMainPoint=HepGeom::Point3D<double>(0.0*CLHEP::mm,31.525*CLHEP::mm,8.0*CLHEP::mm);//31.025
105 const HepGeom::Point3D<double> ALFA_GeometryReader::ms_NominalAlfaRefPoint=HepGeom::Point3D<double>(-77.5*CLHEP::mm,-35.2*CLHEP::mm,114.0*CLHEP::mm);//-35.7
106 const HepGeom::Point3D<double> ALFA_GeometryReader::ms_NominalDetPin1=HepGeom::Point3D<double>(-77.5*CLHEP::mm,-35.0*CLHEP::mm,114.0*CLHEP::mm);
107 
108 ALFA_GeometryReader::ALFA_GeometryReader()
109 {
110  m_eFCoordSystem=EFCS_UNDEFINED;
111  m_eMetrologyType=EMT_UNDEFINED;
112  m_MapRPot.clear();
113 }
114 
115 ALFA_GeometryReader::~ALFA_GeometryReader()
116 {
117  m_MapRPot.clear();
118 }
119 
120 void ALFA_GeometryReader::TransformFiberPositions(PFIBERPARAMS pFiberParams,eRPotName eRPName, const eFiberType eType, const eGeoSourceType eSourceType)
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 }
134 
135 void ALFA_GeometryReader::TransformFiberPositionsFCSCladding(PFIBERPARAMS pFiberParams,eRPotName eRPName, const eFiberType eType, const eGeoSourceType eSourceType)
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 }
273 
274 void ALFA_GeometryReader::TransformFiberPositionsFCSAtlas(PFIBERPARAMS pFiberParams,eRPotName eRPName, const eFiberType eType, const eGeoSourceType eSourceType)
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 }
444 
445 
446 bool ALFA_GeometryReader::InitializeDefault(const PGEOMETRYCONFIGURATION pConfig)
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 }
687 
688 bool ALFA_GeometryReader::Initialize(const PGEOMETRYCONFIGURATION pConfig, eFiberCoordSystem eFCoordSystem)
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 }
766 
767 void ALFA_GeometryReader::UpdateStationsPosParams()
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 }
797 
798 void ALFA_GeometryReader::UpdateSimRPPos(const eRPotName eRPName)
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 }
886 
887 HepGeom::Transform3D ALFA_GeometryReader::ComputeTransformMatrix(const std::vector<HepGeom::Point3D<double> >& VecIdealRefPoints,const std::vector<HepGeom::Point3D<double> >& VecRealRefPoints, const int nPointCnt,
888  HepGeom::Scale3D& Scale, bool bForceUseSVD)
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 }
1003 
1004 bool ALFA_GeometryReader::ReadFiberGeometry(const PGEOMETRYCONFIGURATION pConfig)
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 }
1031 
1032 bool ALFA_GeometryReader::ReadSource(const eGeoSourceType eSourceType, const eRPotName eRPName, const eFiberType eFType, const char* szDataSource)
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 }
1088 
1089 bool ALFA_GeometryReader::SetIdealGeometry(const eRPotName eRPName, const eFiberType eFType)
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 }
1174 
1175 bool ALFA_GeometryReader::ReadFile(const eRPotName eRPName, const eFiberType eFType, const char* szFilename)
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 }
1322 
1323 bool ALFA_GeometryReader::ReadDatabase(const eRPotName eRPName, const eFiberType eFType, const char* szDataSource)
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 }
1413 
1414 bool ALFA_GeometryReader::GetUFiberParams(PFIBERPARAMS pFiberParams, const eRPotName eRPName, const int nPlateID, const int nFiberID)
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 }
1442 
1443 bool ALFA_GeometryReader::GetVFiberParams(PFIBERPARAMS pFiberParams, const eRPotName eRPName, const int nPlateID, const int nFiberID)
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 }
1472 
1473 double ALFA_GeometryReader::GetUFiberCentreXPos(const eRPotName eRPName, const int nPlateID, const int nFiberID)
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 }
1490 
1491 double ALFA_GeometryReader::GetVFiberCentreXPos(const eRPotName eRPName, const int nPlateID, const int nFiberID)
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 }
1508 
1509 double ALFA_GeometryReader::GetUFiberAngle(const eRPotName eRPName, const int nPlateID, const int nFiberID)
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 }
1526 
1527 double ALFA_GeometryReader::GetVFiberAngle(const eRPotName eRPName, const int nPlateID, const int nFiberID)
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 }
1544 
1545 void ALFA_GeometryReader::SetUFiberPositionToMainReference(const eRPotName eRPName, const int nPlateID, const int nFiberID, const HepGeom::Point3D<float>& TransPoint,const double fTransSlope)
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 }
1576 
1577 void ALFA_GeometryReader::SetVFiberPositionToMainReference(const eRPotName eRPName, const int nPlateID, const int nFiberID, const HepGeom::Point3D<float>& TransPoint,const double fTransSlope)
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 }
1608 
1609 bool ALFA_GeometryReader::GetPlateParams(PPLATEPARAMS pPlateParams, const eRPotName eRPName, const int nPlateID)
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 }
1632 
1633 
1634 void ALFA_GeometryReader::PrintFiberGeometry(const char* szOutFilename)
1635 {
1636  std::ofstream OutStream(szOutFilename);
1637  PrintFiberGeometry(OutStream);
1638  OutStream.close();
1639 }
1640 
1641 void ALFA_GeometryReader::PrintFiberGeometry(std::ostream &OutStream)
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 }
1717 
1718 bool ALFA_GeometryReader::StoreReconstructionGeometry(const eRPotName eRPName, const eFiberType eFType, const char* szDataDestination)
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 }
1889 
1890 void ALFA_GeometryReader::UpdateGeometry()
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 }
1909 
1910 void ALFA_GeometryReader::GetListOfRPotIDs(std::map<eRPotName,std::string>* pMapRPotName)
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 }
1924 
1925 void ALFA_GeometryReader::GetListOfExistingRPotIDs(std::list<eRPotName>* pListRPotName)
1926 {
1927  *pListRPotName=m_ListExistingRPots;
1928 }
1929 
1930 bool ALFA_GeometryReader::GetRPPosParams(PRPPOSPARAMS pRPPosParams, const eRPotName eRPName)
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 }
1948 
1949 bool ALFA_GeometryReader::GetASPosParams(PASPOSPARAMS pASPosParams, const eAStationName eASName)
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 }
1967 
1968 eGeoSourceType ALFA_GeometryReader::GetRPGeometryType(const eRPotName eRPName, eFiberType eFType)
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 }
1984 
1985 bool ALFA_GeometryReader::GetMDFiberParams(PFIBERPARAMS pFiberParams, const eFiberType eFType, const eRPotName eRPName, const int nPlateID, const int nFiberID)
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 }
2015 
2016 // OD functions
2017 bool ALFA_GeometryReader::GetODFiberParams(PFIBERPARAMS pFiberParams, const eFiberType eFType, const eRPotName eRPName, const int nPlateID, const int nFiberID)
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 }
2123 
2124 void ALFA_GeometryReader::SetODFiberPositionToMainReference(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID, const HepGeom::Point3D<float>& TransPoint, const double fTransSlope)
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 }
2233 
2234 double ALFA_GeometryReader::GetODFiberCentreYPos(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
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 }
2252 
2253 double ALFA_GeometryReader::GetODFiberAngle(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
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 }
2271 
2272 double ALFA_GeometryReader::GetMDFiberSlope(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
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 }
2302 
2303 double ALFA_GeometryReader::GetMDFiberOffset(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
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 }
2333 
2334 double ALFA_GeometryReader::GetMDFiberZPos(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
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 }
2364 
2365 double ALFA_GeometryReader::GetODFiberSlope(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
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 }
2383 
2384 double ALFA_GeometryReader::GetODFiberOffset(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
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 }
2402 
2403 double ALFA_GeometryReader::GetODFiberZPos(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
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 }
2421 
2422 bool ALFA_GeometryReader::ParseRPMetrology(eGeoSourceType eSourceType, const char* szDataSource)
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 }
2496 
2497 bool ALFA_GeometryReader::ResolveRPotRefPoints(const char* szvalue, eRPotName eRPName, eRefPointType eRPointType)
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 }
2514 
2515 bool ALFA_GeometryReader::ParseRefPoints(const char* szvalue, std::vector<HepGeom::Point3D<double> >& vecRefPoints, eMetrologyCoordSystem eCSystem)
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 }
2590 
2591 bool ALFA_GeometryReader::ParseArrayOfValues(const char* szvalue, std::vector<double>& vecValues)
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 }
2629 
2630 bool ALFA_GeometryReader::SetupDetMetrologyPoints(ALFA_ConfigParams& CfgParams, eRPotName eRPName)
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 }
2725 
2726 bool ALFA_GeometryReader::SetupRPMetrologyPoints(ALFA_ConfigParams& CfgParams, eRPotName eRPName)
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 }
2826 
2827 bool ALFA_GeometryReader::SetupStationMetrologyPoints(ALFA_ConfigParams &CfgParams, eAStationName eASName)
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 }
2843 
2844 double ALFA_GeometryReader::GetPolyFitValue(const double fInputValue, const std::vector<double>& vecPolyFitParams)
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 }
2858 
2859 HepGeom::Point3D<double> ALFA_GeometryReader::GetDetPointInAtlas(eRPotName eRPName, const HepGeom::Point3D<double>& PointInDetCS)
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 }
2903 
2904 HepGeom::Point3D<double> ALFA_GeometryReader::GetDetPointInRPot(eRPotName eRPName, const HepGeom::Point3D<double>& PointInDetCS)
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 }
2925 
2926 
2927 bool ALFA_GeometryReader::SaveRPGeometryParams(const eRPotName eRPName, const char* szDataDestination)
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 }
2995 
2996 HepGeom::Transform3D ALFA_GeometryReader::GetTransformMatrix(const eRPotName eRPName, const eTransformElement eMatrixType)
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 }
3040 
3041 double ALFA_GeometryReader::GetRPotZPosInAtlas(const eRPotName eRPName)
3042 {
3043  RPPOSPARAMS RPParams;
3044  GetRPPosParams(&RPParams, eRPName);
3045 
3046  return RPParams.RefPins.DCPInAtlasCS.z();
3047 }
3048 
3049 void ALFA_GeometryReader::SetupCurrentLVDT(const PGEOMETRYCONFIGURATION pConfig)
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 }
3060 
3061 void ALFA_GeometryReader::SetupSWCorrections(const PGEOMETRYCONFIGURATION pConfig)
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 }
3077 
3078 void ALFA_GeometryReader::SetupUserCorrections(const PGEOMETRYCONFIGURATION pConfig)
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 }
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
ALFA_GeometryReader::ResolveRPotRefPoints
bool ResolveRPotRefPoints(const char *szvalue, eRPotName eRPName, eRefPointType eRPointType)
Definition: ALFA_GeometryReader.cxx:2497
eFiberType
eFiberType
Definition: ALFA_GeometryReader.h:26
RPPINS::DTPInAlfaCS
HepGeom::Point3D< double > DTPInAlfaCS
Definition: ALFA_GeometryReader.h:43
ALFA_SvdCalc.h
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
eFiberCoordSystem
eFiberCoordSystem
Definition: ALFA_GeometryReader.h:30
METROLOGYFILE
#define METROLOGYFILE
Definition: ALFA_constants.h:36
python.Constants.FATAL
int FATAL
Definition: Control/AthenaCommon/python/Constants.py:19
getMessageSvc.h
singleton-like access to IMessageSvc via open function and helper
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_GeometryReader::GetUFiberCentreXPos
double GetUFiberCentreXPos(const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1473
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
eMetrologyCoordSystem
eMetrologyCoordSystem
Definition: ALFA_GeometryReader.h:32
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
ALFA_GeometryReader::SetupUserCorrections
void SetupUserCorrections(const PGEOMETRYCONFIGURATION pConfig)
Definition: ALFA_GeometryReader.cxx:3078
ERPN_B7R1U
@ ERPN_B7R1U
Definition: ALFA_GeometryReader.h:28
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
ALFA_GeometryReader::GetMDFiberParams
bool GetMDFiberParams(PFIBERPARAMS pFiberParams, const eFiberType eFType, const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1985
ALFA_GeometryReader::GetRPGeometryType
eGeoSourceType GetRPGeometryType(const eRPotName eRPName, eFiberType eFType)
Definition: ALFA_GeometryReader.cxx:1968
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.h
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
ALFA_GeometryReader::GetListOfRPotIDs
void GetListOfRPotIDs(std::map< eRPotName, std::string > *pMapRPotName)
Definition: ALFA_GeometryReader.cxx:1910
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
ALFA_GeometryReader::GetODFiberSlope
double GetODFiberSlope(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:2365
ALFA_GeometryReader::SetODFiberPositionToMainReference
void SetODFiberPositionToMainReference(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID, const HepGeom::Point3D< float > &TransPoint, const double fTransSlope)
Definition: ALFA_GeometryReader.cxx:2124
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
ALFA_GeometryReader::SetUFiberPositionToMainReference
void SetUFiberPositionToMainReference(const eRPotName eRPName, const int nPlateID, const int nFiberID, const HepGeom::Point3D< float > &TransPoint, const double fTransSlope)
Definition: ALFA_GeometryReader.cxx:1545
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
x
#define x
RPPOSPARAMS::szLabel
char szLabel[8]
Definition: ALFA_GeometryReader.h:51
FIBERPARAMS
Definition: ALFA_GeometryReader.h:99
CFGRPPOSPARAMS::usercorr
struct CFGRPPOSPARAMS::@53 usercorr
ETE_T3
@ ETE_T3
Definition: ALFA_GeometryReader.h:33
ALFA_GeometryReader::GetTransformMatrix
HepGeom::Transform3D GetTransformMatrix(const eRPotName eRPName, const eTransformElement eMatrixType)
Definition: ALFA_GeometryReader.cxx:2996
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
ETE_A1
@ ETE_A1
Definition: ALFA_GeometryReader.h:33
GEOMETRYCONFIGURATION::clear
void clear()
Definition: ALFA_GeometryReader.cxx:72
ROMAPOT
Definition: ALFA_GeometryReader.h:140
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
GEOMETRYCONFIGURATION
Definition: ALFA_GeometryReader.h:197
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::GetODFiberOffset
double GetODFiberOffset(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:2384
ALFA_GeometryReader::GetMDFiberOffset
double GetMDFiberOffset(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:2303
ALFA_GeometryReader::PrintFiberGeometry
void PrintFiberGeometry(std::ostream &OutStream)
Definition: ALFA_GeometryReader.cxx:1641
FIBERPARAMS::fOriginZ
double fOriginZ
Definition: ALFA_GeometryReader.h:119
ALFA_GeometryReader::GetVFiberAngle
double GetVFiberAngle(const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1527
ALFA_RDBAccess::m_ListFiberData
std::list< FIBERDATA > m_ListFiberData
Definition: ALFA_RDBAccess.h:60
ALFA_GeometryReader::~ALFA_GeometryReader
~ALFA_GeometryReader()
Definition: ALFA_GeometryReader.cxx:115
ALFA_GeometryReader::SaveRPGeometryParams
bool SaveRPGeometryParams(const eRPotName eRPName, const char *szDataDestination)
Definition: ALFA_GeometryReader.cxx:2927
ALFA_GeometryReader::m_eMetrologyType
eMetrologyType m_eMetrologyType
Definition: ALFA_GeometryReader.h:226
ETE_A2
@ ETE_A2
Definition: ALFA_GeometryReader.h:33
EASN_UNDEFINED
@ EASN_UNDEFINED
Definition: ALFA_GeometryReader.h:27
CFGRPPOSPARAMS::bIsEnabledUserTranform
bool bIsEnabledUserTranform
Definition: ALFA_GeometryReader.h:189
RPPOSPARAMS::VecIdealDetRefPoints
std::vector< HepGeom::Point3D< double > > VecIdealDetRefPoints
Definition: ALFA_GeometryReader.h:70
RPPINS::DTPInRPotCS
HepGeom::Point3D< double > DTPInRPotCS
Definition: ALFA_GeometryReader.h:43
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
eTransformElement
eTransformElement
Definition: ALFA_GeometryReader.h:33
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
ALFA_GeometryReader::ALFA_GeometryReader
ALFA_GeometryReader()
Definition: ALFA_GeometryReader.cxx:108
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
eRefPointType
eRefPointType
Definition: ALFA_GeometryReader.h:31
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
ALFA_GeometryReader::GetPlateParams
bool GetPlateParams(PPLATEPARAMS pPlateParams, const eRPotName eRPName, const int nPlateID)
Definition: ALFA_GeometryReader.cxx:1609
ALFA_GeometryReader::Initialize
bool Initialize(const PGEOMETRYCONFIGURATION pConfig, eFiberCoordSystem eFCoordSystem)
Definition: ALFA_GeometryReader.cxx:688
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
ALFA_RDBAccess.h
RPPOSPARAMS::VecRealDetRefPoints
std::vector< HepGeom::Point3D< double > > VecRealDetRefPoints
Definition: ALFA_GeometryReader.h:71
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
RPPINS::clear
void clear()
Definition: ALFA_GeometryReader.cxx:25
GEOMETRYCONFIGURATION::eRPMetrologyGeoType
int eRPMetrologyGeoType
Definition: ALFA_GeometryReader.h:198
PathResolver.h
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
ALFA_GeometryReader::StoreReconstructionGeometry
bool StoreReconstructionGeometry(const eRPotName eRPName, const eFiberType eFType, const char *szDataDestination)
Definition: ALFA_GeometryReader.cxx:1718
EGST_DATABASE
@ EGST_DATABASE
Definition: ALFA_GeometryReader.h:24
RPPINS::RealRPPin2
HepGeom::Point3D< double > RealRPPin2
Definition: ALFA_GeometryReader.h:39
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
RPPINS::RealRPPin3
HepGeom::Point3D< double > RealRPPin3
Definition: ALFA_GeometryReader.h:40
ALFA_GeometryReader::GetMDFiberZPos
double GetMDFiberZPos(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:2334
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
ALFA_GeometryReader::SetVFiberPositionToMainReference
void SetVFiberPositionToMainReference(const eRPotName eRPName, const int nPlateID, const int nFiberID, const HepGeom::Point3D< float > &TransPoint, const double fTransSlope)
Definition: ALFA_GeometryReader.cxx:1577
GEOMETRYCONFIGURATION::fNominalZPosA7L1
double fNominalZPosA7L1
Definition: ALFA_GeometryReader.h:202
ALFA_GeometryReader::GetRPotZPosInAtlas
double GetRPotZPosInAtlas(const eRPotName eRPName)
Definition: ALFA_GeometryReader.cxx:3041
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
ALFA_GeometryReader::GetMDFiberSlope
double GetMDFiberSlope(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:2272
ERPN_A7R1U
@ ERPN_A7R1U
Definition: ALFA_GeometryReader.h:28
ODPLATESCNT
#define ODPLATESCNT
Definition: ALFA_CLinkAlg.h:31
ALFA_GeometryReader::GetODFiberCentreYPos
double GetODFiberCentreYPos(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:2234
ALFA_GeometryReader::GetUFiberParams
bool GetUFiberParams(PFIBERPARAMS pFiberParams, const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1414
y
#define y
RPPINS::RealRPPin1
HepGeom::Point3D< double > RealRPPin1
Definition: ALFA_GeometryReader.h:38
RPPOSPARAMS::DetectorNormal
HepGeom::Vector3D< double > DetectorNormal
Definition: ALFA_GeometryReader.h:59
ERPPT_UNSET
@ ERPPT_UNSET
Definition: ALFA_GeometryReader.h:29
lumiFormat.fill
fill
Definition: lumiFormat.py:111
ALFA_GeometryReader::GetListOfExistingRPotIDs
void GetListOfExistingRPotIDs(std::list< eRPotName > *pListRPotName)
Definition: ALFA_GeometryReader.cxx:1925
EFCS_ATLAS
@ EFCS_ATLAS
Definition: ALFA_GeometryReader.h:30
ALFA_GeometryReader::GetUFiberAngle
double GetUFiberAngle(const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1509
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
ASPOSPARAMS::ASTransformInMainPoint
HepGeom::Transform3D ASTransformInMainPoint
Definition: ALFA_GeometryReader.h:92
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
RPPINS::DTPInAtlasCS
HepGeom::Point3D< double > DTPInAtlasCS
Definition: ALFA_GeometryReader.h:43
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
ALFA_GeometryReader::GetVFiberCentreXPos
double GetVFiberCentreXPos(const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1491
CFGRPPOSPARAMS::eMDGeoType
int eMDGeoType
Definition: ALFA_GeometryReader.h:176
StoreGateSvc.h
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::GetODFiberZPos
double GetODFiberZPos(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:2403
ALFA_GeometryReader::GetODFiberAngle
double GetODFiberAngle(const eRPotName eRPName, const eFiberType eFType, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:2253
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:09:58 for ATLAS Offline Software by   doxygen 1.8.18