AlignmentPlugins/plugins/TrackerAlignmentErrorExtended_PayloadInspector.cc

0001 /*!
0002   \file TrackerAlignmentErrorExtended_PayloadInspector
0003   \Payload Inspector Plugin for Tracker Alignment Errors (APE)
0004   \author M. Musich
0005   \version $Revision: 1.0 $
0006   \date $Date: 2017/07/10 10:59:24 $
0007 */
0008
0009 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0010
0011 #include "CondCore/Utilities/interface/PayloadInspectorModule.h"
0012 #include "CondCore/Utilities/interface/PayloadInspector.h"
0013 #include "CondCore/CondDB/interface/Time.h"
0014
0015 // the data format of the condition to be inspected
0016 #include "CondFormats/Alignment/interface/AlignmentErrorsExtended.h"
0017 #include "DataFormats/DetId/interface/DetId.h"
0018 #include "DataFormats/SiStripDetId/interface/StripSubdetector.h"
0019 #include "DataFormats/DetId/interface/DetId.h"
0020
0021 // needed for the tracker map
0022 #include "CommonTools/TrackerMap/interface/TrackerMap.h"
0023
0024 // needed for mapping
0025 #include "CondCore/AlignmentPlugins/interface/AlignmentPayloadInspectorHelper.h"
0026 #include "CalibTracker/StandaloneTrackerTopology/interface/StandaloneTrackerTopology.h"
0027
0028 #include "DQM/TrackerRemapper/interface/Phase1PixelSummaryMap.h"
0029
0030 #include <memory>
0031 #include <sstream>
0032 #include <iostream>
0033
0034 // include ROOT
0035 #include "TH2F.h"
0036 #include "TLegend.h"
0037 #include "TCanvas.h"
0038 #include "TLine.h"
0039 #include "TStyle.h"
0040 #include "TLatex.h"
0041 #include "TPave.h"
0042 #include "TPaveStats.h"
0043
0044 namespace {
0045
0046   using namespace cond::payloadInspector;
0047
0048   const std::map<AlignmentPI::partitions, std::pair<AlignmentPI::regions, AlignmentPI::regions> > partLimits = {
0049       {AlignmentPI::BPix, std::make_pair(AlignmentPI::BPixL1o, AlignmentPI::BPixL4i)},
0050       {AlignmentPI::FPix, std::make_pair(AlignmentPI::FPixmL1, AlignmentPI::FPixpL3)},
0051       {AlignmentPI::TIB, std::make_pair(AlignmentPI::TIBL1Ro, AlignmentPI::TIBL4i)},
0052       {AlignmentPI::TOB, std::make_pair(AlignmentPI::TOBL1Ro, AlignmentPI::TOBL6i)},
0053       {AlignmentPI::TID, std::make_pair(AlignmentPI::TIDmR1R, AlignmentPI::TIDpR3)},
0054       {AlignmentPI::TEC, std::make_pair(AlignmentPI::TECmR1R, AlignmentPI::TECpR7)}};
0055
0056   /************************************************
0057     1d histogram of sqrt(d_ii) of 1 IOV
0058   *************************************************/
0059
0060   // inherit from one of the predefined plot class: Histogram1D
0061   template <AlignmentPI::index i>
0062   class TrackerAlignmentErrorExtendedValue : public Histogram1D<AlignmentErrorsExtended, SINGLE_IOV> {
0063   public:
0064     TrackerAlignmentErrorExtendedValue()
0065         : Histogram1D<AlignmentErrorsExtended, SINGLE_IOV>(
0066               "TrackerAlignmentErrorExtendedValue",
0067               "TrackerAlignmentErrorExtendedValue sqrt(d_{" + getStringFromIndex(i) + "})",
0068               500,
0069               0.0,
0070               500.0) {}
0071
0072     bool fill() override {
0073       auto tag = PlotBase::getTag<0>();
0074       for (auto const& iov : tag.iovs) {
0075         std::shared_ptr<AlignmentErrorsExtended> payload = Base::fetchPayload(std::get<1>(iov));
0076         if (payload.get()) {
0077           std::vector<AlignTransformErrorExtended> alignErrors = payload->m_alignError;
0078           auto indices = AlignmentPI::getIndices(i);
0079
0080           for (const auto& it : alignErrors) {
0081             CLHEP::HepSymMatrix errMatrix = it.matrix();
0082
0083             if (DetId(it.rawId()).det() != DetId::Tracker) {
0084               edm::LogWarning("TrackerAlignmentErrorExtended_PayloadInspector")
0085                   << "Encountered invalid Tracker DetId:" << it.rawId() << " - terminating ";
0086               return false;
0087             }
0088
0089             // to be used to fill the histogram
0090             fillWithValue(sqrt(errMatrix[indices.first][indices.second]) * AlignmentPI::cmToUm);
0091           }  // loop on the vector of modules
0092         }  // payload
0093       }  // iovs
0094       return true;
0095     }  // fill
0096   };
0097
0098   // diagonal elements
0099   typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::XX> TrackerAlignmentErrorExtendedXXValue;
0100   typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::YY> TrackerAlignmentErrorExtendedYYValue;
0101   typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::ZZ> TrackerAlignmentErrorExtendedZZValue;
0102
0103   // off-diagonal elements
0104   typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::XY> TrackerAlignmentErrorExtendedXYValue;
0105   typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::XZ> TrackerAlignmentErrorExtendedXZValue;
0106   typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::YZ> TrackerAlignmentErrorExtendedYZValue;
0107
0108   // /************************************************
0109   //   Summary spectra of sqrt(d_ii) of 1 IOV
0110   // *************************************************/
0111
0112   template <AlignmentPI::index i>
0113   class TrackerAlignmentErrorExtendedSummary : public PlotImage<AlignmentErrorsExtended, SINGLE_IOV> {
0114   public:
0115     TrackerAlignmentErrorExtendedSummary()
0116         : PlotImage<AlignmentErrorsExtended, SINGLE_IOV>("Summary per Tracker Partition of sqrt(d_{" +
0117                                                          getStringFromIndex(i) + "}) of APE matrix") {}
0118
0119     bool fill() override {
0120       auto tag = PlotBase::getTag<0>();
0121       auto iov = tag.iovs.front();
0122       std::shared_ptr<AlignmentErrorsExtended> payload = fetchPayload(std::get<1>(iov));
0123       std::vector<AlignTransformErrorExtended> alignErrors = payload->m_alignError;
0124
0125       const char* path_toTopologyXML = (alignErrors.size() == AlignmentPI::phase0size)
0126                                            ? "Geometry/TrackerCommonData/data/trackerParameters.xml"
0127                                            : "Geometry/TrackerCommonData/data/PhaseI/trackerParameters.xml";
0128       TrackerTopology tTopo =
0129           StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
0130
0131       auto indices = AlignmentPI::getIndices(i);
0132
0133       TCanvas canvas("Partion summary", "partition summary", 1200, 1000);
0134       canvas.Divide(3, 2);
0135       std::map<AlignmentPI::partitions, int> colormap;
0136       colormap[AlignmentPI::BPix] = kBlue;
0137       colormap[AlignmentPI::FPix] = kBlue + 2;
0138       colormap[AlignmentPI::TIB] = kRed;
0139       colormap[AlignmentPI::TOB] = kRed + 2;
0140       colormap[AlignmentPI::TID] = kRed + 4;
0141       colormap[AlignmentPI::TEC] = kRed + 6;
0142
0143       std::map<AlignmentPI::partitions, std::shared_ptr<TH1F> > APE_spectra;
0144       std::vector<AlignmentPI::partitions> parts = {
0145           AlignmentPI::BPix, AlignmentPI::FPix, AlignmentPI::TIB, AlignmentPI::TID, AlignmentPI::TOB, AlignmentPI::TEC};
0146
0147       auto s_index = getStringFromIndex(i);
0148
0149       for (const auto& part : parts) {
0150         std::string s_part = AlignmentPI::getStringFromPart(part);
0151
0152         APE_spectra[part] =
0153             std::make_shared<TH1F>(Form("hAPE_%s", s_part.c_str()),
0154                                    Form(";%s APE #sqrt{d_{%s}} [#mum];n. of modules", s_part.c_str(), s_index.c_str()),
0155                                    200,
0156                                    -10.,
0157                                    200.);
0158       }
0159
0160       for (const auto& it : alignErrors) {
0161         CLHEP::HepSymMatrix errMatrix = it.matrix();
0162         int subid = DetId(it.rawId()).subdetId();
0163         double matrixElement = sqrt(errMatrix[indices.first][indices.second]);
0164
0165         if (DetId(it.rawId()).det() != DetId::Tracker) {
0166           edm::LogWarning("TrackerAlignmentErrorExtended_PayloadInspector")
0167               << "Encountered invalid Tracker DetId:" << it.rawId() << " - terminating ";
0168           return false;
0169         }
0170
0171         switch (subid) {
0172           case 1:
0173             APE_spectra[AlignmentPI::BPix]->Fill(std::min(200., matrixElement) * AlignmentPI::cmToUm);
0174             break;
0175           case 2:
0176             APE_spectra[AlignmentPI::FPix]->Fill(std::min(200., matrixElement) * AlignmentPI::cmToUm);
0177             break;
0178           case 3:
0179             if (!tTopo.tibIsDoubleSide(it.rawId())) {  // no glued DetIds
0180               APE_spectra[AlignmentPI::TIB]->Fill(std::min(200., matrixElement) * AlignmentPI::cmToUm);
0181             }
0182             break;
0183           case 4:
0184             if (!tTopo.tidIsDoubleSide(it.rawId())) {  // no glued DetIds
0185               APE_spectra[AlignmentPI::TID]->Fill(std::min(200., matrixElement) * AlignmentPI::cmToUm);
0186             }
0187             break;
0188           case 5:
0189             if (!tTopo.tobIsDoubleSide(it.rawId())) {  // no glued DetIds
0190               APE_spectra[AlignmentPI::TOB]->Fill(std::min(200., matrixElement) * AlignmentPI::cmToUm);
0191             }
0192             break;
0193           case 6:
0194             if (!tTopo.tecIsDoubleSide(it.rawId())) {  // no glued DetIds
0195               APE_spectra[AlignmentPI::TEC]->Fill(std::min(200., matrixElement) * AlignmentPI::cmToUm);
0196             }
0197             break;
0198           default:
0199             COUT << "will do nothing" << std::endl;
0200             break;
0201         }
0202       }
0203
0204       TLatex t1;
0205       t1.SetTextAlign(21);
0206       t1.SetTextSize(0.07);
0207       t1.SetTextColor(kBlue);
0208
0209       int c_index = 1;
0210       for (const auto& part : parts) {
0211         canvas.cd(c_index)->SetLogy();
0212         canvas.cd(c_index)->SetTopMargin(0.02);
0213         canvas.cd(c_index)->SetBottomMargin(0.15);
0214         canvas.cd(c_index)->SetLeftMargin(0.14);
0215         canvas.cd(c_index)->SetRightMargin(0.04);
0216         APE_spectra[part]->SetLineWidth(2);
0217         AlignmentPI::makeNicePlotStyle(APE_spectra[part].get(), colormap[part]);
0218         APE_spectra[part]->Draw("HIST");
0219         AlignmentPI::makeNiceStats(APE_spectra[part].get(), part, colormap[part]);
0220
0221         t1.DrawLatexNDC(0.35, 0.92, ("IOV: " + std::to_string(std::get<0>(iov))).c_str());
0222
0223         c_index++;
0224       }
0225
0226       std::string fileName(m_imageFileName);
0227       canvas.SaveAs(fileName.c_str());
0228
0229       return true;
0230     }
0231   };
0232
0233   // diagonal elements
0234   typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::XX> TrackerAlignmentErrorExtendedXXSummary;
0235   typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::YY> TrackerAlignmentErrorExtendedYYSummary;
0236   typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::ZZ> TrackerAlignmentErrorExtendedZZSummary;
0237
0238   // off-diagonal elements
0239   typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::XY> TrackerAlignmentErrorExtendedXYSummary;
0240   typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::XZ> TrackerAlignmentErrorExtendedXZSummary;
0241   typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::YZ> TrackerAlignmentErrorExtendedYZSummary;
0242
0243   // /************************************************
0244   //   TrackerMap of sqrt(d_ii) of 1 IOV
0245   // *************************************************/
0246   template <AlignmentPI::index i>
0247   class TrackerAlignmentErrorExtendedTrackerMap : public PlotImage<AlignmentErrorsExtended, SINGLE_IOV> {
0248   public:
0249     TrackerAlignmentErrorExtendedTrackerMap()
0250         : PlotImage<AlignmentErrorsExtended, SINGLE_IOV>("Tracker Map of sqrt(d_{" + getStringFromIndex(i) +
0251                                                          "}) of APE matrix") {}
0252
0253     bool fill() override {
0254       auto tag = PlotBase::getTag<0>();
0255       auto iov = tag.iovs.front();
0256       std::shared_ptr<AlignmentErrorsExtended> payload = fetchPayload(std::get<1>(iov));
0257
0258       std::string titleMap = "APE #sqrt{d_{" + getStringFromIndex(i) + "}} value (payload : " + std::get<1>(iov) + ")";
0259
0260       std::unique_ptr<TrackerMap> tmap = std::make_unique<TrackerMap>("APE_dii");
0261       tmap->setTitle(titleMap);
0262       tmap->setPalette(1);
0263
0264       std::vector<AlignTransformErrorExtended> alignErrors = payload->m_alignError;
0265
0266       auto indices = AlignmentPI::getIndices(i);
0267
0268       bool isPhase0(false);
0269       if (alignErrors.size() == AlignmentPI::phase0size)
0270         isPhase0 = true;
0271
0272       for (const auto& it : alignErrors) {
0273         CLHEP::HepSymMatrix errMatrix = it.matrix();
0274
0275         // fill the tracker map
0276
0277         int subid = DetId(it.rawId()).subdetId();
0278
0279         if (DetId(it.rawId()).det() != DetId::Tracker) {
0280           edm::LogWarning("TrackerAlignmentErrorExtended_PayloadInspector")
0281               << "Encountered invalid Tracker DetId:" << it.rawId() << " - terminating ";
0282           return false;
0283         }
0284
0285         if (isPhase0) {
0286           tmap->addPixel(true);
0287           tmap->fill(it.rawId(), sqrt(errMatrix[indices.first][indices.second]) * AlignmentPI::cmToUm);
0288         } else {
0289           if (subid != 1 && subid != 2) {
0290             tmap->fill(it.rawId(), sqrt(errMatrix[indices.first][indices.second]) * AlignmentPI::cmToUm);
0291           }
0292         }
0293       }  // loop over detIds
0294
0295       //=========================
0296
0297       auto autoRange = tmap->getAutomaticRange();
0298
0299       std::string fileName(m_imageFileName);
0300       // protect against uniform values (APE are defined positive)
0301       if (autoRange.first != autoRange.second) {
0302         tmap->save(true, 0., autoRange.second, fileName);
0303       } else {
0304         if (autoRange.first != 0.)
0305           tmap->save(true, 0., autoRange.first * 1.05, fileName);
0306         else
0307           tmap->save(true, 0., 1., fileName);
0308       }
0309
0310       return true;
0311     }
0312   };
0313
0314   // diagonal elements
0315   typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::XX> TrackerAlignmentErrorExtendedXXTrackerMap;
0316   typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::YY> TrackerAlignmentErrorExtendedYYTrackerMap;
0317   typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::ZZ> TrackerAlignmentErrorExtendedZZTrackerMap;
0318
0319   // off-diagonal elements
0320   typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::XY> TrackerAlignmentErrorExtendedXYTrackerMap;
0321   typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::XZ> TrackerAlignmentErrorExtendedXZTrackerMap;
0322   typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::YZ> TrackerAlignmentErrorExtendedYZTrackerMap;
0323
0324   // /************************************************
0325   //   TrackerMap of sqrt(d_ii) of 1 IOV
0326   // *************************************************/
0327   template <AlignmentPI::index i>
0328   class PixelAlignmentErrorExtendedTrackerMap : public PlotImage<AlignmentErrorsExtended, SINGLE_IOV> {
0329   public:
0330     PixelAlignmentErrorExtendedTrackerMap()
0331         : PlotImage<AlignmentErrorsExtended, SINGLE_IOV>("Pixel Map of sqrt(d_{" + getStringFromIndex(i) +
0332                                                          "}) of APE matrix") {
0333       label_ = " PixelAlignmentErrorExtendedTrackerMap";
0334       payloadString = "Alignment Parameter Error";
0335     }
0336
0337     bool fill() override {
0338       auto tag = PlotBase::getTag<0>();
0339       auto iov = tag.iovs.front();
0340       std::string IOVsince = std::to_string(std::get<0>(iov));
0341
0342       std::shared_ptr<AlignmentErrorsExtended> payload = fetchPayload(std::get<1>(iov));
0343
0344       Phase1PixelSummaryMap fullMap("", fmt::sprintf("%s", payloadString), fmt::sprintf("%s [#mum]", payloadString));
0345       fullMap.createTrackerBaseMap();
0346
0347       std::vector<AlignTransformErrorExtended> alignErrors = payload->m_alignError;
0348
0349       auto indices = AlignmentPI::getIndices(i);
0350
0351       TCanvas canvas("Canv", "Canv", 3000, 2000);
0352       if (alignErrors.size() == AlignmentPI::phase0size) {
0353         AlignmentPI::displayNotSupported(canvas, 0);
0354         return false;
0355       }
0356
0357       for (const auto& it : alignErrors) {
0358         int subid = DetId(it.rawId()).subdetId();
0359
0360         CLHEP::HepSymMatrix errMatrix = it.matrix();
0361
0362         if (DetId(it.rawId()).det() != DetId::Tracker) {
0363           edm::LogWarning("TrackerAlignmentErrorExtended_PayloadInspector")
0364               << "Encountered invalid Tracker DetId:" << it.rawId() << " - terminating ";
0365           return false;
0366         }
0367         // fill the tracker map only if it's pixel
0368         if ((subid == PixelSubdetector::PixelBarrel) || (subid == PixelSubdetector::PixelEndcap)) {
0369           fullMap.fillTrackerMap(it.rawId(), sqrt(errMatrix[indices.first][indices.second]) * AlignmentPI::cmToUm);
0370         }
0371       }
0372
0373       fullMap.printTrackerMap(canvas);
0374
0375       auto ltx = TLatex();
0376       ltx.SetTextFont(62);
0377       ltx.SetTextSize(0.025);
0378       ltx.SetTextAlign(11);
0379
0380       ltx.DrawLatexNDC(gPad->GetLeftMargin() + 0.01,
0381                        gPad->GetBottomMargin() + 0.01,
0382                        ("#color[4]{" + std::string{tag.name} + "}, IOV: #color[2]{" + IOVsince + "}").c_str());
0383
0384       std::string fileName(this->m_imageFileName);
0385       canvas.SaveAs(fileName.c_str());
0386
0387       return true;
0388     }
0389
0390   protected:
0391     std::string payloadString;
0392     std::string label_;
0393   };
0394
0395   // diagonal elements
0396   typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::XX> PixelAlignmentErrorExtendedXXTrackerMap;
0397   typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::YY> PixelAlignmentErrorExtendedYYTrackerMap;
0398   typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::ZZ> PixelAlignmentErrorExtendedZZTrackerMap;
0399
0400   // off-diagonal elements
0401   typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::XY> PixelAlignmentErrorExtendedXYTrackerMap;
0402   typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::XZ> PixelAlignmentErrorExtendedXZTrackerMap;
0403   typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::YZ> PixelAlignmentErrorExtendedYZTrackerMap;
0404
0405   // /************************************************
0406   //  Partition details of 1 IOV
0407   // *************************************************/
0408   template <AlignmentPI::partitions q>
0409   class TrackerAlignmentErrorExtendedDetail : public PlotImage<AlignmentErrorsExtended, SINGLE_IOV> {
0410   public:
0411     TrackerAlignmentErrorExtendedDetail()
0412         : PlotImage<AlignmentErrorsExtended, SINGLE_IOV>("Details for " + AlignmentPI::getStringFromPart(q)) {}
0413
0414     bool fill() override {
0415       auto tag = PlotBase::getTag<0>();
0416       auto iov = tag.iovs.front();
0417
0418       gStyle->SetPaintTextFormat(".1f");
0419       std::shared_ptr<AlignmentErrorsExtended> payload = fetchPayload(std::get<1>(iov));
0420
0421       std::vector<AlignTransformErrorExtended> alignErrors = payload->m_alignError;
0422
0423       const char* path_toTopologyXML = (alignErrors.size() == AlignmentPI::phase0size)
0424                                            ? "Geometry/TrackerCommonData/data/trackerParameters.xml"
0425                                            : "Geometry/TrackerCommonData/data/PhaseI/trackerParameters.xml";
0426       TrackerTopology tTopo =
0427           StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
0428
0429       bool isPhase0(false);
0430       if (alignErrors.size() == AlignmentPI::phase0size)
0431         isPhase0 = true;
0432
0433       TCanvas canvas("Summary", "Summary", 1600, 1200);
0434       canvas.Divide(3, 2);
0435
0436       // define the paritions range to act upon
0437       auto begin = partLimits.at(q).first;
0438       auto end = partLimits.at(q).second;
0439       // dinamically defined range
0440       auto range = (end - begin) + 1;
0441
0442       std::map<std::pair<AlignmentPI::index, AlignmentPI::regions>, std::shared_ptr<TH1F> > APE_spectraByRegion;
0443       std::map<AlignmentPI::index, std::shared_ptr<TH1F> > summaries;
0444
0445       for (int k = AlignmentPI::XX; k <= AlignmentPI::ZZ; k++) {
0446         AlignmentPI::index coord = (AlignmentPI::index)k;
0447         std::string s_coord = AlignmentPI::getStringFromIndex(coord);
0448
0449         summaries[coord] = std::make_shared<TH1F>(
0450             Form("Summary_%s", s_coord.c_str()),
0451             Form("Summary for #LT #sqrt{d_{%s}} #GT APE;;average APE #LT #sqrt{d_{%s}} #GT [#mum]",
0452                  s_coord.c_str(),
0453                  s_coord.c_str()),
0454             range,
0455             0,
0456             range);
0457
0458         //COUT<<"begin ( "<< begin << "): " << AlignmentPI::getStringFromRegionEnum(begin) << " end ( " << end << "): " <<  AlignmentPI::getStringFromRegionEnum(end) <<" | range = "<< range << std::endl;
0459
0460         for (int j = begin; j <= end; j++) {
0461           AlignmentPI::regions part = (AlignmentPI::regions)j;
0462
0463           // dont' book region that don't exist
0464           if (isPhase0 && (part == AlignmentPI::BPixL4o || part == AlignmentPI::BPixL4i ||
0465                            part == AlignmentPI::FPixmL3 || part == AlignmentPI::FPixpL3))
0466             continue;
0467
0468           std::string s_part = AlignmentPI::getStringFromRegionEnum(part);
0469
0470           auto hash = std::make_pair(coord, part);
0471
0472           APE_spectraByRegion[hash] = std::make_shared<TH1F>(
0473               Form("hAPE_%s_%s", s_coord.c_str(), s_part.c_str()),
0474               Form(";%s APE #sqrt{d_{%s}} [#mum];n. of modules", s_part.c_str(), s_coord.c_str()),
0475               1000,
0476               0.,
0477               1000.);
0478         }
0479       }
0480
0481       // loop on the vector of errors
0482       for (const auto& it : alignErrors) {
0483         CLHEP::HepSymMatrix errMatrix = it.matrix();
0484
0485         if (DetId(it.rawId()).det() != DetId::Tracker) {
0486           edm::LogWarning("TrackerAlignmentErrorExtended_PayloadInspector")
0487               << "Encountered invalid Tracker DetId:" << it.rawId() << " - terminating ";
0488           return false;
0489         }
0490
0491         int subid = DetId(it.rawId()).subdetId();
0492         if (subid != q)
0493           continue;
0494
0495         // fill the struct
0496         AlignmentPI::topolInfo t_info_fromXML;
0497         t_info_fromXML.init();
0498         DetId detid(it.rawId());
0499         t_info_fromXML.fillGeometryInfo(detid, tTopo, isPhase0);
0500         //t_info_fromXML.printAll();
0501
0502         AlignmentPI::regions thePart = t_info_fromXML.filterThePartition();
0503
0504         // skip the glued detector detIds
0505         if (thePart == AlignmentPI::StripDoubleSide)
0506           continue;
0507
0508         for (int k = AlignmentPI::XX; k <= AlignmentPI::ZZ; k++) {
0509           AlignmentPI::index coord = (AlignmentPI::index)k;
0510           auto indices = AlignmentPI::getIndices(coord);
0511           auto hash = std::make_pair(coord, thePart);
0512
0513           APE_spectraByRegion[hash]->Fill(sqrt(errMatrix[indices.first][indices.second]) * AlignmentPI::cmToUm);
0514
0515         }  // loop on the coordinate indices
0516       }  // loop over detIds
0517
0518       // plotting section
0519
0520       TLegend legend = TLegend(0.15, 0.85, 0.99, 0.92);
0521       legend.AddEntry(summaries[AlignmentPI::XX].get(),
0522                       ("#splitline{IOV: " + std::to_string(std::get<0>(iov)) + "}{" + std::get<1>(iov) + "}").c_str(),
0523                       "F");
0524       legend.SetTextSize(0.030);
0525
0526       for (int k = AlignmentPI::XX; k <= AlignmentPI::ZZ; k++) {
0527         AlignmentPI::index coord = (AlignmentPI::index)k;
0528
0529         for (int j = begin; j <= end; j++) {
0530           AlignmentPI::regions part = (AlignmentPI::regions)j;
0531
0532           // don't fill regions that do not exist
0533           if (isPhase0 && (part == AlignmentPI::BPixL4o || part == AlignmentPI::BPixL4i ||
0534                            part == AlignmentPI::FPixmL3 || part == AlignmentPI::FPixpL3))
0535             continue;
0536
0537           auto hash = std::make_pair(coord, part);
0538           summaries[coord]->GetXaxis()->SetBinLabel((j - begin) + 1,
0539                                                     AlignmentPI::getStringFromRegionEnum(part).c_str());
0540
0541           // avoid filling the histogram with numerical noise
0542           float mean = APE_spectraByRegion[hash]->GetMean() > 10.e-6 ? APE_spectraByRegion[hash]->GetMean() : 10.e-6;
0543           summaries[coord]->SetBinContent((j - begin) + 1, mean);
0544           //summaries[coord]->SetBinError((j-begin)+1,APE_spectraByRegion[hash]->GetRMS());
0545           AlignmentPI::makeNicePlotStyle(summaries[coord].get(), kBlue);
0546           summaries[coord]->GetXaxis()->LabelsOption("v");
0547           summaries[coord]->GetXaxis()->SetLabelSize(0.06);
0548
0549         }  // loop over the detector regions
0550
0551         canvas.cd(k);
0552         canvas.cd(k)->SetTopMargin(0.08);
0553         canvas.cd(k)->SetBottomMargin(0.15);
0554         canvas.cd(k)->SetLeftMargin(0.15);
0555         canvas.cd(k)->SetRightMargin(0.01);
0556         //summaries[coord]->SetTitleOffset(0.06);
0557         summaries[coord]->SetFillColorAlpha(kRed, 0.35);
0558         summaries[coord]->SetMarkerSize(2.5);
0559         summaries[coord]->SetMarkerColor(kRed);
0560
0561         // to ensure 0. is actually displayed as 0.
0562         summaries[coord]->GetYaxis()->SetRangeUser(0., std::max(1., summaries[coord]->GetMaximum() * 1.50));
0563         summaries[coord]->Draw("text90");
0564         summaries[coord]->Draw("HISTsame");
0565
0566         legend.Draw("same");
0567
0568       }  // loop over the matrix elements
0569
0570       std::string fileName(m_imageFileName);
0571       canvas.SaveAs(fileName.c_str());
0572
0573       return true;
0574     }
0575   };
0576
0577   typedef TrackerAlignmentErrorExtendedDetail<AlignmentPI::BPix> TrackerAlignmentErrorExtendedBPixDetail;
0578   typedef TrackerAlignmentErrorExtendedDetail<AlignmentPI::FPix> TrackerAlignmentErrorExtendedFPixDetail;
0579   typedef TrackerAlignmentErrorExtendedDetail<AlignmentPI::TIB> TrackerAlignmentErrorExtendedTIBDetail;
0580   typedef TrackerAlignmentErrorExtendedDetail<AlignmentPI::TOB> TrackerAlignmentErrorExtendedTOBDetail;
0581   typedef TrackerAlignmentErrorExtendedDetail<AlignmentPI::TID> TrackerAlignmentErrorExtendedTIDDetail;
0582   typedef TrackerAlignmentErrorExtendedDetail<AlignmentPI::TEC> TrackerAlignmentErrorExtendedTECDetail;
0583
0584   // /************************************************
0585   //  Tracker Aligment Extended Errors grand summary comparison of 2 IOVs
0586   // *************************************************/
0587
0588   template <AlignmentPI::index i, int ntags, IOVMultiplicity nIOVs>
0589   class TrackerAlignmentErrorExtendedComparatorBase : public PlotImage<AlignmentErrorsExtended, nIOVs, ntags> {
0590   public:
0591     TrackerAlignmentErrorExtendedComparatorBase()
0592         : PlotImage<AlignmentErrorsExtended, nIOVs, ntags>("Summary per Tracker region of sqrt(d_{" +
0593                                                            getStringFromIndex(i) + "}) of APE matrix") {}
0594
0595     bool fill() override {
0596       // trick to deal with the multi-ioved tag and two tag case at the same time
0597       auto theIOVs = PlotBase::getTag<0>().iovs;
0598       auto tagname1 = PlotBase::getTag<0>().name;
0599       std::string tagname2 = "";
0600       auto firstiov = theIOVs.front();
0601       std::tuple<cond::Time_t, cond::Hash> lastiov;
0602
0603       // we don't support (yet) comparison with more than 2 tags
0604       assert(this->m_plotAnnotations.ntags < 3);
0605
0606       if (this->m_plotAnnotations.ntags == 2) {
0607         auto tag2iovs = PlotBase::getTag<1>().iovs;
0608         tagname2 = PlotBase::getTag<1>().name;
0609         lastiov = tag2iovs.front();
0610       } else {
0611         lastiov = theIOVs.back();
0612       }
0613
0614       gStyle->SetPaintTextFormat(".1f");
0615
0616       std::shared_ptr<AlignmentErrorsExtended> last_payload = this->fetchPayload(std::get<1>(lastiov));
0617       std::shared_ptr<AlignmentErrorsExtended> first_payload = this->fetchPayload(std::get<1>(firstiov));
0618
0619       std::vector<AlignTransformErrorExtended> f_alignErrors = first_payload->m_alignError;
0620       std::vector<AlignTransformErrorExtended> l_alignErrors = last_payload->m_alignError;
0621
0622       std::string lastIOVsince = std::to_string(std::get<0>(lastiov));
0623       std::string firstIOVsince = std::to_string(std::get<0>(firstiov));
0624
0625       TCanvas canvas("Comparison", "Comparison", 1600, 800);
0626
0627       std::map<AlignmentPI::regions, std::shared_ptr<TH1F> > FirstAPE_spectraByRegion;
0628       std::map<AlignmentPI::regions, std::shared_ptr<TH1F> > LastAPE_spectraByRegion;
0629       std::shared_ptr<TH1F> summaryFirst;
0630       std::shared_ptr<TH1F> summaryLast;
0631
0632       // get the name of the index
0633       std::string s_coord = AlignmentPI::getStringFromIndex(i);
0634
0635       // book the intermediate histograms
0636       for (int r = AlignmentPI::BPixL1o; r != AlignmentPI::StripDoubleSide; r++) {
0637         AlignmentPI::regions part = static_cast<AlignmentPI::regions>(r);
0638         std::string s_part = AlignmentPI::getStringFromRegionEnum(part);
0639
0640         FirstAPE_spectraByRegion[part] =
0641             std::make_shared<TH1F>(Form("hfirstAPE_%s_%s", s_coord.c_str(), s_part.c_str()),
0642                                    Form(";%s APE #sqrt{d_{%s}} [#mum];n. of modules", s_part.c_str(), s_coord.c_str()),
0643                                    1000,
0644                                    0.,
0645                                    1000.);
0646         LastAPE_spectraByRegion[part] =
0647             std::make_shared<TH1F>(Form("hlastAPE_%s_%s", s_coord.c_str(), s_part.c_str()),
0648                                    Form(";%s APE #sqrt{d_{%s}} [#mum];n. of modules", s_part.c_str(), s_coord.c_str()),
0649                                    1000,
0650                                    0.,
0651                                    1000.);
0652       }
0653
0654       summaryFirst =
0655           std::make_shared<TH1F>(Form("first Summary_%s", s_coord.c_str()),
0656                                  Form("Summary for #LT #sqrt{d_{%s}} #GT APE;;average APE #LT #sqrt{d_{%s}} #GT [#mum]",
0657                                       s_coord.c_str(),
0658                                       s_coord.c_str()),
0659                                  FirstAPE_spectraByRegion.size(),
0660                                  0,
0661                                  FirstAPE_spectraByRegion.size());
0662       summaryLast =
0663           std::make_shared<TH1F>(Form("last Summary_%s", s_coord.c_str()),
0664                                  Form("Summary for #LT #sqrt{d_{%s}} #GT APE;;average APE #LT #sqrt{d_{%s}} #GT [#mum]",
0665                                       s_coord.c_str(),
0666                                       s_coord.c_str()),
0667                                  LastAPE_spectraByRegion.size(),
0668                                  0,
0669                                  LastAPE_spectraByRegion.size());
0670
0671       const char* path_toTopologyXML = (f_alignErrors.size() == AlignmentPI::phase0size)
0672                                            ? "Geometry/TrackerCommonData/data/trackerParameters.xml"
0673                                            : "Geometry/TrackerCommonData/data/PhaseI/trackerParameters.xml";
0674       TrackerTopology f_tTopo =
0675           StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
0676
0677       bool isPhase0(false);
0678       if (f_alignErrors.size() == AlignmentPI::phase0size)
0679         isPhase0 = true;
0680
0681       // -------------------------------------------------------------------
0682       // loop on the first vector of errors
0683       // -------------------------------------------------------------------
0684       for (const auto& it : f_alignErrors) {
0685         CLHEP::HepSymMatrix errMatrix = it.matrix();
0686
0687         if (DetId(it.rawId()).det() != DetId::Tracker) {
0688           edm::LogWarning("TrackerAlignmentErrorExtended_PayloadInspector")
0689               << "Encountered invalid Tracker DetId:" << it.rawId() << " - terminating ";
0690           return false;
0691         }
0692
0693         AlignmentPI::topolInfo t_info_fromXML;
0694         t_info_fromXML.init();
0695         DetId detid(it.rawId());
0696         t_info_fromXML.fillGeometryInfo(detid, f_tTopo, isPhase0);
0697
0698         AlignmentPI::regions thePart = t_info_fromXML.filterThePartition();
0699
0700         // skip the glued detector detIds
0701         if (thePart == AlignmentPI::StripDoubleSide)
0702           continue;
0703
0704         auto indices = AlignmentPI::getIndices(i);
0705         FirstAPE_spectraByRegion[thePart]->Fill(sqrt(errMatrix[indices.first][indices.second]) * AlignmentPI::cmToUm);
0706       }  // ends loop on the vector of error transforms
0707
0708       path_toTopologyXML = (l_alignErrors.size() == AlignmentPI::phase0size)
0709                                ? "Geometry/TrackerCommonData/data/trackerParameters.xml"
0710                                : "Geometry/TrackerCommonData/data/PhaseI/trackerParameters.xml";
0711       TrackerTopology l_tTopo =
0712           StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
0713
0714       if (l_alignErrors.size() == AlignmentPI::phase0size)
0715         isPhase0 = true;
0716
0717       // -------------------------------------------------------------------
0718       // loop on the second vector of errors
0719       // -------------------------------------------------------------------
0720       for (const auto& it : l_alignErrors) {
0721         CLHEP::HepSymMatrix errMatrix = it.matrix();
0722
0723         if (DetId(it.rawId()).det() != DetId::Tracker) {
0724           edm::LogWarning("TrackerAlignmentErrorExtended_PayloadInspector")
0725               << "Encountered invalid Tracker DetId:" << it.rawId() << " - terminating ";
0726           return false;
0727         }
0728
0729         AlignmentPI::topolInfo t_info_fromXML;
0730         t_info_fromXML.init();
0731         DetId detid(it.rawId());
0732         t_info_fromXML.fillGeometryInfo(detid, l_tTopo, isPhase0);
0733
0734         AlignmentPI::regions thePart = t_info_fromXML.filterThePartition();
0735
0736         // skip the glued detector detIds
0737         if (thePart == AlignmentPI::StripDoubleSide)
0738           continue;
0739
0740         auto indices = AlignmentPI::getIndices(i);
0741         LastAPE_spectraByRegion[thePart]->Fill(sqrt(errMatrix[indices.first][indices.second]) * AlignmentPI::cmToUm);
0742       }  // ends loop on the vector of error transforms
0743
0744       // fill the summary plots
0745       int bin = 1;
0746       for (int r = AlignmentPI::BPixL1o; r != AlignmentPI::StripDoubleSide; r++) {
0747         AlignmentPI::regions part = static_cast<AlignmentPI::regions>(r);
0748
0749         summaryFirst->GetXaxis()->SetBinLabel(bin, AlignmentPI::getStringFromRegionEnum(part).c_str());
0750         // avoid filling the histogram with numerical noise
0751         float f_mean =
0752             FirstAPE_spectraByRegion[part]->GetMean() > 10.e-6 ? FirstAPE_spectraByRegion[part]->GetMean() : 10.e-6;
0753         summaryFirst->SetBinContent(bin, f_mean);
0754         //summaryFirst->SetBinError(bin,APE_spectraByRegion[hash]->GetRMS());
0755
0756         summaryLast->GetXaxis()->SetBinLabel(bin, AlignmentPI::getStringFromRegionEnum(part).c_str());
0757         // avoid filling the histogram with numerical noise
0758         float l_mean =
0759             LastAPE_spectraByRegion[part]->GetMean() > 10.e-6 ? LastAPE_spectraByRegion[part]->GetMean() : 10.e-6;
0760         summaryLast->SetBinContent(bin, l_mean);
0761         //summaryLast->SetBinError(bin,APE_spectraByRegion[hash]->GetRMS());
0762         bin++;
0763       }
0764
0765       AlignmentPI::makeNicePlotStyle(summaryFirst.get(), kBlue);
0766       summaryFirst->SetMarkerColor(kBlue);
0767       summaryFirst->GetXaxis()->LabelsOption("v");
0768       summaryFirst->GetXaxis()->SetLabelSize(0.05);
0769       summaryFirst->GetYaxis()->SetTitleOffset(0.9);
0770
0771       AlignmentPI::makeNicePlotStyle(summaryLast.get(), kRed);
0772       summaryLast->SetMarkerColor(kRed);
0773       summaryLast->GetYaxis()->SetTitleOffset(0.9);
0774       summaryLast->GetXaxis()->LabelsOption("v");
0775       summaryLast->GetXaxis()->SetLabelSize(0.05);
0776
0777       canvas.cd()->SetGridy();
0778
0779       canvas.SetBottomMargin(0.18);
0780       canvas.SetLeftMargin(0.11);
0781       canvas.SetRightMargin(0.02);
0782       canvas.Modified();
0783
0784       summaryFirst->SetFillColor(kBlue);
0785       summaryLast->SetFillColor(kRed);
0786
0787       summaryFirst->SetBarWidth(0.45);
0788       summaryFirst->SetBarOffset(0.1);
0789
0790       summaryLast->SetBarWidth(0.4);
0791       summaryLast->SetBarOffset(0.55);
0792
0793       float max = (summaryFirst->GetMaximum() > summaryLast->GetMaximum()) ? summaryFirst->GetMaximum()
0794                                                                            : summaryLast->GetMaximum();
0795
0796       summaryFirst->GetYaxis()->SetRangeUser(0., std::max(0., max * 1.20));
0797
0798       summaryFirst->Draw("bar2");
0799       //summaryFirst->Draw("text90same");
0800       summaryLast->Draw("bar2,same");
0801       //summaryLast->Draw("text180same");
0802
0803       TLegend legend = TLegend(0.52, 0.82, 0.98, 0.9);
0804       legend.SetHeader((getStringFromIndex(i) + " APE value comparison").c_str(),
0805                        "C");  // option "C" allows to center the header
0806       legend.AddEntry(
0807           summaryLast.get(),
0808           ("IOV: #scale[1.2]{" + std::to_string(std::get<0>(lastiov)) + "} | #color[2]{" + std::get<1>(lastiov) + "}")
0809               .c_str(),
0810           "F");
0811       legend.AddEntry(
0812           summaryFirst.get(),
0813           ("IOV: #scale[1.2]{" + std::to_string(std::get<0>(firstiov)) + "} | #color[4]{" + std::get<1>(firstiov) + "}")
0814               .c_str(),
0815           "F");
0816       legend.SetTextSize(0.025);
0817       legend.Draw("same");
0818
0819       std::string fileName(this->m_imageFileName);
0820       canvas.SaveAs(fileName.c_str());
0821
0822       return true;
0823
0824     }  // ends fill method
0825   };
0826
0827   template <AlignmentPI::index i>
0828   using TrackerAlignmentErrorExtendedComparator = TrackerAlignmentErrorExtendedComparatorBase<i, 1, MULTI_IOV>;
0829
0830   template <AlignmentPI::index i>
0831   using TrackerAlignmentErrorExtendedComparatorTwoTags = TrackerAlignmentErrorExtendedComparatorBase<i, 2, SINGLE_IOV>;
0832
0833   // diagonal elements
0834   typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::XX> TrackerAlignmentErrorExtendedXXComparator;
0835   typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::YY> TrackerAlignmentErrorExtendedYYComparator;
0836   typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::ZZ> TrackerAlignmentErrorExtendedZZComparator;
0837
0838   // off-diagonal elements
0839   typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::XY> TrackerAlignmentErrorExtendedXYComparator;
0840   typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::XZ> TrackerAlignmentErrorExtendedXZComparator;
0841   typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::YZ> TrackerAlignmentErrorExtendedYZComparator;
0842
0843   // diagonal elements
0844   typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::XX>
0845       TrackerAlignmentErrorExtendedXXComparatorTwoTags;
0846   typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::YY>
0847       TrackerAlignmentErrorExtendedYYComparatorTwoTags;
0848   typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::ZZ>
0849       TrackerAlignmentErrorExtendedZZComparatorTwoTags;
0850
0851   // off-diagonal elements
0852   typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::XY>
0853       TrackerAlignmentErrorExtendedXYComparatorTwoTags;
0854   typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::XZ>
0855       TrackerAlignmentErrorExtendedXZComparatorTwoTags;
0856   typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::YZ>
0857       TrackerAlignmentErrorExtendedYZComparatorTwoTags;
0858
0859 }  // namespace
0860
0861 // Register the classes as boost python plugin
0862 PAYLOAD_INSPECTOR_MODULE(TrackerAlignmentErrorExtended) {
0863   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXXValue);
0864   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedYYValue);
0865   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedZZValue);
0866   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXYValue);
0867   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXZValue);
0868   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedYZValue);
0869   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXXSummary);
0870   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedYYSummary);
0871   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedZZSummary);
0872   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXYSummary);
0873   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXZSummary);
0874   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedYZSummary);
0875   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXXTrackerMap);
0876   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedYYTrackerMap);
0877   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedZZTrackerMap);
0878   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXYTrackerMap);
0879   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXZTrackerMap);
0880   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedYZTrackerMap);
0881   PAYLOAD_INSPECTOR_CLASS(PixelAlignmentErrorExtendedXXTrackerMap);
0882   PAYLOAD_INSPECTOR_CLASS(PixelAlignmentErrorExtendedYYTrackerMap);
0883   PAYLOAD_INSPECTOR_CLASS(PixelAlignmentErrorExtendedZZTrackerMap);
0884   PAYLOAD_INSPECTOR_CLASS(PixelAlignmentErrorExtendedXYTrackerMap);
0885   PAYLOAD_INSPECTOR_CLASS(PixelAlignmentErrorExtendedXZTrackerMap);
0886   PAYLOAD_INSPECTOR_CLASS(PixelAlignmentErrorExtendedYZTrackerMap);
0887   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedBPixDetail);
0888   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedFPixDetail);
0889   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedTIBDetail);
0890   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedTOBDetail);
0891   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedTIDDetail);
0892   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedTECDetail);
0893   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXXComparator);
0894   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedYYComparator);
0895   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedZZComparator);
0896   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXYComparator);
0897   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXZComparator);
0898   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedYZComparator);
0899   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXXComparatorTwoTags);
0900   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedYYComparatorTwoTags);
0901   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedZZComparatorTwoTags);
0902   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXYComparatorTwoTags);
0903   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedXZComparatorTwoTags);
0904   PAYLOAD_INSPECTOR_CLASS(TrackerAlignmentErrorExtendedYZComparatorTwoTags);
0905 }