File indexing completed on 2024-12-01 23:40:00
0001
0002
0003
0004
0005
0006
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
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
0022 #include "CommonTools/TrackerMap/interface/TrackerMap.h"
0023
0024
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
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
0058
0059
0060
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
0090 fillWithValue(sqrt(errMatrix[indices.first][indices.second]) * AlignmentPI::cmToUm);
0091 }
0092 }
0093 }
0094 return true;
0095 }
0096 };
0097
0098
0099 typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::XX> TrackerAlignmentErrorExtendedXXValue;
0100 typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::YY> TrackerAlignmentErrorExtendedYYValue;
0101 typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::ZZ> TrackerAlignmentErrorExtendedZZValue;
0102
0103
0104 typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::XY> TrackerAlignmentErrorExtendedXYValue;
0105 typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::XZ> TrackerAlignmentErrorExtendedXZValue;
0106 typedef TrackerAlignmentErrorExtendedValue<AlignmentPI::YZ> TrackerAlignmentErrorExtendedYZValue;
0107
0108
0109
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())) {
0180 APE_spectra[AlignmentPI::TIB]->Fill(std::min(200., matrixElement) * AlignmentPI::cmToUm);
0181 }
0182 break;
0183 case 4:
0184 if (!tTopo.tidIsDoubleSide(it.rawId())) {
0185 APE_spectra[AlignmentPI::TID]->Fill(std::min(200., matrixElement) * AlignmentPI::cmToUm);
0186 }
0187 break;
0188 case 5:
0189 if (!tTopo.tobIsDoubleSide(it.rawId())) {
0190 APE_spectra[AlignmentPI::TOB]->Fill(std::min(200., matrixElement) * AlignmentPI::cmToUm);
0191 }
0192 break;
0193 case 6:
0194 if (!tTopo.tecIsDoubleSide(it.rawId())) {
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
0234 typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::XX> TrackerAlignmentErrorExtendedXXSummary;
0235 typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::YY> TrackerAlignmentErrorExtendedYYSummary;
0236 typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::ZZ> TrackerAlignmentErrorExtendedZZSummary;
0237
0238
0239 typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::XY> TrackerAlignmentErrorExtendedXYSummary;
0240 typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::XZ> TrackerAlignmentErrorExtendedXZSummary;
0241 typedef TrackerAlignmentErrorExtendedSummary<AlignmentPI::YZ> TrackerAlignmentErrorExtendedYZSummary;
0242
0243
0244
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
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 }
0294
0295
0296
0297 auto autoRange = tmap->getAutomaticRange();
0298
0299 std::string fileName(m_imageFileName);
0300
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
0315 typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::XX> TrackerAlignmentErrorExtendedXXTrackerMap;
0316 typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::YY> TrackerAlignmentErrorExtendedYYTrackerMap;
0317 typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::ZZ> TrackerAlignmentErrorExtendedZZTrackerMap;
0318
0319
0320 typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::XY> TrackerAlignmentErrorExtendedXYTrackerMap;
0321 typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::XZ> TrackerAlignmentErrorExtendedXZTrackerMap;
0322 typedef TrackerAlignmentErrorExtendedTrackerMap<AlignmentPI::YZ> TrackerAlignmentErrorExtendedYZTrackerMap;
0323
0324
0325
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
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
0396 typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::XX> PixelAlignmentErrorExtendedXXTrackerMap;
0397 typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::YY> PixelAlignmentErrorExtendedYYTrackerMap;
0398 typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::ZZ> PixelAlignmentErrorExtendedZZTrackerMap;
0399
0400
0401 typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::XY> PixelAlignmentErrorExtendedXYTrackerMap;
0402 typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::XZ> PixelAlignmentErrorExtendedXZTrackerMap;
0403 typedef PixelAlignmentErrorExtendedTrackerMap<AlignmentPI::YZ> PixelAlignmentErrorExtendedYZTrackerMap;
0404
0405
0406
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
0437 auto begin = partLimits.at(q).first;
0438 auto end = partLimits.at(q).second;
0439
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
0459
0460 for (int j = begin; j <= end; j++) {
0461 AlignmentPI::regions part = (AlignmentPI::regions)j;
0462
0463
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
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
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
0501
0502 AlignmentPI::regions thePart = t_info_fromXML.filterThePartition();
0503
0504
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 }
0516 }
0517
0518
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
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
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
0545 AlignmentPI::makeNicePlotStyle(summaries[coord].get(), kBlue);
0546 summaries[coord]->GetXaxis()->LabelsOption("v");
0547 summaries[coord]->GetXaxis()->SetLabelSize(0.06);
0548
0549 }
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
0557 summaries[coord]->SetFillColorAlpha(kRed, 0.35);
0558 summaries[coord]->SetMarkerSize(2.5);
0559 summaries[coord]->SetMarkerColor(kRed);
0560
0561
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 }
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
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
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
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
0633 std::string s_coord = AlignmentPI::getStringFromIndex(i);
0634
0635
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
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
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 }
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
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
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 }
0743
0744
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
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
0755
0756 summaryLast->GetXaxis()->SetBinLabel(bin, AlignmentPI::getStringFromRegionEnum(part).c_str());
0757
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
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
0800 summaryLast->Draw("bar2,same");
0801
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");
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 }
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
0834 typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::XX> TrackerAlignmentErrorExtendedXXComparator;
0835 typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::YY> TrackerAlignmentErrorExtendedYYComparator;
0836 typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::ZZ> TrackerAlignmentErrorExtendedZZComparator;
0837
0838
0839 typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::XY> TrackerAlignmentErrorExtendedXYComparator;
0840 typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::XZ> TrackerAlignmentErrorExtendedXZComparator;
0841 typedef TrackerAlignmentErrorExtendedComparator<AlignmentPI::YZ> TrackerAlignmentErrorExtendedYZComparator;
0842
0843
0844 typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::XX>
0845 TrackerAlignmentErrorExtendedXXComparatorTwoTags;
0846 typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::YY>
0847 TrackerAlignmentErrorExtendedYYComparatorTwoTags;
0848 typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::ZZ>
0849 TrackerAlignmentErrorExtendedZZComparatorTwoTags;
0850
0851
0852 typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::XY>
0853 TrackerAlignmentErrorExtendedXYComparatorTwoTags;
0854 typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::XZ>
0855 TrackerAlignmentErrorExtendedXZComparatorTwoTags;
0856 typedef TrackerAlignmentErrorExtendedComparatorTwoTags<AlignmentPI::YZ>
0857 TrackerAlignmentErrorExtendedYZComparatorTwoTags;
0858
0859 }
0860
0861
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 }