File indexing completed on 2024-04-06 11:56:31
0001
0002
0003
0004
0005 #include "CompareMillePede.h"
0006 #include "PlotMillePede.h"
0007 #include "GFUtils/GFHistManager.h"
0008
0009 #include <TTree.h>
0010 #include <TString.h>
0011 #include <TError.h>
0012 #include <TH1.h>
0013 #include <TH2.h>
0014 #include <TLine.h>
0015
0016 #include <iostream>
0017 const unsigned int CompareMillePede::kNpar = MillePedeTrees::kNpar;
0018
0019
0020 CompareMillePede::CompareMillePede(const char *fileName1, const char *fileName2,
0021 Int_t iov1, Int_t iov2, Int_t hieraLevel) :
0022 fPlotMp1(new PlotMillePede(fileName1, iov1, hieraLevel, "first")),
0023 fPlotMp2(new PlotMillePede(fileName2, iov2, hieraLevel, "second")),
0024 fHistManager(new GFHistManager)
0025 {
0026 fHistManager->SetLegendX1Y1X2Y2(0.14, 0.7, 0.45, 0.9);
0027
0028 TTree *tree1 = fPlotMp1->GetMainTree();
0029 TTree *tree2 = fPlotMp2->GetMainTree();
0030 if (!tree1 || !tree2) {
0031 ::Error("CompareMillePede", "Stop here: Previous problems...");
0032 } else if (tree1->GetEntries() != tree2->GetEntries()) {
0033
0034 ::Error("CompareMillePede", "Stop here: %lld alignables in tree1, %lld in tree2.",
0035 tree1->GetEntries(), tree2->GetEntries());
0036 } else {
0037 tree1->AddFriend(tree2);
0038 if (!this->IsConsistent()) {
0039 ::Error("CompareMillePede", "Alignables in inconsistent order.");
0040 }
0041 }
0042 }
0043
0044
0045 CompareMillePede::~CompareMillePede()
0046 {
0047 delete fHistManager;
0048 delete fPlotMp1;
0049 delete fPlotMp2;
0050 }
0051
0052
0053 void CompareMillePede::DrawPedeParam(Option_t *option, unsigned int nNonRigidParam)
0054 {
0055
0056 const TString opt(option);
0057
0058 const Int_t layer = this->PrepareAdd(opt.Contains("add", TString::kIgnoreCase));
0059 const bool lineVs = opt.Contains("line", TString::kIgnoreCase);
0060
0061 const TString titleAdd = this->TitleAdd();
0062
0063 const PlotMillePede *m = fPlotMp1;
0064 UInt_t nPlot = 0;
0065 for (UInt_t iPar = 0; iPar < kNpar + nNonRigidParam; ++iPar) {
0066 TString sel("");
0067 this->AddIsFreeSel(sel, opt, iPar);
0068 fPlotMp1->AddBasicSelection(sel);
0069 fPlotMp2->AddBasicSelection(sel);
0070
0071 const TString pedePar1(fPlotMp1->MpT() += m->Par(iPar));
0072 const TString pedePar2(fPlotMp2->MpT() += m->Par(iPar));
0073 const TString deltaPedePar(m->Parenth(pedePar2 + m->Min() += pedePar1)
0074 += m->ToMumMuRadPede(iPar));
0075 const TString deltaName(m->Unique(Form("deltaPedePar%d", iPar)));
0076 TH1 *h = fPlotMp1->CreateHist(deltaPedePar, sel, deltaName);
0077 if (0. == h->GetEntries()) {
0078 delete h;
0079 continue;
0080 }
0081
0082 const TString name2D(m->Unique(Form("pedePar2D%d", iPar)));
0083 TH2 *hVs = fPlotMp1->CreateHist2D(pedePar1 + m->ToMumMuRadPede(iPar),
0084 pedePar2 + m->ToMumMuRadPede(iPar), sel, name2D, "BOX");
0085
0086 const TString diff(Form("%s_{2}-%s_{1}", m->NamePede(iPar).Data(), m->NamePede(iPar).Data()));
0087 h->SetTitle(diff + titleAdd + ";" + diff + m->UnitPede(iPar) +=";#parameters");
0088
0089 hVs->SetTitle(m->NamePede(iPar).Data() + titleAdd
0090 + Form(";%s_{1}", m->NamePede(iPar).Data()) + m->UnitPede(iPar)
0091 += Form(";%s_{2}", m->NamePede(iPar).Data()) + m->UnitPede(iPar));
0092 fHistManager->AddHist(h, layer);
0093 fHistManager->AddHist(hVs, layer+1);
0094
0095 if (lineVs) {
0096 const Double_t xMin = hVs->GetXaxis()->GetXmin();
0097 const Double_t xMax = hVs->GetXaxis()->GetXmax();
0098 TLine *line = new TLine(xMin, xMin, xMax, xMax);
0099 line->SetLineColor(kRed); line->SetLineWidth(2);
0100 fHistManager->AddObject(line, layer + 1, iPar);
0101 }
0102
0103 ++nPlot;
0104 }
0105
0106 fHistManager->Draw();
0107 }
0108
0109
0110 void CompareMillePede::DrawPedeParamVsLocation(Option_t *option, unsigned int nNonRigidParam)
0111 {
0112
0113 ::Warning("CompareMillePede::DrawPedeParamVsLocation",
0114 "Not yet fully adjusted to possible bows");
0115 const TString opt(option);
0116 const Int_t layer = this->PrepareAdd(opt.Contains("add", TString::kIgnoreCase));
0117 const TString titleAdd = this->TitleAdd();
0118
0119 const PlotMillePede *m = fPlotMp1;
0120 UInt_t nPlot = 0;
0121 for (UInt_t iPar = 0; iPar < kNpar + nNonRigidParam; ++iPar) {
0122 TString sel("");
0123 this->AddIsFreeSel(sel, opt, iPar);
0124 fPlotMp1->AddBasicSelection(sel);
0125 fPlotMp2->AddBasicSelection(sel);
0126
0127 const TString deltaPedePar(m->Parenth(fPlotMp2->MpT() += m->Par(iPar) += m->Min()
0128 += fPlotMp1->MpT() += m->Par(iPar))
0129 += m->ToMumMuRadPede(iPar));
0130
0131 const TString deltaNameR(fPlotMp1->Unique(Form("deltaPedePar%dR", iPar)));
0132 TH2 *hDr = fPlotMp1->CreateHist2D(fPlotMp1->RPos(fPlotMp1->OrgPosT()), deltaPedePar, sel,
0133 deltaNameR, "BOX");
0134 if (0. == hDr->GetEntries()) {
0135 delete hDr;
0136 continue;
0137 }
0138
0139 const TString deltaNamePhi(fPlotMp1->Unique(Form("deltaPedePar%dPhi", iPar)));
0140 TH2 *hDphi = fPlotMp1->CreateHist2D(fPlotMp1->Phi(fPlotMp1->OrgPosT()), deltaPedePar, sel,
0141 deltaNamePhi, "BOX");
0142 const TString deltaNameZ(fPlotMp1->Unique(Form("deltaPedePar%dZ", iPar)));
0143 TH2 *hDz = fPlotMp1->CreateHist2D(fPlotMp1->OrgPosT() += fPlotMp1->ZPos(), deltaPedePar, sel,
0144 deltaNameZ, "BOX");
0145
0146 const TString deltaNameH(fPlotMp1->Unique(Form("deltaPedePar%dH", iPar)));
0147 TH2 *hDhit = fPlotMp1->CreateHist2D(fPlotMp1->HitsX(), deltaPedePar, sel, deltaNameH, "BOX");
0148
0149
0150
0151
0152
0153
0154
0155
0156
0157
0158
0159
0160
0161
0162
0163
0164
0165
0166
0167
0168
0169
0170
0171
0172
0173
0174
0175
0176
0177 const TString diff(Form("%s_{2}-%s_{1}", m->NamePede(iPar).Data(), m->NamePede(iPar).Data()));
0178
0179 hDr->SetTitle(m->DelName(iPar) += " vs r" + titleAdd + ";r[cm];" + diff + ' ' + m->UnitPede(iPar));
0180 hDphi->SetTitle(m->DelName(iPar) += " vs #phi" + titleAdd + ";#phi;" + diff + ' '
0181 + m->Unit(iPar));
0182 hDz->SetTitle(m->DelName(iPar) += " vs z" + titleAdd + ";z[cm];" + diff + ' ' + m->UnitPede(iPar));
0183 hDhit->SetTitle(m->DelName(iPar) += " vs #hits" + titleAdd + ";#hits_{x};" + diff + ' '
0184 + m->UnitPede(iPar));
0185
0186 fHistManager->AddHist(hDr, layer + nPlot);
0187 fHistManager->AddHist(hDphi, layer + nPlot);
0188 fHistManager->AddHist(hDz, layer + nPlot);
0189 fHistManager->AddHist(hDhit, layer + nPlot);
0190
0191
0192
0193
0194
0195
0196
0197
0198
0199
0200
0201
0202
0203
0204
0205
0206
0207
0208
0209
0210
0211
0212
0213
0214
0215
0216 ++nPlot;
0217 }
0218
0219 const bool oldDiffStyle = fHistManager->DrawDiffStyle(false);
0220 fHistManager->Draw();
0221 fHistManager->DrawDiffStyle(oldDiffStyle);
0222 }
0223
0224
0225 void CompareMillePede::DrawParam(Option_t *option)
0226 {
0227
0228 const TString opt(option);
0229
0230 const Int_t layer = this->PrepareAdd(opt.Contains("add", TString::kIgnoreCase));
0231 const TString titleAdd = this->TitleAdd();
0232
0233 const PlotMillePede *m = fPlotMp1;
0234 UInt_t nPlot = 0;
0235 for (UInt_t iPar = 0; iPar < kNpar; ++iPar) {
0236 TString sel("");
0237 this->AddIsFreeSel(sel, opt, iPar);
0238 fPlotMp1->AddBasicSelection(sel);
0239 fPlotMp2->AddBasicSelection(sel);
0240
0241 const TString deltaPar(m->Parenth(this->DeltaPar(iPar)) += m->ToMumMuRad(iPar));
0242 const TString deltaName(m->Unique(Form("deltaPar%d", iPar)));
0243 TH1 *hD = fPlotMp1->CreateHist(deltaPar, sel, deltaName);
0244 if (0. == hD->GetEntries()) {
0245 delete hD;
0246 continue;
0247 }
0248
0249 const TString deltaBySi1(this->DeltaParBySigma(iPar, fPlotMp1));
0250 const TString deltaBySiName1(m->Unique(Form("deltaPar%dRel1", iPar)));
0251 TString sel1Ok(fPlotMp1->ParSiOk(iPar));
0252 if (!sel.IsNull()) sel1Ok.Append(m->AndL() += sel);
0253 TH1 *hDs1 = fPlotMp1->CreateHist(deltaBySi1, sel1Ok, deltaBySiName1);
0254
0255 const TString deltaBySi2(this->DeltaParBySigma(iPar, fPlotMp2));
0256 TString deltaBySiName2(m->Unique(Form("deltaPar%dRel2", iPar)));
0257 m->CopyAddBinning(deltaBySiName2, hDs1);
0258 TString sel2Ok(fPlotMp2->ParSiOk(iPar));
0259 if (!sel.IsNull()) sel2Ok.Append(m->AndL() += sel);
0260 TH1 *hDs2 = fPlotMp1->CreateHist(deltaBySi2, sel2Ok, deltaBySiName2);
0261
0262 const TString diff(Form("%s_{2}-%s_{1}", m->Name(iPar).Data(), m->Name(iPar).Data()));
0263 hD->SetTitle(m->DelName(iPar) += titleAdd + ";" + diff + ' ' + m->Unit(iPar) +=";#parameters");
0264 hDs1->SetTitle(m->DelName(iPar) += "/#sigma" + titleAdd + ";(" + diff +")/#sigma;#parameters");
0265
0266 fHistManager->AddHist(hD, layer);
0267 if (hDs1->GetEntries()) {
0268 fHistManager->AddHist(hDs1, layer+1, "by #sigma_{1}");
0269 } else delete hDs1;
0270 if (hDs2->GetEntries()) {
0271 fHistManager->AddHistSame(hDs2, layer+1, nPlot, "by #sigma_{2}");
0272 } else delete hDs2;
0273
0274 ++nPlot;
0275 }
0276
0277 fHistManager->Draw();
0278 }
0279
0280
0281 void CompareMillePede::DrawParamVsLocation(Option_t *option)
0282 {
0283
0284 const TString opt(option);
0285 const Int_t layer = this->PrepareAdd(opt.Contains("add", TString::kIgnoreCase));
0286 const TString titleAdd = this->TitleAdd();
0287
0288 const PlotMillePede *m = fPlotMp1;
0289 UInt_t nPlot = 0;
0290 for (UInt_t iPar = 0; iPar < kNpar; ++iPar) {
0291 TString sel("");
0292 this->AddIsFreeSel(sel, opt, iPar);
0293 fPlotMp1->AddBasicSelection(sel);
0294 fPlotMp2->AddBasicSelection(sel);
0295
0296 const TString deltaPar(fPlotMp1->Parenth(this->DeltaPar(iPar)) += fPlotMp1->ToMumMuRad(iPar));
0297
0298 const TString deltaNameR(fPlotMp1->Unique(Form("deltaPar%dR", iPar)));
0299 TH2 *hDr = fPlotMp1->CreateHist2D(fPlotMp1->RPos(fPlotMp1->OrgPosT()), deltaPar, sel,
0300 deltaNameR, "BOX");
0301 if (0. == hDr->GetEntries()) {
0302 delete hDr;
0303 continue;
0304 }
0305
0306 const TString deltaNamePhi(fPlotMp1->Unique(Form("deltaPar%dPhi", iPar)));
0307 TH2 *hDphi = fPlotMp1->CreateHist2D(fPlotMp1->Phi(fPlotMp1->OrgPosT()), deltaPar, sel,
0308 deltaNamePhi, "BOX");
0309 const TString deltaNameZ(fPlotMp1->Unique(Form("deltaPar%dZ", iPar)));
0310 TH2 *hDz = fPlotMp1->CreateHist2D(fPlotMp1->OrgPosT() += fPlotMp1->ZPos(), deltaPar, sel,
0311 deltaNameZ, "BOX");
0312
0313 const TString deltaBySi1(this->DeltaParBySigma(iPar, fPlotMp1));
0314 TString sel1Ok(fPlotMp1->ParSiOk(iPar));
0315 if (!sel.IsNull()) sel1Ok.Append(fPlotMp1->AndL() += sel);
0316 const TString deltaBySiName1R(fPlotMp1->Unique(Form("deltaPar%dRRel1", iPar)));
0317 TH2 *hDrS1 = fPlotMp1->CreateHist2D(fPlotMp1->RPos(fPlotMp1->OrgPosT()),
0318 deltaBySi1, sel1Ok, deltaBySiName1R, "BOX");
0319 const TString deltaBySiName1Phi(fPlotMp1->Unique(Form("deltaPar%dPhiRel1", iPar)));
0320 TH2 *hDphiS1 = fPlotMp1->CreateHist2D(fPlotMp1->Phi(fPlotMp1->OrgPosT()),
0321 deltaBySi1, sel1Ok, deltaBySiName1Phi, "BOX");
0322 const TString deltaBySiName1Z(fPlotMp1->Unique(Form("deltaPar%dZRel1", iPar)));
0323 TH2 *hDzS1 = fPlotMp1->CreateHist2D(fPlotMp1->OrgPosT() += fPlotMp1->ZPos(),
0324 deltaBySi1, sel1Ok, deltaBySiName1Z, "BOX");
0325
0326
0327 const TString deltaBySi2(this->DeltaParBySigma(iPar, fPlotMp2));
0328 TString sel2Ok(fPlotMp2->ParSiOk(iPar));
0329 if (!sel.IsNull()) sel2Ok.Append(fPlotMp2->AndL() += sel);
0330 const TString deltaBySiName2R(fPlotMp2->Unique(Form("deltaPar%dRRel2", iPar)));
0331 TH2 *hDrS2 = fPlotMp1->CreateHist2D(fPlotMp2->RPos(fPlotMp2->OrgPosT()),
0332 deltaBySi2, sel2Ok, deltaBySiName2R, "BOX");
0333 const TString deltaBySiName2Phi(fPlotMp2->Unique(Form("deltaPar%dPhiRel2", iPar)));
0334 TH2 *hDphiS2 = fPlotMp1->CreateHist2D(fPlotMp2->Phi(fPlotMp2->OrgPosT()),
0335 deltaBySi2, sel2Ok, deltaBySiName2Phi, "BOX");
0336 const TString deltaBySiName2Z(fPlotMp2->Unique(Form("deltaPar%dZRel2", iPar)));
0337 TH2 *hDzS2 = fPlotMp1->CreateHist2D(fPlotMp2->OrgPosT() += fPlotMp2->ZPos(),
0338 deltaBySi2, sel2Ok, deltaBySiName2Z, "BOX");
0339
0340 const TString diff(Form("%s_{2}-%s_{1}", m->Name(iPar).Data(), m->Name(iPar).Data()));
0341
0342 hDr->SetTitle(m->DelName(iPar) += " vs r" + titleAdd + ";r[cm];" + diff +' '+ m->Unit(iPar));
0343 hDphi->SetTitle(m->DelName(iPar) += " vs #phi" + titleAdd + ";#phi;"+diff +' '+ m->Unit(iPar));
0344 hDz->SetTitle(m->DelName(iPar) += " vs z" + titleAdd + ";z[cm];" + diff +' '+ m->Unit(iPar));
0345
0346 fHistManager->AddHist(hDr, layer + nPlot);
0347 fHistManager->AddHist(hDphi, layer + nPlot);
0348 fHistManager->AddHist(hDz, layer + nPlot);
0349
0350 if (hDrS1->GetEntries()) {
0351 hDrS1->SetTitle(m->DelName(iPar) += "/#sigma vs r" +titleAdd+ ";r[cm];(" + diff + ")/#sigma");
0352 hDphiS1->SetTitle(m->DelName(iPar) += "/#sigma vs #phi" + titleAdd + ";#phi;("
0353 + diff + ")/#sigma");
0354 hDzS1->SetTitle(m->DelName(iPar) += "/#sigma vs z" +titleAdd+ ";z[cm];(" + diff + ")/#sigma");
0355 fHistManager->AddHist(hDrS1, layer + nPlot + 1, "by #sigma_{1}", "f");
0356 fHistManager->AddHist(hDphiS1, layer + nPlot + 1, "by #sigma_{1}", "f");
0357 fHistManager->AddHist(hDzS1, layer + nPlot + 1, "by #sigma_{1}", "f");
0358 } else {
0359 delete hDrS1;
0360 delete hDphiS1;
0361 delete hDzS1;
0362 }
0363 if (hDrS2->GetEntries()) {
0364 hDrS2->SetLineColor(kRed);
0365 hDphiS2->SetLineColor(kRed);
0366 hDzS2->SetLineColor(kRed);
0367 fHistManager->AddHistSame(hDrS2, layer + nPlot + 1, 0, "by #sigma_{2}", "f");
0368 fHistManager->AddHistSame(hDphiS2, layer + nPlot + 1, 1, "by #sigma_{2}", "f");
0369 fHistManager->AddHistSame(hDzS2, layer + nPlot + 1, 2, "by #sigma_{2}", "f");
0370 } else {
0371 delete hDrS2;
0372 delete hDphiS2;
0373 delete hDzS2;
0374 }
0375 nPlot += 2;
0376 }
0377
0378 const bool oldDiffStyle = fHistManager->DrawDiffStyle(false);
0379 fHistManager->Draw();
0380 fHistManager->DrawDiffStyle(oldDiffStyle);
0381 }
0382
0383
0384 void CompareMillePede::DrawParamDeltaMis(Option_t *option)
0385 {
0386
0387 const TString opt(option);
0388
0389 const Int_t layer = this->PrepareAdd(opt.Contains("add", TString::kIgnoreCase));
0390 const TString titleAdd = this->TitleAdd();
0391
0392 const PlotMillePede *m = fPlotMp1;
0393 UInt_t nPlot = 0;
0394 for (UInt_t iPar = 0; iPar < kNpar; ++iPar) {
0395 TString sel("");
0396 this->AddIsFreeSel(sel, opt, iPar);
0397 fPlotMp1->AddBasicSelection(sel);
0398 fPlotMp2->AddBasicSelection(sel);
0399
0400 const TString deltaMisPar(m->Parenth(this->DeltaMisPar(iPar)) += m->ToMumMuRad(iPar));
0401 const TString deltaName(m->Unique(Form("deltaMisPar%d", iPar)));
0402 TH1 *hD = fPlotMp1->CreateHist(deltaMisPar, sel, deltaName);
0403 if (0. == hD->GetEntries()) {
0404 delete hD;
0405 continue;
0406 }
0407
0408 const TString deltaMisBySi1(this->DeltaMisParBySigma(iPar, fPlotMp1));
0409 const TString deltaBySiName1(m->Unique(Form("deltaMisPar%dRel1", iPar)));
0410 TString sel1Ok(fPlotMp1->ParSiOk(iPar));
0411 if (!sel.IsNull()) sel1Ok.Append(m->AndL() += sel);
0412 TH1 *hDs1 = fPlotMp1->CreateHist(deltaMisBySi1, sel1Ok, deltaBySiName1);
0413
0414 const TString deltaMisBySi2(this->DeltaMisParBySigma(iPar, fPlotMp2));
0415 TString deltaBySiName2(m->Unique(Form("deltaMisPar%dRel2", iPar)));
0416 m->CopyAddBinning(deltaBySiName2, hDs1);
0417 TString sel2Ok(fPlotMp2->ParSiOk(iPar));
0418 if (!sel.IsNull()) sel2Ok.Append(m->AndL() += sel);
0419 TH1 *hDs2 = fPlotMp1->CreateHist(deltaMisBySi2, sel2Ok, deltaBySiName2);
0420
0421 const TString dlNm = m->DelName(iPar);
0422 hD->SetTitle(m->Name(iPar) += titleAdd
0423 + Form(";|%s_{2}|-|%s_{1}| ",dlNm.Data(), dlNm.Data())
0424 + m->Unit(iPar) += ";#parameters");
0425
0426 hDs1->SetTitle(m->Name(iPar) += titleAdd
0427 + Form(";(|%s_{2}|-|%s_{1}|)/#sigma%s", dlNm.Data(), dlNm.Data(),
0428 ";#parameters"));
0429
0430 fHistManager->AddHist(hD, layer);
0431 if (hDs1->GetEntries()) {
0432 fHistManager->AddHist(hDs1, layer+1, "by #sigma_{1}");
0433 } else delete hDs1;
0434 if (hDs2->GetEntries()) {
0435 fHistManager->AddHistSame(hDs2, layer+1, nPlot, "by #sigma_{2}");
0436 } else delete hDs2;
0437
0438 ++nPlot;
0439 }
0440
0441 fHistManager->Draw();
0442
0443 }
0444
0445
0446 void CompareMillePede::DrawParamDeltaMisVsLoc(Option_t *option)
0447 {
0448
0449 const TString opt(option);
0450 const Int_t layer = this->PrepareAdd(opt.Contains("add", TString::kIgnoreCase));
0451 const TString titleAdd = this->TitleAdd();
0452
0453 const PlotMillePede *m = fPlotMp1;
0454 UInt_t nPlot = 0;
0455 for (UInt_t iPar = 0; iPar < kNpar; ++iPar) {
0456 TString sel("");
0457 this->AddIsFreeSel(sel, opt, iPar);
0458 fPlotMp1->AddBasicSelection(sel);
0459 fPlotMp2->AddBasicSelection(sel);
0460
0461 const TString deltaMisPar(m->Parenth(this->DeltaMisPar(iPar)) += m->ToMumMuRad(iPar));
0462
0463 const TString deltaNameR(m->Unique(Form("deltaMisPar%dR", iPar)));
0464 TH2 *hDr = fPlotMp1->CreateHist2D(fPlotMp1->RPos(fPlotMp1->OrgPosT()), deltaMisPar, sel,
0465 deltaNameR, "BOX");
0466 if (0. == hDr->GetEntries()) {
0467 delete hDr;
0468 continue;
0469 }
0470 const TString deltaNamePhi(m->Unique(Form("deltaMisPar%dPhi", iPar)));
0471 TH2 *hDphi = fPlotMp1->CreateHist2D(fPlotMp1->Phi(fPlotMp1->OrgPosT()), deltaMisPar, sel,
0472 deltaNamePhi, "BOX");
0473 const TString deltaNameZ(m->Unique(Form("deltaMisPar%dZ", iPar)));
0474 TH2 *hDz = fPlotMp1->CreateHist2D(fPlotMp1->OrgPosT() += fPlotMp1->ZPos(), deltaMisPar, sel,
0475 deltaNameZ, "BOX");
0476 const TString deltaNameNh1(m->Unique(Form("deltaMisPar%dNh1", iPar)));
0477 TH2 *hDnh1 = fPlotMp1->CreateHist2D(fPlotMp1->HitsX(), deltaMisPar, sel,
0478 deltaNameNh1, "BOX");
0479 const TString deltaNameNh2(m->Unique(Form("deltaMisPar%dNh2", iPar)));
0480 TH2 *hDnh2 = fPlotMp1->CreateHist2D(fPlotMp2->HitsX(), deltaMisPar, sel,
0481 deltaNameNh2, "BOX");
0482
0483
0484 const TString deltaMisBySi1(this->DeltaMisParBySigma(iPar, fPlotMp1));
0485 TString sel1Ok(fPlotMp1->ParSiOk(iPar));
0486 if (!sel.IsNull()) sel1Ok.Append(m->AndL() += sel);
0487 const TString deltaBySiName1R(m->Unique(Form("deltaMisPar%dRRel1", iPar)));
0488 TH2 *hDrS1 = fPlotMp1->CreateHist2D(fPlotMp1->RPos(fPlotMp1->OrgPosT()),
0489 deltaMisBySi1, sel1Ok, deltaBySiName1R, "BOX");
0490 const TString deltaBySiName1Phi(m->Unique(Form("deltaMisPar%dPhiRel1", iPar)));
0491 TH2 *hDphiS1 = fPlotMp1->CreateHist2D(fPlotMp1->Phi(fPlotMp1->OrgPosT()),
0492 deltaMisBySi1, sel1Ok, deltaBySiName1Phi, "BOX");
0493 const TString deltaBySiName1Z(m->Unique(Form("deltaMisPar%dZRel1", iPar)));
0494 TH2 *hDzS1 = fPlotMp1->CreateHist2D(fPlotMp1->OrgPosT() += fPlotMp1->ZPos(),
0495 deltaMisBySi1, sel1Ok, deltaBySiName1Z, "BOX");
0496
0497
0498 const TString deltaMisBySi2(this->DeltaMisParBySigma(iPar, fPlotMp2));
0499 TString sel2Ok(fPlotMp2->ParSiOk(iPar));
0500 if (!sel.IsNull()) sel2Ok.Append(m->AndL() += sel);
0501 const TString deltaBySiName2R(m->Unique(Form("deltaMisPar%dRRel2", iPar)));
0502 TH2 *hDrS2 = fPlotMp1->CreateHist2D(fPlotMp2->RPos(fPlotMp2->OrgPosT()),
0503 deltaMisBySi2, sel2Ok, deltaBySiName2R, "BOX");
0504 const TString deltaBySiName2Phi(m->Unique(Form("deltaMisPar%dPhiRel2", iPar)));
0505 TH2 *hDphiS2 = fPlotMp1->CreateHist2D(fPlotMp2->Phi(fPlotMp2->OrgPosT()),
0506 deltaMisBySi2, sel2Ok, deltaBySiName2Phi, "BOX");
0507 const TString deltaBySiName2Z(m->Unique(Form("deltaMisPar%dZRel2", iPar)));
0508 TH2 *hDzS2 = fPlotMp1->CreateHist2D(fPlotMp2->OrgPosT() += fPlotMp2->ZPos(),
0509 deltaMisBySi2, sel2Ok, deltaBySiName2Z, "BOX");
0510
0511
0512 const TString diff(Form("|%s_{2}|-|%s_{1}|",m->DelName(iPar).Data(),m->DelName(iPar).Data()));
0513
0514 hDr->SetTitle(m->DelName(iPar) += " vs r" + titleAdd + ";r[cm];" + diff + ' ' + m->Unit(iPar));
0515 hDphi->SetTitle(m->DelName(iPar) += " vs #phi" + titleAdd + ";#phi;" + diff + ' '
0516 + m->Unit(iPar));
0517 hDz->SetTitle(m->DelName(iPar) += " vs z" + titleAdd + ";z[cm];" + diff + ' ' + m->Unit(iPar));
0518 hDnh1->SetTitle(m->DelName(iPar) += " vs N_{1}(hit" + titleAdd + ";N_{1}(hit);"
0519 + diff + ' ' + m->Unit(iPar));
0520 hDnh2->SetTitle(m->DelName(iPar) += " vs N_{2}(hit" + titleAdd + ";N_{2}(hit);"
0521 + diff + ' ' + m->Unit(iPar));
0522
0523 fHistManager->AddHist(hDr, layer + nPlot);
0524 fHistManager->AddHist(hDphi, layer + nPlot);
0525 fHistManager->AddHist(hDz, layer + nPlot);
0526 fHistManager->AddHist(hDnh1, layer + nPlot);
0527 fHistManager->AddHist(hDnh2, layer + nPlot);
0528
0529 if (hDrS1->GetEntries()) {
0530 hDrS1->SetTitle(m->DelName(iPar) += "/#sigma vs r" + titleAdd + ";r[cm];(" + diff
0531 + ")/#sigma");
0532 hDphiS1->SetTitle(m->DelName(iPar) += "/#sigma vs #phi" + titleAdd + ";#phi;(" + diff
0533 + ")/#sigma");
0534 hDzS1->SetTitle(m->DelName(iPar) += "/#sigma vs z" + titleAdd + ";z[cm];(" + diff
0535 + ")/#sigma");
0536 fHistManager->AddHist(hDrS1, layer + nPlot + 1, "by #sigma_{1}", "f");
0537 fHistManager->AddHist(hDphiS1, layer + nPlot + 1, "by #sigma_{1}", "f");
0538 fHistManager->AddHist(hDzS1, layer + nPlot + 1, "by #sigma_{1}", "f");
0539 } else {
0540 delete hDrS1;
0541 delete hDphiS1;
0542 delete hDzS1;
0543 }
0544 if (hDrS2->GetEntries()) {
0545 hDrS2->SetLineColor(kRed);
0546 hDphiS2->SetLineColor(kRed);
0547 hDzS2->SetLineColor(kRed);
0548 fHistManager->AddHistSame(hDrS2, layer + nPlot + 1, 0, "by #sigma_{2}", "f");
0549 fHistManager->AddHistSame(hDphiS2, layer + nPlot + 1, 1, "by #sigma_{2}", "f");
0550 fHistManager->AddHistSame(hDzS2, layer + nPlot + 1, 2, "by #sigma_{2}", "f");
0551 } else {
0552 delete hDrS2;
0553 delete hDphiS2;
0554 delete hDzS2;
0555 }
0556 nPlot += 2;
0557 }
0558
0559 const bool oldDiffStyle = fHistManager->DrawDiffStyle(false);
0560 fHistManager->Draw();
0561 fHistManager->DrawDiffStyle(oldDiffStyle);
0562 }
0563
0564
0565 void CompareMillePede::DrawNumHits(Option_t *option)
0566 {
0567 const TString opt(option);
0568 const Int_t layer = this->PrepareAdd(opt.Contains("add", TString::kIgnoreCase));
0569 const TString titleAdd = this->TitleAdd();
0570
0571 const PlotMillePede *m = fPlotMp1;
0572
0573 TString sel;
0574 fPlotMp1->AddBasicSelection(sel);
0575 fPlotMp2->AddBasicSelection(sel);
0576
0577 const TString nX1vs2(m->Unique("hitsX1vs2"));
0578 TH2 *hX1vs2 = fPlotMp1->CreateHist2D(fPlotMp1->HitsX(), fPlotMp2->HitsX(), sel, nX1vs2, "BOX");
0579
0580 const TString nY1vs2(m->Unique("hitsY1vs2"));
0581 TH2 *hY1vs2 = fPlotMp1->CreateHist2D(fPlotMp1->HitsY(), fPlotMp2->HitsY(), sel, nY1vs2, "BOX");
0582
0583 const TString nDiffX(m->Unique("deltaHitsX"));
0584 const TString diffX(m->Parenth(fPlotMp2->HitsX() += m->Min() += fPlotMp1->HitsX()));
0585 TH1 *hDiffX = fPlotMp1->CreateHist(diffX, sel, nDiffX);
0586
0587 const TString nDiffY(m->Unique("deltaHitsY"));
0588 const TString diffY(m->Parenth(fPlotMp2->HitsY() += m->Min() += fPlotMp1->HitsY()));
0589 TH1 *hDiffY = fPlotMp1->CreateHist(diffY, sel, nDiffY);
0590
0591 const TString ratioX(m->Parenth(fPlotMp2->HitsX() += m->Div() += fPlotMp1->HitsX()));
0592 const TString selRatioX(fPlotMp1->HitsX() += ">0" + m->AndL() += sel);
0593 const TString nRatioX(m->Unique("ratioHitsX"));
0594 TH1 *hRatioX = fPlotMp1->CreateHist(ratioX, selRatioX, nRatioX);
0595
0596 const TString ratioY(m->Parenth(fPlotMp2->HitsY() += m->Div() += fPlotMp1->HitsY()));
0597 const TString selRatioY(fPlotMp1->HitsY() += ">0" + m->AndL() += sel);
0598 const TString nRatioY(m->Unique("ratioHitsY"));
0599 TH1 *hRatioY = fPlotMp1->CreateHist(ratioY, selRatioY, nRatioY);
0600
0601
0602
0603
0604
0605 const TString nDiffXvsR(m->Unique("deltaHitsXvsR"));
0606 TH2 *hDiffXvsR = fPlotMp1->CreateHist2D(diffX, fPlotMp1->RPos(fPlotMp1->OrgPosT()),
0607 sel, nDiffXvsR, "BOX");
0608 const TString nDiffXvsPhi(m->Unique("deltaHitsXvsPhi"));
0609 TH2 *hDiffXvsPhi = fPlotMp1->CreateHist2D(diffX, fPlotMp1->Phi(fPlotMp1->OrgPosT()),
0610 sel, nDiffXvsPhi, "BOX");
0611 const TString nDiffXvsZ(m->Unique("deltaHitsXvsZ"));
0612 TH2 *hDiffXvsZ = fPlotMp1->CreateHist2D(diffX, fPlotMp1->OrgPosT() += fPlotMp1->ZPos(),
0613 sel, nDiffXvsZ, "BOX");
0614 const TString nDiffXvsX(m->Unique("deltaHitsXvsX"));
0615 TH2 *hDiffXvsX = fPlotMp1->CreateHist2D(diffX, fPlotMp1->OrgPosT() += fPlotMp1->XPos(),
0616 sel, nDiffXvsX, "BOX");
0617 const TString nDiffXvsY(m->Unique("deltaHitsXvsY"));
0618 TH2 *hDiffXvsY = fPlotMp1->CreateHist2D(diffX, fPlotMp1->OrgPosT() += fPlotMp1->YPos(),
0619 sel, nDiffXvsY, "BOX");
0620 const TString nDiffXvs1(m->Unique("deltaHitsXvs1"));
0621 TH2 *hDiffXvs1 = fPlotMp1->CreateHist2D(diffX, fPlotMp1->HitsX(), sel, nDiffXvs1, "BOX");
0622
0623
0624 const TString nRatioXvsR(m->Unique("ratioHitsXvsR"));
0625 TH2 *hRatioXvsR = fPlotMp1->CreateHist2D(ratioX, fPlotMp1->RPos(fPlotMp1->OrgPosT()),
0626 selRatioX, nRatioXvsR, "BOX");
0627 const TString nRatioXvsPhi(m->Unique("ratioHitsXvsPhi"));
0628 TH2 *hRatioXvsPhi = fPlotMp1->CreateHist2D(ratioX, fPlotMp1->Phi(fPlotMp1->OrgPosT()),
0629 selRatioX, nRatioXvsPhi, "BOX");
0630 const TString nRatioXvsZ(m->Unique("ratioHitsXvsZ"));
0631 TH2 *hRatioXvsZ = fPlotMp1->CreateHist2D(ratioX, fPlotMp1->OrgPosT() += fPlotMp1->ZPos(),
0632 selRatioX, nRatioXvsZ, "BOX");
0633 const TString nRatioXvsX(m->Unique("ratioHitsXvsX"));
0634 TH2 *hRatioXvsX = fPlotMp1->CreateHist2D(ratioX, fPlotMp1->OrgPosT() += fPlotMp1->XPos(),
0635 selRatioX, nRatioXvsX, "BOX");
0636 const TString nRatioXvsY(m->Unique("ratioHitsXvsY"));
0637 TH2 *hRatioXvsY = fPlotMp1->CreateHist2D(ratioX, fPlotMp1->OrgPosT() += fPlotMp1->YPos(),
0638 selRatioX, nRatioXvsY, "BOX");
0639 const TString nRatioXvs1(m->Unique("ratioHitsXvs1"));
0640 TH2 *hRatioXvs1 = fPlotMp1->CreateHist2D(ratioX, fPlotMp1->HitsX(), selRatioX, nRatioXvs1, "BOX");
0641
0642
0643 hX1vs2->SetTitle("#hits_{x}" + titleAdd + ";N_{hit,x}^{1};N_{hit,x}^{2}");
0644 hY1vs2->SetTitle("#hits_{y}" + titleAdd + ";N_{hit,y}^{1};N_{hit,y}^{2}");
0645 hDiffX->SetTitle("#Delta#hits_{x}" + titleAdd + ";N_{hit,x}^{2} - N_{hit,x}^{1};#alignables");
0646 hDiffY->SetTitle("#Delta#hits_{y}" + titleAdd + ";N_{hit,y}^{2} - N_{hit,y}^{1};#alignables");
0647
0648
0649 hRatioX->SetTitle("ratio #hits_{x}" + titleAdd + ";N_{hit,x}^{2} / N_{hit,x}^{1};#alignables");
0650 hRatioY->SetTitle("ratio #hits_{y}" + titleAdd + ";N_{hit,y}^{2} / N_{hit,y}^{1};#alignables");
0651
0652 hDiffXvsR->SetTitle("#Delta#hits_{x} vs r" + titleAdd + ";N_{hit,x}^{2} - N_{hit,x}^{1};r[cm]");
0653 hDiffXvsPhi->SetTitle("#Delta#hits_{x} vs #phi" +titleAdd+ ";N_{hit,x}^{2} - N_{hit,x}^{1};#phi");
0654 hDiffXvsZ->SetTitle("#Delta#hits_{x} vs z" + titleAdd + ";N_{hit,x}^{2} - N_{hit,x}^{1};z[cm]");
0655 hDiffXvsX->SetTitle("#Delta#hits_{x} vs x" + titleAdd + ";N_{hit,x}^{2} - N_{hit,x}^{1};x[cm]");
0656 hDiffXvsY->SetTitle("#Delta#hits_{x} vs y" + titleAdd + ";N_{hit,x}^{2} - N_{hit,x}^{1};y[cm]");
0657 hDiffXvs1->SetTitle("#Delta#hits_{x} vs #hits_{x}^{1}" + titleAdd
0658 + ";N_{hit,x}^{2} - N_{hit,x}^{1};N_{hit,x}^{1}");
0659
0660 hRatioXvsR->SetTitle("hit ratio vs r" + titleAdd + ";N_{hit,x}^{2} / N_{hit,x}^{1};r[cm]");
0661 hRatioXvsPhi->SetTitle("hit ratio vs #phi" +titleAdd+ ";N_{hit,x}^{2} / N_{hit,x}^{1};#phi");
0662 hRatioXvsZ->SetTitle("hit ratio vs z" + titleAdd + ";N_{hit,x}^{2} / N_{hit,x}^{1};z[cm]");
0663 hRatioXvsX->SetTitle("hit ratio vs x" + titleAdd + ";N_{hit,x}^{2} / N_{hit,x}^{1};x[cm]");
0664 hRatioXvsY->SetTitle("hit ratio vs y" + titleAdd + ";N_{hit,x}^{2} / N_{hit,x}^{1};y[cm]");
0665 hRatioXvs1->SetTitle("hit ratio vs #hits_{x}^{1}" + titleAdd
0666 + ";N_{hit,x}^{2} / N_{hit,x}^{1};N_{hit,x}^{1}");
0667
0668 fHistManager->AddHist(hX1vs2, layer);
0669 fHistManager->AddHist(hDiffX, layer);
0670 fHistManager->AddHist(hRatioX, layer);
0671 fHistManager->AddHist(hY1vs2, layer);
0672 fHistManager->AddHist(hDiffY, layer);
0673
0674 fHistManager->AddHist(hRatioY, layer);
0675
0676 fHistManager->AddHist(hDiffXvsR, layer+1);
0677 fHistManager->AddHist(hDiffXvsPhi, layer+1);
0678 fHistManager->AddHist(hDiffXvsZ, layer+1);
0679 fHistManager->AddHist(hDiffXvsX, layer+1);
0680 fHistManager->AddHist(hDiffXvsY, layer+1);
0681 fHistManager->AddHist(hDiffXvs1, layer+1);
0682
0683 fHistManager->AddHist(hRatioXvsR, layer+2);
0684 fHistManager->AddHist(hRatioXvsPhi, layer+2);
0685 fHistManager->AddHist(hRatioXvsZ, layer+2);
0686 fHistManager->AddHist(hRatioXvsX, layer+2);
0687 fHistManager->AddHist(hRatioXvsY, layer+2);
0688 fHistManager->AddHist(hRatioXvs1, layer+2);
0689
0690 fHistManager->Draw();
0691 }
0692
0693
0694 void CompareMillePede::DrawAbsPos(Option_t *option)
0695 {
0696
0697
0698 const TString opt(option);
0699
0700 const Int_t layer = this->PrepareAdd(opt.Contains("add", TString::kIgnoreCase));
0701 const TString titleAdd = this->TitleAdd();
0702
0703 const TString tree1(opt.Contains("start", TString::kIgnoreCase) ? fPlotMp1->OrgPosT() : fPlotMp1->PosT());
0704 const TString tree2(opt.Contains("start", TString::kIgnoreCase) ? fPlotMp2->OrgPosT() : fPlotMp2->PosT());
0705
0706 const PlotMillePede *m = fPlotMp1;
0707
0708
0709
0710
0711
0712
0713 for (UInt_t iPos = 0; iPos < 3; ++iPos) {
0714 TString sel("");
0715
0716 fPlotMp1->AddBasicSelection(sel);
0717 fPlotMp2->AddBasicSelection(sel);
0718
0719
0720
0721
0722
0723
0724
0725
0726
0727
0728
0729
0730
0731
0732
0733
0734
0735
0736 const TString deltaName(m->Unique(Form("deltaPos%d", iPos)));
0737
0738 TH1 *h = fPlotMp1->CreateHist(m->DelPos(iPos, tree2, tree1), sel, deltaName);
0739 if (0. == h->GetEntries()) {
0740 delete h;
0741 continue;
0742 }
0743
0744 const TString diff(Form("%s_{2}-%s_{1}", m->NamePos(iPos).Data(), m->NamePos(iPos).Data()));
0745 h->SetTitle(diff + titleAdd + ";" + diff + " [cm];#alignables");
0746
0747 fHistManager->AddHist(h, layer);
0748
0749 }
0750
0751 fHistManager->Draw();
0752 }
0753
0754
0755 void CompareMillePede::DrawSurfaceDeformations(Option_t *option, unsigned int firstPar,
0756 unsigned int lastPar, const TString &whichOne)
0757 {
0758 const TString opt(option);
0759
0760 const Int_t layer = this->PrepareAdd(opt.Contains("add", TString::kIgnoreCase));
0761 const bool limits = opt.Contains("limit", TString::kIgnoreCase);
0762 const bool noVs = opt.Contains("novs", TString::kIgnoreCase);
0763 const bool noDiff = opt.Contains("noDiff", TString::kIgnoreCase);
0764 const TString titleAdd = this->TitleAdd();
0765 const PlotMillePede *m = fPlotMp1;
0766
0767 UInt_t nPlot = 0;
0768 for (UInt_t iPar = firstPar; iPar <= lastPar; ++iPar) {
0769 TString sel("");
0770 fPlotMp1->AddBasicSelection(sel);
0771 fPlotMp2->AddBasicSelection(sel);
0772 sel += m->AndL() += m->Parenth(fPlotMp1->NumDeformValues(whichOne) += Form(">%u", iPar))
0773 += m->AndL() += m->Parenth(fPlotMp2->NumDeformValues(whichOne) += Form(">%u", iPar));
0774
0775 const TString deform1(fPlotMp1->DeformValue(iPar, whichOne));
0776 const TString deform2(fPlotMp2->DeformValue(iPar, whichOne));
0777 const TString diff(m->Parenth(deform2 + m->Min() += deform1)
0778 += m->ToMumMuRadSurfDef(iPar));
0779 TString hNameDiff(m->Unique(Form("hSurfDiff%s%u", whichOne.Data(), iPar)));
0780 if (limits) hNameDiff += Form("(101,%f,%f)", m->GetMaxDevDown(), m->GetMaxDevUp());
0781
0782
0783 TH1 *hDiff = fPlotMp1->CreateHist(diff, sel, hNameDiff);
0784 if (0. == hDiff->GetEntries()) {
0785 delete hDiff;
0786 continue;
0787 }
0788
0789 if (noDiff) {
0790 delete hDiff;
0791 } else {
0792
0793 const TString diffTit(m->NameSurfDef(iPar) += "_{2}-"
0794 + m->NameSurfDef(iPar) += "_{1}");
0795 hDiff->SetTitle(diffTit + titleAdd + ";"
0796 + diffTit + m->UnitSurfDef(iPar) +=";#parameters");
0797 fHistManager->AddHist(hDiff, layer);
0798 }
0799
0800 if (!noVs) {
0801 TString hNameVs(m->Unique(Form("hSurfVs%s%u", whichOne.Data(), iPar)));
0802 if (limits) hNameVs += Form("(101,%f,%f, 101,%f,%f)", m->GetMaxDevDown(),
0803 m->GetMaxDevUp(), m->GetMaxDevDown(), m->GetMaxDevUp());
0804 TH2 *hVs = fPlotMp1->CreateHist2D(deform1 + m->ToMumMuRadSurfDef(iPar),
0805 deform2 + m->ToMumMuRadSurfDef(iPar), sel,
0806 hNameVs, "BOX");
0807 hVs->SetTitle(m->NameSurfDef(iPar) += titleAdd + ";"
0808 + m->NameSurfDef(iPar) += "_{1}" + m->UnitSurfDef(iPar) +=";"
0809 + m->NameSurfDef(iPar) += "_{2}" + m->UnitSurfDef(iPar));
0810
0811 fHistManager->AddHist(hVs, layer + !noDiff);
0812
0813 const Double_t xMin = hVs->GetXaxis()->GetXmin();
0814 const Double_t xMax = hVs->GetXaxis()->GetXmax();
0815 TLine *line = new TLine(xMin, xMin, xMax, xMax);
0816 line->SetLineColor(kRed); line->SetLineWidth(2);
0817 fHistManager->AddObject(line, layer + !noDiff, nPlot);
0818 }
0819
0820 ++nPlot;
0821 }
0822
0823 fHistManager->Draw();
0824 }
0825
0826
0827
0828 bool CompareMillePede::IsConsistent()
0829 {
0830
0831
0832
0833
0834 TH1 *hId = fPlotMp1->CreateHist(fPlotMp1->PosT() += "Id - " + fPlotMp2->PosT() += "Id", "");
0835 TH1 *hObjId = fPlotMp1->CreateHist(fPlotMp1->PosT()+="ObjId - " + fPlotMp2->PosT()+="ObjId", "");
0836
0837 if (hId->GetMean() == 0. && hId->GetRMS() == 0.
0838 && hObjId->GetMean() == 0. && hObjId->GetRMS() == 0.) {
0839 delete hId;
0840 delete hObjId;
0841 return true;
0842 } else {
0843 fHistManager->Clear();
0844 fHistManager->AddHist(hId);
0845 fHistManager->AddHist(hObjId);
0846 fHistManager->Draw();
0847
0848 return false;
0849 }
0850 }
0851
0852
0853 TString CompareMillePede::DeltaPar(UInt_t iPar) const
0854 {
0855
0856 return fPlotMp2->FinalMisAlignment(iPar) += fPlotMp1->Min() += fPlotMp1->FinalMisAlignment(iPar);
0857 }
0858
0859
0860 TString CompareMillePede::DeltaParBySigma(UInt_t iPar, const PlotMillePede *sigmaSource) const
0861 {
0862
0863 return
0864 sigmaSource->Parenth(this->DeltaPar(iPar)) += sigmaSource->Div() += sigmaSource->ParSi(iPar);
0865 }
0866
0867
0868 TString CompareMillePede::DeltaMisPar(UInt_t iPar) const
0869 {
0870
0871 const PlotMillePede *m = fPlotMp1;
0872 return m->Abs(fPlotMp2->FinalMisAlignment(iPar))
0873 += m->Min() += m->Abs(fPlotMp1->FinalMisAlignment(iPar));
0874 }
0875
0876
0877 TString CompareMillePede::DeltaMisParBySigma(UInt_t iPar, const PlotMillePede *sigmaSource) const
0878 {
0879
0880 return sigmaSource->Parenth(this->DeltaMisPar(iPar))
0881 += sigmaSource->Div() += sigmaSource->ParSi(iPar);
0882 }
0883
0884
0885 TString CompareMillePede::DeltaPos(UInt_t iPos) const
0886 {
0887 TString pos1(fPlotMp1->Parenth(fPlotMp1->PosT() += fPlotMp1->Pos(iPos)));
0888 TString pos2(fPlotMp2->Parenth(fPlotMp2->PosT() += fPlotMp2->Pos(iPos)));
0889
0890 return pos1 += fPlotMp1->Min() += pos2;
0891 }
0892
0893
0894 void CompareMillePede::AddIsFreeSel(TString &sel, const TString &option, UInt_t iPar) const
0895 {
0896 if (option.Contains("free1", TString::kIgnoreCase)) {
0897 if (sel.IsNull()) sel = fPlotMp1->Fixed(iPar, false);
0898 else sel.Prepend(fPlotMp1->Fixed(iPar, false) += fPlotMp1->AndL());
0899 }
0900 if (option.Contains("free2", TString::kIgnoreCase)) {
0901 if (sel.IsNull()) sel = fPlotMp2->Fixed(iPar, false);
0902 else sel.Prepend(fPlotMp2->Fixed(iPar, false) += fPlotMp2->AndL());
0903 }
0904 }
0905
0906
0907 void CompareMillePede::SetSubDetId(Int_t subDetId)
0908 {
0909 fPlotMp1->SetSubDetId(subDetId);
0910 fPlotMp2->SetSubDetId(subDetId);
0911 }
0912
0913
0914 void CompareMillePede::AddSubDetId(Int_t subDetId)
0915 {
0916 fPlotMp1->AddSubDetId(subDetId);
0917 fPlotMp2->AddSubDetId(subDetId);
0918 }
0919
0920
0921 void CompareMillePede::SetAlignableTypeId(Int_t alignableTypeId)
0922 {
0923 fPlotMp1->SetAlignableTypeId(alignableTypeId);
0924 fPlotMp2->SetAlignableTypeId(alignableTypeId);
0925 }
0926
0927
0928 void CompareMillePede::SetHieraLevel(Int_t hieraLevel)
0929 {
0930 fPlotMp1->SetHieraLevel(hieraLevel);
0931 fPlotMp2->SetHieraLevel(hieraLevel);
0932 }
0933
0934
0935 void CompareMillePede::AddAdditionalSel(const char *selection)
0936 {
0937 fPlotMp1->AddAdditionalSel(selection);
0938 fPlotMp2->AddAdditionalSel(selection);
0939 }
0940
0941
0942 void CompareMillePede::AddAdditionalSel(const TString &xyzrPhiNhit, Float_t min, Float_t max)
0943 {
0944 fPlotMp1->AddAdditionalSel(xyzrPhiNhit, min, max);
0945 fPlotMp2->AddAdditionalSel(xyzrPhiNhit, min, max);
0946 }
0947
0948
0949 void CompareMillePede::ClearAdditionalSel ()
0950 {
0951 fPlotMp1->ClearAdditionalSel();
0952 fPlotMp2->ClearAdditionalSel();
0953 }
0954
0955
0956 void CompareMillePede::SetSurfDefDeltaBows(bool deltaBows)
0957 {
0958 fPlotMp1->SetSurfDefDeltaBows(deltaBows);
0959 fPlotMp2->SetSurfDefDeltaBows(deltaBows);
0960 }
0961
0962
0963 Int_t CompareMillePede::PrepareAdd(bool addPlots)
0964 {
0965 if (addPlots) {
0966 return fHistManager->GetNumLayers();
0967 } else {
0968 fHistManager->Clear();
0969 return 0;
0970 }
0971 }
0972
0973
0974 TString CompareMillePede::TitleAdd() const
0975 {
0976
0977
0978
0979 TString titleAdd1 = fPlotMp1->TitleAdd();
0980 const TString title1(fPlotMp1->GetTitle());
0981 TString titleAdd1noTitle(titleAdd1);
0982 const Ssiz_t tit1pos = titleAdd1.First(title1);
0983 if (tit1pos != kNPOS) titleAdd1noTitle.Remove(tit1pos, title1.Length() + 2);
0984
0985 TString titleAdd2 = fPlotMp2->TitleAdd();
0986 const TString title2(fPlotMp2->GetTitle());
0987 TString titleAdd2noTitle(titleAdd2);
0988 const Ssiz_t tit2pos = titleAdd2.First(title2);
0989 if (tit2pos != kNPOS) titleAdd2noTitle.Remove(tit2pos, title2.Length() + 2);
0990
0991 if (titleAdd1noTitle != titleAdd2noTitle) {
0992
0993 titleAdd1 += " (1), ";
0994 if (titleAdd2(0, 2) == ": ") titleAdd2.Remove(0, 2);
0995 titleAdd1 += titleAdd2 += " (2)";
0996 return titleAdd1;
0997 } else {
0998
0999 return (titleAdd1noTitle += ", 1: " + title1 + ", 2: " + title2);
1000 }
1001 }