CMS 3D CMS Logo
Classes | Enumerations | Functions | Variables
AlignmentPI Namespace Reference

Classes

struct  TkAlBarycenters
 
struct  topolInfo
 

Enumerations

enum  coordinate {
  t_x = 1, t_y = 2, t_z = 3, rot_alpha = 4,
  rot_beta = 5, rot_gamma = 6
}
 
enum  index {
  XX = 1, XY = 2, XZ = 3, YZ = 4,
  YY = 5, ZZ = 6
}
 
enum  PARTITION {
  PARTITION::BPIX, PARTITION::FPIXp, PARTITION::FPIXm, PARTITION::TIB,
  PARTITION::TIDp, PARTITION::TIDm, PARTITION::TOB, PARTITION::TECp,
  PARTITION::TECm, PARTITION::LAST = TECm
}
 
enum  partitions {
  INVALID = 0, BPix = 1, FPix = 2, TIB = 3,
  TID = 4, TOB = 5, TEC = 6
}
 
enum  regions {
  BPixL1o, BPixL1i, BPixL2o, BPixL2i,
  BPixL3o, BPixL3i, BPixL4o, BPixL4i,
  FPixmL1, FPixmL2, FPixmL3, FPixpL1,
  FPixpL2, FPixpL3, TIBL1Ro, TIBL1Ri,
  TIBL1So, TIBL1Si, TIBL2Ro, TIBL2Ri,
  TIBL2So, TIBL2Si, TIBL3o, TIBL3i,
  TIBL4o, TIBL4i, TOBL1Ro, TOBL1Ri,
  TOBL1So, TOBL1Si, TOBL2Ro, TOBL2Ri,
  TOBL2So, TOBL2Si, TOBL3o, TOBL3i,
  TOBL4o, TOBL4i, TOBL5o, TOBL5i,
  TOBL6o, TOBL6i, TIDmR1R, TIDmR1S,
  TIDmR2R, TIDmR2S, TIDmR3, TIDpR1R,
  TIDpR1S, TIDpR2R, TIDpR2S, TIDpR3,
  TECmR1R, TECmR1S, TECmR2R, TECmR2S,
  TECmR3, TECmR4, TECmR5, TECmR6,
  TECmR7, TECpR1R, TECpR1S, TECpR2R,
  TECpR2S, TECpR3, TECpR4, TECpR5,
  TECpR6, TECpR7, StripDoubleSide, NUM_OF_REGIONS
}
 

Functions

std::pair< double, double > calculatePosition (TVirtualPad *myPad, int boundary)
 
void fillComparisonHistogram (const AlignmentPI::coordinate &coord, std::map< int, AlignmentPI::partitions > &boundaries, const std::vector< AlignTransform > &ref_ali, const std::vector< AlignTransform > &target_ali, std::unique_ptr< TH1F > &compare)
 
void fillComparisonHistograms (std::map< int, AlignmentPI::partitions > &boundaries, const std::vector< AlignTransform > &ref_ali, const std::vector< AlignTransform > &target_ali, std::unordered_map< AlignmentPI::coordinate, std::unique_ptr< TH1F > > &compare, bool diff=false, AlignmentPI::partitions checkPart=AlignmentPI::INVALID)
 
std::pair< int, int > getIndices (AlignmentPI::index i)
 
std::string getStringFromCoordinate (AlignmentPI::coordinate coord)
 
std::string getStringFromIndex (AlignmentPI::index i)
 
std::string getStringFromPart (AlignmentPI::partitions i, bool isPhase2=false)
 
std::string getStringFromRegionEnum (AlignmentPI::regions e)
 
std::pair< float, float > getTheRange (std::map< uint32_t, float > values, const float nsigma)
 
bool isBPixOuterLadder (const DetId &detid, const TrackerTopology &tTopo, bool isPhase0)
 
void makeNicePlotStyle (TH1 *hist, int color)
 
void makeNiceStats (TH1F *hist, AlignmentPI::partitions part, int color)
 
std::ostream & operator<< (std::ostream &o, PARTITION x)
 
double returnZeroIfNear2PI (const double phi)
 
double trim2PIs (const double phi, const double tolerance=1.f)
 

Variables

static const float cmToUm = 10000.f
 
const PARTITION PARTITIONS [(int) PARTITION::LAST+1]
 
static const unsigned int phase0size = 19876
 
static const unsigned int phase1size = 20292
 
static const float tomRad = 1000.f
 

Enumeration Type Documentation

◆ coordinate

enum AlignmentPI::coordinate
Enumerator
t_x 
t_y 
t_z 
rot_alpha 
rot_beta 
rot_gamma 

Definition at line 59 of file AlignmentPayloadInspectorHelper.h.

59  {
60  t_x = 1,
61  t_y = 2,
62  t_z = 3,
63  rot_alpha = 4,
64  rot_beta = 5,
65  rot_gamma = 6,
66  };

◆ index

enum AlignmentPI::index
Enumerator
XX 
XY 
XZ 
YZ 
YY 
ZZ 

Definition at line 72 of file AlignmentPayloadInspectorHelper.h.

72 { XX = 1, XY = 2, XZ = 3, YZ = 4, YY = 5, ZZ = 6 };

◆ PARTITION

enum AlignmentPI::PARTITION
strong
Enumerator
BPIX 
FPIXp 
FPIXm 
TIB 
TIDp 
TIDm 
TOB 
TECp 
TECm 
LAST 

Definition at line 76 of file AlignmentPayloadInspectorHelper.h.

76  {
77  BPIX, // 0 Barrel Pixel
78  FPIXp, // 1 Forward Pixel Plus
79  FPIXm, // 2 Forward Pixel Minus
80  TIB, // 3 Tracker Inner Barrel
81  TIDp, // 4 Tracker Inner Disks Plus
82  TIDm, // 5 Tracker Inner Disks Minus
83  TOB, // 6 Tracker Outer Barrel
84  TECp, // 7 Tracker Endcaps Plus
85  TECm, // 8 Tracker Endcaps Minus
86  LAST = TECm
87  };
BPIX
#define BPIX
Definition: PixelCalibConfiguration.cc:22

◆ partitions

enum AlignmentPI::partitions
Enumerator
INVALID 
BPix 
FPix 
TIB 
TID 
TOB 
TEC 

Definition at line 74 of file AlignmentPayloadInspectorHelper.h.

74 { INVALID = 0, BPix = 1, FPix = 2, TIB = 3, TID = 4, TOB = 5, TEC = 6 };

◆ regions

enum AlignmentPI::regions
Enumerator
BPixL1o 
BPixL1i 
BPixL2o 
BPixL2i 
BPixL3o 
BPixL3i 
BPixL4o 
BPixL4i 
FPixmL1 
FPixmL2 
FPixmL3 
FPixpL1 
FPixpL2 
FPixpL3 
TIBL1Ro 
TIBL1Ri 
TIBL1So 
TIBL1Si 
TIBL2Ro 
TIBL2Ri 
TIBL2So 
TIBL2Si 
TIBL3o 
TIBL3i 
TIBL4o 
TIBL4i 
TOBL1Ro 
TOBL1Ri 
TOBL1So 
TOBL1Si 
TOBL2Ro 
TOBL2Ri 
TOBL2So 
TOBL2Si 
TOBL3o 
TOBL3i 
TOBL4o 
TOBL4i 
TOBL5o 
TOBL5i 
TOBL6o 
TOBL6i 
TIDmR1R 
TIDmR1S 
TIDmR2R 
TIDmR2S 
TIDmR3 
TIDpR1R 
TIDpR1S 
TIDpR2R 
TIDpR2S 
TIDpR3 
TECmR1R 
TECmR1S 
TECmR2R 
TECmR2S 
TECmR3 
TECmR4 
TECmR5 
TECmR6 
TECmR7 
TECpR1R 
TECpR1S 
TECpR2R 
TECpR2S 
TECpR3 
TECpR4 
TECpR5 
TECpR6 
TECpR7 
StripDoubleSide 
NUM_OF_REGIONS 

Definition at line 104 of file AlignmentPayloadInspectorHelper.h.

104  {
105  BPixL1o, //0 Barrel Pixel Layer 1 outer
106  BPixL1i, //1 Barrel Pixel Layer 1 inner
107  BPixL2o, //2 Barrel Pixel Layer 2 outer
108  BPixL2i, //3 Barrel Pixel Layer 2 inner
109  BPixL3o, //4 Barrel Pixel Layer 3 outer
110  BPixL3i, //5 Barrel Pixel Layer 3 inner
111  BPixL4o, //6 Barrel Pixel Layer 4 outer
112  BPixL4i, //7 Barrel Pixel Layer 4 inner
113  FPixmL1, //8 Forward Pixel Minus side Disk 1
114  FPixmL2, //9 Forward Pixel Minus side Disk 2
115  FPixmL3, //10 Forward Pixel Minus side Disk 3
116  FPixpL1, //11 Forward Pixel Plus side Disk 1
117  FPixpL2, //12 Forward Pixel Plus side Disk 2
118  FPixpL3, //13 Forward Pixel Plus side Disk 3
119  TIBL1Ro, //14 Inner Barrel Layer 1 Rphi outer
120  TIBL1Ri, //15 Inner Barrel Layer 1 Rphi inner
121  TIBL1So, //16 Inner Barrel Layer 1 Stereo outer
122  TIBL1Si, //17 Inner Barrel Layer 1 Stereo inner
123  TIBL2Ro, //18 Inner Barrel Layer 2 Rphi outer
124  TIBL2Ri, //19 Inner Barrel Layer 2 Rphi inner
125  TIBL2So, //20 Inner Barrel Layer 2 Stereo outer
126  TIBL2Si, //21 Inner Barrel Layer 2 Stereo inner
127  TIBL3o, //22 Inner Barrel Layer 3 outer
128  TIBL3i, //23 Inner Barrel Layer 3 inner
129  TIBL4o, //24 Inner Barrel Layer 4 outer
130  TIBL4i, //25 Inner Barrel Layer 4 inner
131  TOBL1Ro, //26 Outer Barrel Layer 1 Rphi outer
132  TOBL1Ri, //27 Outer Barrel Layer 1 Rphi inner
133  TOBL1So, //28 Outer Barrel Layer 1 Stereo outer
134  TOBL1Si, //29 Outer Barrel Layer 1 Stereo inner
135  TOBL2Ro, //30 Outer Barrel Layer 2 Rphi outer
136  TOBL2Ri, //31 Outer Barrel Layer 2 Rphi inner
137  TOBL2So, //32 Outer Barrel Layer 2 Stereo outer
138  TOBL2Si, //33 Outer Barrel Layer 2 Stereo inner
139  TOBL3o, //34 Outer Barrel Layer 3 outer
140  TOBL3i, //35 Outer Barrel Layer 3 inner
141  TOBL4o, //36 Outer Barrel Layer 4 outer
142  TOBL4i, //37 Outer Barrel Layer 4 inner
143  TOBL5o, //38 Outer Barrel Layer 5 outer
144  TOBL5i, //39 Outer Barrel Layer 5 inner
145  TOBL6o, //40 Outer Barrel Layer 6 outer
146  TOBL6i, //41 Outer Barrel Layer 6 inner
147  TIDmR1R, //42 Inner Disk Minus side Ring 1 Rphi
148  TIDmR1S, //43 Inner Disk Minus side Ring 1 Stereo
149  TIDmR2R, //44 Inner Disk Minus side Ring 2 Rphi
150  TIDmR2S, //45 Inner Disk Minus side Ring 2 Stereo
151  TIDmR3, //46 Inner Disk Minus side Ring 3
152  TIDpR1R, //47 Inner Disk Plus side Ring 1 Rphi
153  TIDpR1S, //48 Inner Disk Plus side Ring 1 Stereo
154  TIDpR2R, //49 Inner Disk Plus side Ring 2 Rphi
155  TIDpR2S, //50 Inner Disk Plus side Ring 2 Stereo
156  TIDpR3, //51 Inner Disk Plus side Ring 3
157  TECmR1R, //52 Endcaps Minus side Ring 1 Rphi
158  TECmR1S, //53 Endcaps Minus side Ring 1 Stereo
159  TECmR2R, //54 Encdaps Minus side Ring 2 Rphi
160  TECmR2S, //55 Endcaps Minus side Ring 2 Stereo
161  TECmR3, //56 Endcaps Minus side Ring 3
162  TECmR4, //57 Endcaps Minus side Ring 4
163  TECmR5, //58 Endcaps Minus side Ring 5
164  TECmR6, //59 Endcaps Minus side Ring 6
165  TECmR7, //60 Endcaps Minus side Ring 7
166  TECpR1R, //61 Endcaps Plus side Ring 1 Rphi
167  TECpR1S, //62 Endcaps Plus side Ring 1 Stereo
168  TECpR2R, //63 Encdaps Plus side Ring 2 Rphi
169  TECpR2S, //64 Endcaps Plus side Ring 2 Stereo
170  TECpR3, //65 Endcaps Plus side Ring 3
171  TECpR4, //66 Endcaps Plus side Ring 4
172  TECpR5, //67 Endcaps Plus side Ring 5
173  TECpR6, //68 Endcaps Plus side Ring 6
174  TECpR7, //67 Endcaps Plus side Ring 7
175  StripDoubleSide, // 70 -- not to be considered
176  NUM_OF_REGIONS // 71 -- default
177  };

Function Documentation

◆ calculatePosition()

std::pair<double, double> AlignmentPI::calculatePosition ( TVirtualPad *  myPad,
int  boundary 
)
inline

Definition at line 801 of file AlignmentPayloadInspectorHelper.h.

References createfilelist::int, SiStripPI::min, and corrVsCorr::rx.

Referenced by HGCalImagingAlgo::getClusters(), and HGCalCLUEAlgoT< TILE >::getClusters().

803  {
804  int ix1;
805  int ix2;
806  int iw = myPad->GetWw();
807  int ih = myPad->GetWh();
808  double x1p, y1p, x2p, y2p;
809  myPad->GetPadPar(x1p, y1p, x2p, y2p);
810  ix1 = (int)(iw * x1p);
811  ix2 = (int)(iw * x2p);
812  double wndc = std::min(1., (double)iw / (double)ih);
813  double rw = wndc / (double)iw;
814  double x1ndc = (double)ix1 * rw;
815  double x2ndc = (double)ix2 * rw;
816  double rx1, ry1, rx2, ry2;
817  myPad->GetRange(rx1, ry1, rx2, ry2);
818  double rx = (x2ndc - x1ndc) / (rx2 - rx1);
819  double _sx;
820  _sx = rx * (boundary - rx1) + x1ndc;
821  double _dx = _sx + 0.05;
822 
823  return std::make_pair(_sx, _dx);
824  }

◆ fillComparisonHistogram()

void AlignmentPI::fillComparisonHistogram ( const AlignmentPI::coordinate &  coord,
std::map< int, AlignmentPI::partitions > &  boundaries,
const std::vector< AlignTransform > &  ref_ali,
const std::vector< AlignTransform > &  target_ali,
std::unique_ptr< TH1F > &  compare 
)
inline

Definition at line 1010 of file AlignmentPayloadInspectorHelper.h.

References BPix, cmToUm, counter, SiPixelRawToDigiRegional_cfi::deltaPhi, mps_fire::i, rot_alpha, rot_beta, rot_gamma, idealTransformation::rotation, DetId::subdetId(), t_x, t_y, t_z, align::toAngles(), and tomRad.

1016  {
1017  int counter = 0; /* start the counter */
1018  AlignmentPI::partitions currentPart = AlignmentPI::BPix;
1019  for (unsigned int i = 0; i < ref_ali.size(); i++) {
1020  if (ref_ali[i].rawId() == target_ali[i].rawId()) {
1021  counter++;
1022  int subid = DetId(ref_ali[i].rawId()).subdetId();
1023 
1024  auto thePart = static_cast<AlignmentPI::partitions>(subid);
1025  if (thePart != currentPart) {
1026  currentPart = thePart;
1027  boundaries.insert({counter, thePart});
1028  }
1029 
1030  CLHEP::HepRotation target_rot(target_ali[i].rotation());
1031  CLHEP::HepRotation ref_rot(ref_ali[i].rotation());
1032 
1033  align::RotationType target_ROT(target_rot.xx(),
1034  target_rot.xy(),
1035  target_rot.xz(),
1036  target_rot.yx(),
1037  target_rot.yy(),
1038  target_rot.yz(),
1039  target_rot.zx(),
1040  target_rot.zy(),
1041  target_rot.zz());
1042 
1043  align::RotationType ref_ROT(ref_rot.xx(),
1044  ref_rot.xy(),
1045  ref_rot.xz(),
1046  ref_rot.yx(),
1047  ref_rot.yy(),
1048  ref_rot.yz(),
1049  ref_rot.zx(),
1050  ref_rot.zy(),
1051  ref_rot.zz());
1052 
1053  const std::vector<double> deltaRot = {::deltaPhi(align::toAngles(target_ROT)[0], align::toAngles(ref_ROT)[0]),
1054  ::deltaPhi(align::toAngles(target_ROT)[1], align::toAngles(ref_ROT)[1]),
1055  ::deltaPhi(align::toAngles(target_ROT)[2], align::toAngles(ref_ROT)[2])};
1056 
1057  const auto& deltaTrans = target_ali[i].translation() - ref_ali[i].translation();
1058 
1059  switch (coord) {
1060  case AlignmentPI::t_x:
1061  compare->SetBinContent(i + 1, deltaTrans.x() * AlignmentPI::cmToUm);
1062  break;
1063  case AlignmentPI::t_y:
1064  compare->SetBinContent(i + 1, deltaTrans.y() * AlignmentPI::cmToUm);
1065  break;
1066  case AlignmentPI::t_z:
1067  compare->SetBinContent(i + 1, deltaTrans.z() * AlignmentPI::cmToUm);
1068  break;
1069  case AlignmentPI::rot_alpha:
1070  compare->SetBinContent(i + 1, deltaRot[0] * AlignmentPI::tomRad);
1071  break;
1072  case AlignmentPI::rot_beta:
1073  compare->SetBinContent(i + 1, deltaRot[1] * AlignmentPI::tomRad);
1074  break;
1075  case AlignmentPI::rot_gamma:
1076  compare->SetBinContent(i + 1, deltaRot[2] * AlignmentPI::tomRad);
1077  break;
1078  default:
1079  edm::LogError("TrackerAlignment_PayloadInspector") << "Unrecognized coordinate " << coord << std::endl;
1080  break;
1081  } // switch on the coordinate
1082  } // check on the same detID
1083  } // loop on the components
1084  }
mps_fire.i
i
Definition: mps_fire.py:429
SiPixelRawToDigiRegional_cfi.deltaPhi
deltaPhi
Definition: SiPixelRawToDigiRegional_cfi.py:9
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
AlignmentPI::cmToUm
static const float cmToUm
Definition: AlignmentPayloadInspectorHelper.h:35
AlignmentPI::tomRad
static const float tomRad
Definition: AlignmentPayloadInspectorHelper.h:36
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:48
align::toAngles
EulerAngles toAngles(const RotationType &)
Convert rotation matrix to angles about x-, y-, z-axes (frame rotation).
Definition: Utilities.cc:8
DetId
Definition: DetId.h:17
counter
static std::atomic< unsigned int > counter
Definition: SharedResourceNames.cc:17

◆ fillComparisonHistograms()

void AlignmentPI::fillComparisonHistograms ( std::map< int, AlignmentPI::partitions > &  boundaries,
const std::vector< AlignTransform > &  ref_ali,
const std::vector< AlignTransform > &  target_ali,
std::unordered_map< AlignmentPI::coordinate, std::unique_ptr< TH1F > > &  compare,
bool  diff = false,
AlignmentPI::partitions  checkPart = AlignmentPI::INVALID 
)
inline

Definition at line 1087 of file AlignmentPayloadInspectorHelper.h.

References BPix, cmToUm, counter, SiPixelRawToDigiRegional_cfi::deltaPhi, change_name::diff, mps_fire::i, rot_alpha, rot_beta, rot_gamma, idealTransformation::rotation, DetId::subdetId(), t_x, t_y, t_z, align::toAngles(), and tomRad.

1094  {
1095  int counter = 0; /* start the counter */
1096  AlignmentPI::partitions currentPart = AlignmentPI::BPix;
1097  for (unsigned int i = 0; i < ref_ali.size(); i++) {
1098  if (ref_ali[i].rawId() == target_ali[i].rawId()) {
1099  counter++;
1100  int subid = DetId(ref_ali[i].rawId()).subdetId();
1101 
1102  auto thePart = static_cast<AlignmentPI::partitions>(subid);
1103 
1104  // in case it has to be filtered
1105  if (checkPart > 0 && thePart != checkPart) {
1106  continue;
1107  }
1108 
1109  if (thePart != currentPart) {
1110  currentPart = thePart;
1111  boundaries.insert({counter, thePart});
1112  }
1113 
1114  CLHEP::HepRotation target_rot(target_ali[i].rotation());
1115  CLHEP::HepRotation ref_rot(ref_ali[i].rotation());
1116 
1117  align::RotationType target_ROT(target_rot.xx(),
1118  target_rot.xy(),
1119  target_rot.xz(),
1120  target_rot.yx(),
1121  target_rot.yy(),
1122  target_rot.yz(),
1123  target_rot.zx(),
1124  target_rot.zy(),
1125  target_rot.zz());
1126 
1127  align::RotationType ref_ROT(ref_rot.xx(),
1128  ref_rot.xy(),
1129  ref_rot.xz(),
1130  ref_rot.yx(),
1131  ref_rot.yy(),
1132  ref_rot.yz(),
1133  ref_rot.zx(),
1134  ref_rot.zy(),
1135  ref_rot.zz());
1136 
1137  const std::vector<double> deltaRot = {::deltaPhi(align::toAngles(target_ROT)[0], align::toAngles(ref_ROT)[0]),
1138  ::deltaPhi(align::toAngles(target_ROT)[1], align::toAngles(ref_ROT)[1]),
1139  ::deltaPhi(align::toAngles(target_ROT)[2], align::toAngles(ref_ROT)[2])};
1140 
1141  const auto& deltaTrans = target_ali[i].translation() - ref_ali[i].translation();
1142 
1143  // fill the histograms
1144  if (diff) {
1145  compare[AlignmentPI::t_x]->Fill(deltaTrans.x() * AlignmentPI::cmToUm);
1146  compare[AlignmentPI::t_y]->Fill(deltaTrans.y() * AlignmentPI::cmToUm);
1147  compare[AlignmentPI::t_z]->Fill(deltaTrans.z() * AlignmentPI::cmToUm);
1148 
1149  compare[AlignmentPI::rot_alpha]->Fill(deltaRot[0] * AlignmentPI::tomRad);
1150  compare[AlignmentPI::rot_beta]->Fill(deltaRot[1] * AlignmentPI::tomRad);
1151  compare[AlignmentPI::rot_gamma]->Fill(deltaRot[2] * AlignmentPI::tomRad);
1152  } else {
1153  compare[AlignmentPI::t_x]->SetBinContent(i + 1, deltaTrans.x() * AlignmentPI::cmToUm);
1154  compare[AlignmentPI::t_y]->SetBinContent(i + 1, deltaTrans.y() * AlignmentPI::cmToUm);
1155  compare[AlignmentPI::t_z]->SetBinContent(i + 1, deltaTrans.z() * AlignmentPI::cmToUm);
1156 
1157  compare[AlignmentPI::rot_alpha]->SetBinContent(i + 1, deltaRot[0] * AlignmentPI::tomRad);
1158  compare[AlignmentPI::rot_beta]->SetBinContent(i + 1, deltaRot[1] * AlignmentPI::tomRad);
1159  compare[AlignmentPI::rot_gamma]->SetBinContent(i + 1, deltaRot[2] * AlignmentPI::tomRad);
1160  }
1161 
1162  } // if it's the same detid
1163  } // loop on detids
1164  }
mps_fire.i
i
Definition: mps_fire.py:429
SiPixelRawToDigiRegional_cfi.deltaPhi
deltaPhi
Definition: SiPixelRawToDigiRegional_cfi.py:9
AlignmentPI::cmToUm
static const float cmToUm
Definition: AlignmentPayloadInspectorHelper.h:35
AlignmentPI::tomRad
static const float tomRad
Definition: AlignmentPayloadInspectorHelper.h:36
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:48
change_name.diff
diff
Definition: change_name.py:13
align::toAngles
EulerAngles toAngles(const RotationType &)
Convert rotation matrix to angles about x-, y-, z-axes (frame rotation).
Definition: Utilities.cc:8
DetId
Definition: DetId.h:17
counter
static std::atomic< unsigned int > counter
Definition: SharedResourceNames.cc:17

◆ getIndices()

std::pair<int, int> AlignmentPI::getIndices ( AlignmentPI::index  i)
inline

Definition at line 696 of file AlignmentPayloadInspectorHelper.h.

References mps_fire::i, XX, XY, XZ, YY, YZ, and ZZ.

698  {
699  switch (i) {
700  case XX:
701  return std::make_pair(0, 0);
702  case XY:
703  return std::make_pair(0, 1);
704  case XZ:
705  return std::make_pair(0, 2);
706  case YZ:
707  return std::make_pair(1, 0);
708  case YY:
709  return std::make_pair(1, 1);
710  case ZZ:
711  return std::make_pair(2, 2);
712  default:
713  return std::make_pair(-1, -1);
714  }
715  }
mps_fire.i
i
Definition: mps_fire.py:429

◆ getStringFromCoordinate()

std::string AlignmentPI::getStringFromCoordinate ( AlignmentPI::coordinate  coord)
inline

Definition at line 630 of file AlignmentPayloadInspectorHelper.h.

References rot_alpha, rot_beta, rot_gamma, t_x, t_y, and t_z.

632  {
633  switch (coord) {
634  case t_x:
635  return "x-translation";
636  case t_y:
637  return "y-translation";
638  case t_z:
639  return "z-translation";
640  case rot_alpha:
641  return "#alpha angle rotation";
642  case rot_beta:
643  return "#beta angle rotation";
644  case rot_gamma:
645  return "#gamma angle rotation";
646  default:
647  return "should never be here!";
648  }
649  }

◆ getStringFromIndex()

std::string AlignmentPI::getStringFromIndex ( AlignmentPI::index  i)
inline

Definition at line 652 of file AlignmentPayloadInspectorHelper.h.

References mps_fire::i, XX, XY, XZ, YY, YZ, and ZZ.

654  {
655  switch (i) {
656  case XX:
657  return "XX";
658  case XY:
659  return "XY";
660  case XZ:
661  return "XZ";
662  case YZ:
663  return "YX";
664  case YY:
665  return "YY";
666  case ZZ:
667  return "ZZ";
668  default:
669  return "should never be here!";
670  }
671  }
mps_fire.i
i
Definition: mps_fire.py:429

◆ getStringFromPart()

std::string AlignmentPI::getStringFromPart ( AlignmentPI::partitions  i,
bool  isPhase2 = false 
)
inline

Definition at line 674 of file AlignmentPayloadInspectorHelper.h.

References BPix, FPix, mps_fire::i, HLT_2022v15_cff::isPhase2, TEC, TIB, TID, and TOB.

Referenced by makeNiceStats().

676  {
677  switch (i) {
678  case BPix:
679  return "BPix";
680  case FPix:
681  return "FPix";
682  case TIB:
683  return (isPhase2 ? "TIB-invalid" : "TIB");
684  case TID:
685  return (isPhase2 ? "P2OTEC" : "TID");
686  case TOB:
687  return (isPhase2 ? "P2OTB" : "TOB");
688  case TEC:
689  return (isPhase2 ? "TEC-invalid" : "TEC");
690  default:
691  return "should never be here!";
692  }
693  }
mps_fire.i
i
Definition: mps_fire.py:429
HLT_2022v15_cff.isPhase2
isPhase2
Definition: HLT_2022v15_cff.py:4750

◆ getStringFromRegionEnum()

std::string AlignmentPI::getStringFromRegionEnum ( AlignmentPI::regions  e)
inline

Definition at line 180 of file AlignmentPayloadInspectorHelper.h.

References BPixL1i, BPixL1o, BPixL2i, BPixL2o, BPixL3i, BPixL3o, BPixL4i, BPixL4o, MillePedeFileConverter_cfg::e, FPixmL1, FPixmL2, FPixmL3, FPixpL1, FPixpL2, FPixpL3, TECmR1R, TECmR1S, TECmR2R, TECmR2S, TECmR3, TECmR4, TECmR5, TECmR6, TECmR7, TECpR1R, TECpR1S, TECpR2R, TECpR2S, TECpR3, TECpR4, TECpR5, TECpR6, TECpR7, TIBL1Ri, TIBL1Ro, TIBL1Si, TIBL1So, TIBL2Ri, TIBL2Ro, TIBL2Si, TIBL2So, TIBL3i, TIBL3o, TIBL4i, TIBL4o, TIDmR1R, TIDmR1S, TIDmR2R, TIDmR2S, TIDmR3, TIDpR1R, TIDpR1S, TIDpR2R, TIDpR2S, TIDpR3, TOBL1Ri, TOBL1Ro, TOBL1Si, TOBL1So, TOBL2Ri, TOBL2Ro, TOBL2Si, TOBL2So, TOBL3i, TOBL3o, TOBL4i, TOBL4o, TOBL5i, TOBL5o, TOBL6i, and TOBL6o.

182  {
183  switch (e) {
184  case AlignmentPI::BPixL1o:
185  return "BPixL1o";
186  case AlignmentPI::BPixL1i:
187  return "BPixL1i";
188  case AlignmentPI::BPixL2o:
189  return "BPixL2o";
190  case AlignmentPI::BPixL2i:
191  return "BPixL2i";
192  case AlignmentPI::BPixL3o:
193  return "BPixL3o";
194  case AlignmentPI::BPixL3i:
195  return "BPixL3i";
196  case AlignmentPI::BPixL4o:
197  return "BPixL4o";
198  case AlignmentPI::BPixL4i:
199  return "BPixL4i";
200  case AlignmentPI::FPixmL1:
201  return "FPixmL1";
202  case AlignmentPI::FPixmL2:
203  return "FPixmL2";
204  case AlignmentPI::FPixmL3:
205  return "FPixmL3";
206  case AlignmentPI::FPixpL1:
207  return "FPixpL1";
208  case AlignmentPI::FPixpL2:
209  return "FPixpL2";
210  case AlignmentPI::FPixpL3:
211  return "FPixpL3";
212  case AlignmentPI::TIBL1Ro:
213  return "TIBL1Ro";
214  case AlignmentPI::TIBL1Ri:
215  return "TIBL1Ri";
216  case AlignmentPI::TIBL1So:
217  return "TIBL1So";
218  case AlignmentPI::TIBL1Si:
219  return "TIBL1Si";
220  case AlignmentPI::TIBL2Ro:
221  return "TIBL2Ro";
222  case AlignmentPI::TIBL2Ri:
223  return "TIBL2Ri";
224  case AlignmentPI::TIBL2So:
225  return "TIBL2So";
226  case AlignmentPI::TIBL2Si:
227  return "TIBL2Si";
228  case AlignmentPI::TIBL3o:
229  return "TIBL3o";
230  case AlignmentPI::TIBL3i:
231  return "TIBL3i";
232  case AlignmentPI::TIBL4o:
233  return "TIBL4o";
234  case AlignmentPI::TIBL4i:
235  return "TIBL4i";
236  case AlignmentPI::TOBL1Ro:
237  return "TOBL1Ro";
238  case AlignmentPI::TOBL1Ri:
239  return "TOBL1Ri";
240  case AlignmentPI::TOBL1So:
241  return "TOBL1So";
242  case AlignmentPI::TOBL1Si:
243  return "TOBL1Si";
244  case AlignmentPI::TOBL2Ro:
245  return "TOBL2Ro";
246  case AlignmentPI::TOBL2Ri:
247  return "TOBL2Ri";
248  case AlignmentPI::TOBL2So:
249  return "TOBL2So";
250  case AlignmentPI::TOBL2Si:
251  return "TOBL2Si";
252  case AlignmentPI::TOBL3o:
253  return "TOBL3o";
254  case AlignmentPI::TOBL3i:
255  return "TOBL3i";
256  case AlignmentPI::TOBL4o:
257  return "TOBL4o";
258  case AlignmentPI::TOBL4i:
259  return "TOBL4i";
260  case AlignmentPI::TOBL5o:
261  return "TOBL5o";
262  case AlignmentPI::TOBL5i:
263  return "TOBL5i";
264  case AlignmentPI::TOBL6o:
265  return "TOBL6o";
266  case AlignmentPI::TOBL6i:
267  return "TOBL6i";
268  case AlignmentPI::TIDmR1R:
269  return "TIDmR1R";
270  case AlignmentPI::TIDmR1S:
271  return "TIDmR1S";
272  case AlignmentPI::TIDmR2R:
273  return "TIDmR2R";
274  case AlignmentPI::TIDmR2S:
275  return "TIDmR2S";
276  case AlignmentPI::TIDmR3:
277  return "TIDmR3";
278  case AlignmentPI::TIDpR1R:
279  return "TIDpR1R";
280  case AlignmentPI::TIDpR1S:
281  return "TIDpR1S";
282  case AlignmentPI::TIDpR2R:
283  return "TIDpR2R";
284  case AlignmentPI::TIDpR2S:
285  return "TIDpR2S";
286  case AlignmentPI::TIDpR3:
287  return "TIDpR3";
288  case AlignmentPI::TECmR1R:
289  return "TECmR1R";
290  case AlignmentPI::TECmR1S:
291  return "TECmR1S";
292  case AlignmentPI::TECmR2R:
293  return "TECmR2R";
294  case AlignmentPI::TECmR2S:
295  return "TECmR2S";
296  case AlignmentPI::TECmR3:
297  return "TECmR3";
298  case AlignmentPI::TECmR4:
299  return "TECmR4";
300  case AlignmentPI::TECmR5:
301  return "TECmR5";
302  case AlignmentPI::TECmR6:
303  return "TECmR6";
304  case AlignmentPI::TECmR7:
305  return "TECmR7";
306  case AlignmentPI::TECpR1R:
307  return "TECpR1R";
308  case AlignmentPI::TECpR1S:
309  return "TECpR1S";
310  case AlignmentPI::TECpR2R:
311  return "TECpR2R";
312  case AlignmentPI::TECpR2S:
313  return "TECpR2S";
314  case AlignmentPI::TECpR3:
315  return "TECpR3";
316  case AlignmentPI::TECpR4:
317  return "TECpR4";
318  case AlignmentPI::TECpR5:
319  return "TECpR5";
320  case AlignmentPI::TECpR6:
321  return "TECpR6";
322  case AlignmentPI::TECpR7:
323  return "TECpR7";
324  default:
325  edm::LogWarning("LogicError") << "Unknown partition: " << e;
326  return "";
327  }
328  }
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122

◆ getTheRange()

std::pair<float, float> AlignmentPI::getTheRange ( std::map< uint32_t, float >  values,
const float  nsigma 
)
inline

Definition at line 776 of file AlignmentPayloadInspectorHelper.h.

References visualization-live-secondInstance_cfg::m, AlCaHLTBitMon_ParallelJobs::p, mathSSE::sqrt(), plotscripts::stdev(), and contentValuesCheck::values.

778  {
779  float sum = std::accumulate(
780  std::begin(values), std::end(values), 0.0, [](float value, const std::map<uint32_t, float>::value_type& p) {
781  return value + p.second;
782  });
783 
784  float m = sum / values.size();
785 
786  float accum = 0.0;
787  std::for_each(std::begin(values), std::end(values), [&](const std::map<uint32_t, float>::value_type& p) {
788  accum += (p.second - m) * (p.second - m);
789  });
790 
791  float stdev = sqrt(accum / (values.size() - 1));
792 
793  if (stdev != 0.) {
794  return std::make_pair(m - nsigma * stdev, m + nsigma * stdev);
795  } else {
796  return std::make_pair(m > 0. ? 0.95 * m : 1.05 * m, m > 0 ? 1.05 * m : 0.95 * m);
797  }
798  }
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
visualization-live-secondInstance_cfg.m
m
Definition: visualization-live-secondInstance_cfg.py:80
value
Definition: value.py:1
plotscripts.stdev
def stdev(xlist)
Definition: plotscripts.py:69
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153

◆ isBPixOuterLadder()

bool AlignmentPI::isBPixOuterLadder ( const DetId &  detid,
const TrackerTopology &  tTopo,
bool  isPhase0 
)
inline

Definition at line 331 of file AlignmentPayloadInspectorHelper.h.

References TrackerTopology::pxbLadder(), TrackerTopology::pxbLayer(), and DetId::rawId().

Referenced by AlignmentPI::topolInfo::fillGeometryInfo().

333  {
334  // Using TrackerTopology
335  // Ladders have a staggered structure
336  // Non-flipped ladders are on the outer radius
337  // Phase 0: Outer ladders are odd for layer 1,3 and even for layer 2
338  // Phase 1: Outer ladders are odd for layer 1,2,3 and even for layer 4
339  bool isOuter = false;
340  int layer = tTopo.pxbLayer(detid.rawId());
341  bool odd_ladder = tTopo.pxbLadder(detid.rawId()) % 2;
342  if (isPhase0) {
343  if (layer == 2)
344  isOuter = !odd_ladder;
345  else
346  isOuter = odd_ladder;
347  } else {
348  if (layer == 4)
349  isOuter = !odd_ladder;
350  else
351  isOuter = odd_ladder;
352  }
353  return isOuter;
354  }
TrackerTopology::pxbLayer
unsigned int pxbLayer(const DetId &id) const
Definition: TrackerTopology.h:144
TrackerTopology::pxbLadder
unsigned int pxbLadder(const DetId &id) const
Definition: TrackerTopology.h:155
pixelTopology::layer
constexpr std::array< uint8_t, layerIndexSize< TrackerTraits > > layer
Definition: SimplePixelTopology.h:90
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57

◆ makeNicePlotStyle()

void AlignmentPI::makeNicePlotStyle ( TH1 *  hist,
int  color 
)
inline

Definition at line 718 of file AlignmentPayloadInspectorHelper.h.

References compareTotals::hist.

720  {
721  hist->SetStats(kFALSE);
722 
723  hist->GetXaxis()->SetTitleColor(color);
724  hist->SetLineColor(color);
725  hist->SetTitleSize(0.08);
726  hist->SetLineWidth(2);
727  hist->GetXaxis()->CenterTitle(true);
728  hist->GetYaxis()->CenterTitle(true);
729  hist->GetXaxis()->SetTitleFont(42);
730  hist->GetYaxis()->SetTitleFont(42);
731  hist->GetXaxis()->SetNdivisions(505);
732  hist->GetXaxis()->SetTitleSize(0.06);
733  hist->GetYaxis()->SetTitleSize(0.06);
734  hist->GetXaxis()->SetTitleOffset(1.0);
735  hist->GetYaxis()->SetTitleOffset(1.3);
736  hist->GetXaxis()->SetLabelFont(42);
737  hist->GetYaxis()->SetLabelFont(42);
738  hist->GetYaxis()->SetLabelSize(.05);
739  hist->GetXaxis()->SetLabelSize(.05);
740  }

◆ makeNiceStats()

void AlignmentPI::makeNiceStats ( TH1F *  hist,
AlignmentPI::partitions  part,
int  color 
)
inline

Definition at line 743 of file AlignmentPayloadInspectorHelper.h.

References funct::abs(), edmScanValgrind::buffer, getStringFromPart(), and compareTotals::hist.

745  {
746  char buffer[255];
747  TPaveText* stat = new TPaveText(0.71, 0.75, 0.95, 0.88, "NDC");
748  sprintf(buffer, "%s \n", AlignmentPI::getStringFromPart(part).c_str());
749  stat->AddText(buffer);
750 
751  sprintf(buffer, "Entries : %i\n", (int)hist->GetEntries());
752  stat->AddText(buffer);
753 
754  if (std::abs(hist->GetMean()) > 0.01) {
755  sprintf(buffer, "Mean : %6.2f\n", hist->GetMean());
756  } else {
757  sprintf(buffer, "Mean : %6.2f e-2\n", 100 * hist->GetMean());
758  }
759  stat->AddText(buffer);
760 
761  if (std::abs(hist->GetRMS()) > 0.01) {
762  sprintf(buffer, "RMS : %6.2f\n", hist->GetRMS());
763  } else {
764  sprintf(buffer, "RMS : %6.2f e-2\n", 100 * hist->GetRMS());
765  }
766  stat->AddText(buffer);
767 
768  stat->SetLineColor(0);
769  stat->SetTextColor(color);
770  stat->SetFillColor(10);
771  stat->SetShadowColor(10);
772  stat->Draw();
773  }
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
part
part
Definition: HCALResponse.h:20
AlignmentPI::getStringFromPart
std::string getStringFromPart(AlignmentPI::partitions i, bool isPhase2=false)
Definition: AlignmentPayloadInspectorHelper.h:674

◆ operator<<()

std::ostream& AlignmentPI::operator<< ( std::ostream &  o,
PARTITION  x 
)
inline

Definition at line 100 of file AlignmentPayloadInspectorHelper.h.

References x.

100  {
101  return o << std::underlying_type<PARTITION>::type(x);
102  }
x
float x
Definition: beamSpotDipStandalone.cc:55

◆ returnZeroIfNear2PI()

double AlignmentPI::returnZeroIfNear2PI ( const double  phi)
inline

Definition at line 40 of file AlignmentPayloadInspectorHelper.h.

References funct::abs(), f, M_PI, and cms_rounding::roundIfNear0().

40  {
41  const double tol = 2.e-7; // default tolerance 1.e-7 doesn't account for possible variations
42  if (cms_rounding::roundIfNear0(std::abs(phi) - 2 * M_PI, tol) == 0.f) {
43  return 0.f;
44  } else {
45  return phi;
46  }
47  }
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
cms_rounding::roundIfNear0
constexpr valType roundIfNear0(valType value, double tolerance=1.e-7)
Definition: Rounding.h:11
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:50

◆ trim2PIs()

double AlignmentPI::trim2PIs ( const double  phi,
const double  tolerance = 1.f 
)
inline

Definition at line 51 of file AlignmentPayloadInspectorHelper.h.

References funct::abs(), M_PI, tolerance, and tomRad.

51  {
52  if (std::abs((std::abs(phi) - 2 * M_PI) * tomRad) < tolerance) {
53  return (std::abs(phi) - 2 * M_PI);
54  } else {
55  return phi;
56  }
57  }
tolerance
const double tolerance
Definition: HGCalGeomParameters.cc:29
AlignmentPI::tomRad
static const float tomRad
Definition: AlignmentPayloadInspectorHelper.h:36
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:50

Variable Documentation

◆ cmToUm

const float AlignmentPI::cmToUm = 10000.f
static

Definition at line 35 of file AlignmentPayloadInspectorHelper.h.

Referenced by fillComparisonHistogram(), and fillComparisonHistograms().

◆ PARTITIONS

const PARTITION AlignmentPI::PARTITIONS
Initial value:
= {PARTITION::BPIX,
PARTITION::FPIXp,
PARTITION::FPIXm,
PARTITION::TIB,
PARTITION::TIDp,
PARTITION::TIDm,
PARTITION::TOB,
PARTITION::TECp,
PARTITION::TECm}
BPIX
#define BPIX
Definition: PixelCalibConfiguration.cc:22

Definition at line 90 of file AlignmentPayloadInspectorHelper.h.

Referenced by AlignmentPI::TkAlBarycenters::computeBarycenters().

◆ phase0size

const unsigned int AlignmentPI::phase0size = 19876
static

Definition at line 33 of file AlignmentPayloadInspectorHelper.h.

◆ phase1size

const unsigned int AlignmentPI::phase1size = 20292
static

Definition at line 34 of file AlignmentPayloadInspectorHelper.h.

◆ tomRad

const float AlignmentPI::tomRad = 1000.f
static

Definition at line 36 of file AlignmentPayloadInspectorHelper.h.

Referenced by fillComparisonHistogram(), fillComparisonHistograms(), and trim2PIs().

Generated for CMSSW Reference Manual by doxygen 1.8.14