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::vector< int > &boundaries, const std::vector< AlignTransform > &ref_ali, const std::vector< AlignTransform > &target_ali, std::unique_ptr< TH1F > &compare)
void	fillComparisonHistograms (std::vector< int > &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)
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 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 58 of file AlignmentPayloadInspectorHelper.h.

                  {
    t_x = 1,
    t_y = 2,
    t_z = 3,
    rot_alpha = 4,
    rot_beta = 5,
    rot_gamma = 6,
  };

index

enum AlignmentPI::index

Enumerator
XX
XY
XZ
YZ
YY
ZZ

Definition at line 71 of file AlignmentPayloadInspectorHelper.h.

{ 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 75 of file AlignmentPayloadInspectorHelper.h.

                       {
    BPIX,   // 0 Barrel Pixel
    FPIXp,  // 1 Forward Pixel Plus
    FPIXm,  // 2 Forward Pixel Minus
    TIB,    // 3 Tracker Inner Barrel
    TIDp,   // 4 Tracker Inner Disks Plus
    TIDm,   // 5 Tracker Inner Disks Minus
    TOB,    // 6 Tracker Outer Barrel
    TECp,   // 7 Tracker Endcaps Plus
    TECm,   // 8 Tracker Endcaps Minus
    LAST = TECm
  };

partitions

enum AlignmentPI::partitions

Enumerator
INVALID
BPix
FPix
TIB
TID
TOB
TEC

Definition at line 73 of file AlignmentPayloadInspectorHelper.h.

{ 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 103 of file AlignmentPayloadInspectorHelper.h.

               {
    BPixL1o,          //0  Barrel Pixel Layer 1 outer
    BPixL1i,          //1  Barrel Pixel Layer 1 inner
    BPixL2o,          //2  Barrel Pixel Layer 2 outer
    BPixL2i,          //3  Barrel Pixel Layer 2 inner
    BPixL3o,          //4  Barrel Pixel Layer 3 outer
    BPixL3i,          //5  Barrel Pixel Layer 3 inner
    BPixL4o,          //6  Barrel Pixel Layer 4 outer
    BPixL4i,          //7  Barrel Pixel Layer 4 inner
    FPixmL1,          //8  Forward Pixel Minus side Disk 1
    FPixmL2,          //9 Forward Pixel Minus side Disk 2
    FPixmL3,          //10 Forward Pixel Minus side Disk 3
    FPixpL1,          //11 Forward Pixel Plus side Disk 1
    FPixpL2,          //12 Forward Pixel Plus side Disk 2
    FPixpL3,          //13 Forward Pixel Plus side Disk 3
    TIBL1Ro,          //14 Inner Barrel Layer 1 Rphi outer
    TIBL1Ri,          //15 Inner Barrel Layer 1 Rphi inner
    TIBL1So,          //16 Inner Barrel Layer 1 Stereo outer
    TIBL1Si,          //17 Inner Barrel Layer 1 Stereo inner
    TIBL2Ro,          //18 Inner Barrel Layer 2 Rphi outer
    TIBL2Ri,          //19 Inner Barrel Layer 2 Rphi inner
    TIBL2So,          //20 Inner Barrel Layer 2 Stereo outer
    TIBL2Si,          //21 Inner Barrel Layer 2 Stereo inner
    TIBL3o,           //22 Inner Barrel Layer 3 outer
    TIBL3i,           //23 Inner Barrel Layer 3 inner
    TIBL4o,           //24 Inner Barrel Layer 4 outer
    TIBL4i,           //25 Inner Barrel Layer 4 inner
    TOBL1Ro,          //26 Outer Barrel Layer 1 Rphi outer
    TOBL1Ri,          //27 Outer Barrel Layer 1 Rphi inner
    TOBL1So,          //28 Outer Barrel Layer 1 Stereo outer
    TOBL1Si,          //29 Outer Barrel Layer 1 Stereo inner
    TOBL2Ro,          //30 Outer Barrel Layer 2 Rphi outer
    TOBL2Ri,          //31 Outer Barrel Layer 2 Rphi inner
    TOBL2So,          //32 Outer Barrel Layer 2 Stereo outer
    TOBL2Si,          //33 Outer Barrel Layer 2 Stereo inner
    TOBL3o,           //34 Outer Barrel Layer 3 outer
    TOBL3i,           //35 Outer Barrel Layer 3 inner
    TOBL4o,           //36 Outer Barrel Layer 4 outer
    TOBL4i,           //37 Outer Barrel Layer 4 inner
    TOBL5o,           //38 Outer Barrel Layer 5 outer
    TOBL5i,           //39 Outer Barrel Layer 5 inner
    TOBL6o,           //40 Outer Barrel Layer 6 outer
    TOBL6i,           //41 Outer Barrel Layer 6 inner
    TIDmR1R,          //42 Inner Disk Minus side Ring 1 Rphi
    TIDmR1S,          //43 Inner Disk Minus side Ring 1 Stereo
    TIDmR2R,          //44 Inner Disk Minus side Ring 2 Rphi
    TIDmR2S,          //45 Inner Disk Minus side Ring 2 Stereo
    TIDmR3,           //46 Inner Disk Minus side Ring 3
    TIDpR1R,          //47 Inner Disk Plus side Ring 1 Rphi
    TIDpR1S,          //48 Inner Disk Plus side Ring 1 Stereo
    TIDpR2R,          //49 Inner Disk Plus side Ring 2 Rphi
    TIDpR2S,          //50 Inner Disk Plus side Ring 2 Stereo
    TIDpR3,           //51 Inner Disk Plus side Ring 3
    TECmR1R,          //52 Endcaps Minus side Ring 1 Rphi
    TECmR1S,          //53 Endcaps Minus side Ring 1 Stereo
    TECmR2R,          //54 Encdaps Minus side Ring 2 Rphi
    TECmR2S,          //55 Endcaps Minus side Ring 2 Stereo
    TECmR3,           //56 Endcaps Minus side Ring 3
    TECmR4,           //57 Endcaps Minus side Ring 4
    TECmR5,           //58 Endcaps Minus side Ring 5
    TECmR6,           //59 Endcaps Minus side Ring 6
    TECmR7,           //60 Endcaps Minus side Ring 7
    TECpR1R,          //61 Endcaps Plus side Ring 1 Rphi
    TECpR1S,          //62 Endcaps Plus side Ring 1 Stereo
    TECpR2R,          //63 Encdaps Plus side Ring 2 Rphi
    TECpR2S,          //64 Endcaps Plus side Ring 2 Stereo
    TECpR3,           //65 Endcaps Plus side Ring 3
    TECpR4,           //66 Endcaps Plus side Ring 4
    TECpR5,           //67 Endcaps Plus side Ring 5
    TECpR6,           //68 Endcaps Plus side Ring 6
    TECpR7,           //67 Endcaps Plus side Ring 7
    StripDoubleSide,  // 70 -- not to be considered
    NUM_OF_REGIONS    // 71 -- default
  };

Function Documentation

calculatePosition()

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

inline

Definition at line 800 of file AlignmentPayloadInspectorHelper.h.

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

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

  {
    int ix1;
    int ix2;
    int iw = myPad->GetWw();
    int ih = myPad->GetWh();
    double x1p, y1p, x2p, y2p;
    myPad->GetPadPar(x1p, y1p, x2p, y2p);
    ix1 = (int)(iw * x1p);
    ix2 = (int)(iw * x2p);
    double wndc = std::min(1., (double)iw / (double)ih);
    double rw = wndc / (double)iw;
    double x1ndc = (double)ix1 * rw;
    double x2ndc = (double)ix2 * rw;
    double rx1, ry1, rx2, ry2;
    myPad->GetRange(rx1, ry1, rx2, ry2);
    double rx = (x2ndc - x1ndc) / (rx2 - rx1);
    double _sx;
    _sx = rx * (boundary - rx1) + x1ndc;
    double _dx = _sx + 0.05;

    return std::make_pair(_sx, _dx);
  }

fillComparisonHistogram()

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

inline

Definition at line 1000 of file AlignmentPayloadInspectorHelper.h.

References BPix, cmToUm, 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.

  {
    int counter = 0; /* start the counter */
    AlignmentPI::partitions currentPart = AlignmentPI::BPix;
    for (unsigned int i = 0; i < ref_ali.size(); i++) {
      if (ref_ali[i].rawId() == target_ali[i].rawId()) {
        counter++;
        int subid = DetId(ref_ali[i].rawId()).subdetId();

        auto thePart = static_cast<AlignmentPI::partitions>(subid);
        if (thePart != currentPart) {
          currentPart = thePart;
          boundaries.push_back(counter);
        }

        CLHEP::HepRotation target_rot(target_ali[i].rotation());
        CLHEP::HepRotation ref_rot(ref_ali[i].rotation());

        align::RotationType target_ROT(target_rot.xx(),
                                       target_rot.xy(),
                                       target_rot.xz(),
                                       target_rot.yx(),
                                       target_rot.yy(),
                                       target_rot.yz(),
                                       target_rot.zx(),
                                       target_rot.zy(),
                                       target_rot.zz());

        align::RotationType ref_ROT(ref_rot.xx(),
                                    ref_rot.xy(),
                                    ref_rot.xz(),
                                    ref_rot.yx(),
                                    ref_rot.yy(),
                                    ref_rot.yz(),
                                    ref_rot.zx(),
                                    ref_rot.zy(),
                                    ref_rot.zz());

        const std::vector<double> deltaRot = {::deltaPhi(align::toAngles(target_ROT)[0], align::toAngles(ref_ROT)[0]),
                                              ::deltaPhi(align::toAngles(target_ROT)[1], align::toAngles(ref_ROT)[1]),
                                              ::deltaPhi(align::toAngles(target_ROT)[2], align::toAngles(ref_ROT)[2])};

        const auto& deltaTrans = target_ali[i].translation() - ref_ali[i].translation();

        switch (coord) {
          case AlignmentPI::t_x:
            compare->SetBinContent(i + 1, deltaTrans.x() * AlignmentPI::cmToUm);
            break;
          case AlignmentPI::t_y:
            compare->SetBinContent(i + 1, deltaTrans.y() * AlignmentPI::cmToUm);
            break;
          case AlignmentPI::t_z:
            compare->SetBinContent(i + 1, deltaTrans.z() * AlignmentPI::cmToUm);
            break;
          case AlignmentPI::rot_alpha:
            compare->SetBinContent(i + 1, deltaRot[0] * AlignmentPI::tomRad);
            break;
          case AlignmentPI::rot_beta:
            compare->SetBinContent(i + 1, deltaRot[1] * AlignmentPI::tomRad);
            break;
          case AlignmentPI::rot_gamma:
            compare->SetBinContent(i + 1, deltaRot[2] * AlignmentPI::tomRad);
            break;
          default:
            edm::LogError("TrackerAlignment_PayloadInspector") << "Unrecognized coordinate " << coord << std::endl;
            break;
        }  // switch on the coordinate
      }    // check on the same detID
    }      // loop on the components
  }

fillComparisonHistograms()

void AlignmentPI::fillComparisonHistograms ( std::vector< int > &  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 1077 of file AlignmentPayloadInspectorHelper.h.

References BPix, cmToUm, 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.

  {
    int counter = 0; /* start the counter */
    AlignmentPI::partitions currentPart = AlignmentPI::BPix;
    for (unsigned int i = 0; i < ref_ali.size(); i++) {
      if (ref_ali[i].rawId() == target_ali[i].rawId()) {
        counter++;
        int subid = DetId(ref_ali[i].rawId()).subdetId();

        auto thePart = static_cast<AlignmentPI::partitions>(subid);

        // in case it has to be filtered
        if (checkPart > 0 && thePart != checkPart) {
          continue;
        }

        if (thePart != currentPart) {
          currentPart = thePart;
          boundaries.push_back(counter);
        }

        CLHEP::HepRotation target_rot(target_ali[i].rotation());
        CLHEP::HepRotation ref_rot(ref_ali[i].rotation());

        align::RotationType target_ROT(target_rot.xx(),
                                       target_rot.xy(),
                                       target_rot.xz(),
                                       target_rot.yx(),
                                       target_rot.yy(),
                                       target_rot.yz(),
                                       target_rot.zx(),
                                       target_rot.zy(),
                                       target_rot.zz());

        align::RotationType ref_ROT(ref_rot.xx(),
                                    ref_rot.xy(),
                                    ref_rot.xz(),
                                    ref_rot.yx(),
                                    ref_rot.yy(),
                                    ref_rot.yz(),
                                    ref_rot.zx(),
                                    ref_rot.zy(),
                                    ref_rot.zz());

        const std::vector<double> deltaRot = {::deltaPhi(align::toAngles(target_ROT)[0], align::toAngles(ref_ROT)[0]),
                                              ::deltaPhi(align::toAngles(target_ROT)[1], align::toAngles(ref_ROT)[1]),
                                              ::deltaPhi(align::toAngles(target_ROT)[2], align::toAngles(ref_ROT)[2])};

        const auto& deltaTrans = target_ali[i].translation() - ref_ali[i].translation();

        // fill the histograms
        if (diff) {
          compare[AlignmentPI::t_x]->Fill(deltaTrans.x() * AlignmentPI::cmToUm);
          compare[AlignmentPI::t_y]->Fill(deltaTrans.y() * AlignmentPI::cmToUm);
          compare[AlignmentPI::t_z]->Fill(deltaTrans.z() * AlignmentPI::cmToUm);

          compare[AlignmentPI::rot_alpha]->Fill(deltaRot[0] * AlignmentPI::tomRad);
          compare[AlignmentPI::rot_beta]->Fill(deltaRot[1] * AlignmentPI::tomRad);
          compare[AlignmentPI::rot_gamma]->Fill(deltaRot[2] * AlignmentPI::tomRad);
        } else {
          compare[AlignmentPI::t_x]->SetBinContent(i + 1, deltaTrans.x() * AlignmentPI::cmToUm);
          compare[AlignmentPI::t_y]->SetBinContent(i + 1, deltaTrans.y() * AlignmentPI::cmToUm);
          compare[AlignmentPI::t_z]->SetBinContent(i + 1, deltaTrans.z() * AlignmentPI::cmToUm);

          compare[AlignmentPI::rot_alpha]->SetBinContent(i + 1, deltaRot[0] * AlignmentPI::tomRad);
          compare[AlignmentPI::rot_beta]->SetBinContent(i + 1, deltaRot[1] * AlignmentPI::tomRad);
          compare[AlignmentPI::rot_gamma]->SetBinContent(i + 1, deltaRot[2] * AlignmentPI::tomRad);
        }

      }  // if it's the same detid
    }    // loop on detids
  }

getIndices()

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

inline

Definition at line 695 of file AlignmentPayloadInspectorHelper.h.

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

  {
    switch (i) {
      case XX:
        return std::make_pair(0, 0);
      case XY:
        return std::make_pair(0, 1);
      case XZ:
        return std::make_pair(0, 2);
      case YZ:
        return std::make_pair(1, 0);
      case YY:
        return std::make_pair(1, 1);
      case ZZ:
        return std::make_pair(2, 2);
      default:
        return std::make_pair(-1, -1);
    }
  }

getStringFromCoordinate()

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

inline

Definition at line 629 of file AlignmentPayloadInspectorHelper.h.

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

  {
    switch (coord) {
      case t_x:
        return "x-translation";
      case t_y:
        return "y-translation";
      case t_z:
        return "z-translation";
      case rot_alpha:
        return "#alpha angle rotation";
      case rot_beta:
        return "#beta angle rotation";
      case rot_gamma:
        return "#gamma angle rotation";
      default:
        return "should never be here!";
    }
  }

getStringFromIndex()

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

inline

Definition at line 651 of file AlignmentPayloadInspectorHelper.h.

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

  {
    switch (i) {
      case XX:
        return "XX";
      case XY:
        return "XY";
      case XZ:
        return "XZ";
      case YZ:
        return "YX";
      case YY:
        return "YY";
      case ZZ:
        return "ZZ";
      default:
        return "should never be here!";
    }
  }

getStringFromPart()

std::string AlignmentPI::getStringFromPart ( AlignmentPI::partitions  i )

inline

Definition at line 673 of file AlignmentPayloadInspectorHelper.h.

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

Referenced by makeNiceStats().

  {
    switch (i) {
      case BPix:
        return "BPix";
      case FPix:
        return "FPix";
      case TIB:
        return "TIB";
      case TID:
        return "TID";
      case TOB:
        return "TOB";
      case TEC:
        return "TEC";
      default:
        return "should never be here!";
    }
  }

getStringFromRegionEnum()

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

inline

Definition at line 179 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.

  {
    switch (e) {
      case AlignmentPI::BPixL1o:
        return "BPixL1o";
      case AlignmentPI::BPixL1i:
        return "BPixL1i";
      case AlignmentPI::BPixL2o:
        return "BPixL2o";
      case AlignmentPI::BPixL2i:
        return "BPixL2i";
      case AlignmentPI::BPixL3o:
        return "BPixL3o";
      case AlignmentPI::BPixL3i:
        return "BPixL3i";
      case AlignmentPI::BPixL4o:
        return "BPixL4o";
      case AlignmentPI::BPixL4i:
        return "BPixL4i";
      case AlignmentPI::FPixmL1:
        return "FPixmL1";
      case AlignmentPI::FPixmL2:
        return "FPixmL2";
      case AlignmentPI::FPixmL3:
        return "FPixmL3";
      case AlignmentPI::FPixpL1:
        return "FPixpL1";
      case AlignmentPI::FPixpL2:
        return "FPixpL2";
      case AlignmentPI::FPixpL3:
        return "FPixpL3";
      case AlignmentPI::TIBL1Ro:
        return "TIBL1Ro";
      case AlignmentPI::TIBL1Ri:
        return "TIBL1Ri";
      case AlignmentPI::TIBL1So:
        return "TIBL1So";
      case AlignmentPI::TIBL1Si:
        return "TIBL1Si";
      case AlignmentPI::TIBL2Ro:
        return "TIBL2Ro";
      case AlignmentPI::TIBL2Ri:
        return "TIBL2Ri";
      case AlignmentPI::TIBL2So:
        return "TIBL2So";
      case AlignmentPI::TIBL2Si:
        return "TIBL2Si";
      case AlignmentPI::TIBL3o:
        return "TIBL3o";
      case AlignmentPI::TIBL3i:
        return "TIBL3i";
      case AlignmentPI::TIBL4o:
        return "TIBL4o";
      case AlignmentPI::TIBL4i:
        return "TIBL4i";
      case AlignmentPI::TOBL1Ro:
        return "TOBL1Ro";
      case AlignmentPI::TOBL1Ri:
        return "TOBL1Ri";
      case AlignmentPI::TOBL1So:
        return "TOBL1So";
      case AlignmentPI::TOBL1Si:
        return "TOBL1Si";
      case AlignmentPI::TOBL2Ro:
        return "TOBL2Ro";
      case AlignmentPI::TOBL2Ri:
        return "TOBL2Ri";
      case AlignmentPI::TOBL2So:
        return "TOBL2So";
      case AlignmentPI::TOBL2Si:
        return "TOBL2Si";
      case AlignmentPI::TOBL3o:
        return "TOBL3o";
      case AlignmentPI::TOBL3i:
        return "TOBL3i";
      case AlignmentPI::TOBL4o:
        return "TOBL4o";
      case AlignmentPI::TOBL4i:
        return "TOBL4i";
      case AlignmentPI::TOBL5o:
        return "TOBL5o";
      case AlignmentPI::TOBL5i:
        return "TOBL5i";
      case AlignmentPI::TOBL6o:
        return "TOBL6o";
      case AlignmentPI::TOBL6i:
        return "TOBL6i";
      case AlignmentPI::TIDmR1R:
        return "TIDmR1R";
      case AlignmentPI::TIDmR1S:
        return "TIDmR1S";
      case AlignmentPI::TIDmR2R:
        return "TIDmR2R";
      case AlignmentPI::TIDmR2S:
        return "TIDmR2S";
      case AlignmentPI::TIDmR3:
        return "TIDmR3";
      case AlignmentPI::TIDpR1R:
        return "TIDpR1R";
      case AlignmentPI::TIDpR1S:
        return "TIDpR1S";
      case AlignmentPI::TIDpR2R:
        return "TIDpR2R";
      case AlignmentPI::TIDpR2S:
        return "TIDpR2S";
      case AlignmentPI::TIDpR3:
        return "TIDpR3";
      case AlignmentPI::TECmR1R:
        return "TECmR1R";
      case AlignmentPI::TECmR1S:
        return "TECmR1S";
      case AlignmentPI::TECmR2R:
        return "TECmR2R";
      case AlignmentPI::TECmR2S:
        return "TECmR2S";
      case AlignmentPI::TECmR3:
        return "TECmR3";
      case AlignmentPI::TECmR4:
        return "TECmR4";
      case AlignmentPI::TECmR5:
        return "TECmR5";
      case AlignmentPI::TECmR6:
        return "TECmR6";
      case AlignmentPI::TECmR7:
        return "TECmR7";
      case AlignmentPI::TECpR1R:
        return "TECpR1R";
      case AlignmentPI::TECpR1S:
        return "TECpR1S";
      case AlignmentPI::TECpR2R:
        return "TECpR2R";
      case AlignmentPI::TECpR2S:
        return "TECpR2S";
      case AlignmentPI::TECpR3:
        return "TECpR3";
      case AlignmentPI::TECpR4:
        return "TECpR4";
      case AlignmentPI::TECpR5:
        return "TECpR5";
      case AlignmentPI::TECpR6:
        return "TECpR6";
      case AlignmentPI::TECpR7:
        return "TECpR7";
      default:
        edm::LogWarning("LogicError") << "Unknown partition: " << e;
        return "";
    }
  }

getTheRange()

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

inline

Definition at line 775 of file AlignmentPayloadInspectorHelper.h.

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

  {
    float sum = std::accumulate(
        std::begin(values), std::end(values), 0.0, [](float value, const std::map<uint32_t, float>::value_type& p) {
          return value + p.second;
        });

    float m = sum / values.size();

    float accum = 0.0;
    std::for_each(std::begin(values), std::end(values), [&](const std::map<uint32_t, float>::value_type& p) {
      accum += (p.second - m) * (p.second - m);
    });

    float stdev = sqrt(accum / (values.size() - 1));

    if (stdev != 0.) {
      return std::make_pair(m - nsigma * stdev, m + nsigma * stdev);
    } else {
      return std::make_pair(m > 0. ? 0.95 * m : 1.05 * m, m > 0 ? 1.05 * m : 0.95 * m);
    }
  }

isBPixOuterLadder()

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

inline

Definition at line 330 of file AlignmentPayloadInspectorHelper.h.

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

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

  {
    // Using TrackerTopology
    // Ladders have a staggered structure
    // Non-flipped ladders are on the outer radius
    // Phase 0: Outer ladders are odd for layer 1,3 and even for layer 2
    // Phase 1: Outer ladders are odd for layer 1,2,3 and even for layer 4
    bool isOuter = false;
    int layer = tTopo.pxbLayer(detid.rawId());
    bool odd_ladder = tTopo.pxbLadder(detid.rawId()) % 2;
    if (isPhase0) {
      if (layer == 2)
        isOuter = !odd_ladder;
      else
        isOuter = odd_ladder;
    } else {
      if (layer == 4)
        isOuter = !odd_ladder;
      else
        isOuter = odd_ladder;
    }
    return isOuter;
  }

makeNicePlotStyle()

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

inline

Definition at line 717 of file AlignmentPayloadInspectorHelper.h.

References gpuVertexFinder::hist.

  {
    hist->SetStats(kFALSE);

    hist->GetXaxis()->SetTitleColor(color);
    hist->SetLineColor(color);
    hist->SetTitleSize(0.08);
    hist->SetLineWidth(2);
    hist->GetXaxis()->CenterTitle(true);
    hist->GetYaxis()->CenterTitle(true);
    hist->GetXaxis()->SetTitleFont(42);
    hist->GetYaxis()->SetTitleFont(42);
    hist->GetXaxis()->SetNdivisions(505);
    hist->GetXaxis()->SetTitleSize(0.06);
    hist->GetYaxis()->SetTitleSize(0.06);
    hist->GetXaxis()->SetTitleOffset(1.0);
    hist->GetYaxis()->SetTitleOffset(1.3);
    hist->GetXaxis()->SetLabelFont(42);
    hist->GetYaxis()->SetLabelFont(42);
    hist->GetYaxis()->SetLabelSize(.05);
    hist->GetXaxis()->SetLabelSize(.05);
  }

makeNiceStats()

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

inline

Definition at line 742 of file AlignmentPayloadInspectorHelper.h.

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

  {
    char buffer[255];
    TPaveText* stat = new TPaveText(0.60, 0.75, 0.95, 0.95, "NDC");
    sprintf(buffer, "%s \n", AlignmentPI::getStringFromPart(part).c_str());
    stat->AddText(buffer);

    sprintf(buffer, "Entries : %i\n", (int)hist->GetEntries());
    stat->AddText(buffer);

    if (std::abs(hist->GetMean()) > 0.01) {
      sprintf(buffer, "Mean    : %6.2f\n", hist->GetMean());
    } else {
      sprintf(buffer, "Mean    : %6.2f e-2\n", 100 * hist->GetMean());
    }
    stat->AddText(buffer);

    if (std::abs(hist->GetRMS()) > 0.01) {
      sprintf(buffer, "RMS     : %6.2f\n", hist->GetRMS());
    } else {
      sprintf(buffer, "RMS     : %6.2f e-2\n", 100 * hist->GetRMS());
    }
    stat->AddText(buffer);

    stat->SetLineColor(color);
    stat->SetTextColor(color);
    stat->SetFillColor(10);
    stat->SetShadowColor(10);
    stat->Draw();
  }

operator<<()

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

inline

Definition at line 99 of file AlignmentPayloadInspectorHelper.h.

References x.

                                                            {
    return o << std::underlying_type<PARTITION>::type(x);
  }

returnZeroIfNear2PI()

double AlignmentPI::returnZeroIfNear2PI ( const double  phi )

inline

Definition at line 39 of file AlignmentPayloadInspectorHelper.h.

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

                                                      {
    const double tol = 2.e-7;  // default tolerance 1.e-7 doesn't account for possible variations
    if (cms_rounding::roundIfNear0(std::abs(phi) - 2 * M_PI, tol) == 0.f) {
      return 0.f;
    } else {
      return phi;
    }
  }

trim2PIs()

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

inline

Definition at line 50 of file AlignmentPayloadInspectorHelper.h.

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

                                                                         {
    if (std::abs((std::abs(phi) - 2 * M_PI) * tomRad) < tolerance) {
      return (std::abs(phi) - 2 * M_PI);
    } else {
      return phi;
    }
  }

Variable Documentation

cmToUm

const float AlignmentPI::cmToUm = 10000.f

static

Definition at line 34 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}

Definition at line 89 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.

tomRad

const float AlignmentPI::tomRad = 1000.f

static

Definition at line 35 of file AlignmentPayloadInspectorHelper.h.

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