File indexing completed on 2025-12-16 09:28:23
0001 #include "TileTrend.h"
0002 #include "TFitResult.h"
0003 #include "TFitResultPtr.h"
0004
0005 ClassImp(TileTrend);
0006
0007
0008
0009
0010
0011 bool TileTrend::Fill(double x, const TileCalib& tc, int runNr, double volt){
0012 gTrendLGped .AddPoint (x,tc.PedestalMeanL);
0013 gTrendLGped .SetPointError(gTrendLGped.GetN()-1,0.,tc.PedestalSigL);
0014 if(tc.PedestalMeanL<MinLGped && tc.PedestalMeanL > -100) MinLGped=tc.PedestalMeanL;
0015 if(tc.PedestalMeanL>MaxLGped) MaxLGped=tc.PedestalMeanL;
0016
0017 gTrendHGped .AddPoint (x,tc.PedestalMeanH);
0018 gTrendHGped .SetPointError(gTrendHGped.GetN()-1,0.,tc.PedestalSigH);
0019 if(tc.PedestalMeanH<MinHGped && tc.PedestalMeanH > -100) MinHGped=tc.PedestalMeanH;
0020 if(tc.PedestalMeanH>MaxHGped) MaxHGped=tc.PedestalMeanH;
0021
0022 gTrendLGpedwidth .AddPoint (x,tc.PedestalSigL);
0023 gTrendLGpedwidth .SetPointError(gTrendLGpedwidth.GetN()-1,0.,0.);
0024 if(tc.PedestalSigL<MinLGpedwidth && tc.PedestalSigL > -100) MinLGpedwidth=tc.PedestalSigL;
0025 if(tc.PedestalSigL>MaxLGpedwidth) MaxLGpedwidth=tc.PedestalSigL;
0026
0027 gTrendHGpedwidth .AddPoint (x,tc.PedestalSigH);
0028 gTrendHGpedwidth .SetPointError(gTrendHGpedwidth.GetN()-1,0.,0.);
0029 if(tc.PedestalSigH<MinHGpedwidth && tc.PedestalSigH > -100) MinHGpedwidth=tc.PedestalSigH;
0030 if(tc.PedestalSigH>MaxHGpedwidth) MaxHGpedwidth=tc.PedestalSigH;
0031
0032 gTrendLGscale .AddPoint (x,tc.ScaleL );
0033 gTrendLGscale .SetPointError(gTrendLGscale.GetN()-1,0.,tc.ScaleWidthL);
0034 if(tc.ScaleL<MinLGscale && tc.ScaleL > 0) MinLGscale=tc.ScaleL;
0035 if(tc.ScaleL>MaxLGscale) MaxLGscale=tc.ScaleL;
0036
0037 gTrendHGscale .AddPoint (x,tc.ScaleH );
0038 gTrendHGscale .SetPointError(gTrendHGscale.GetN()-1,0.,tc.ScaleWidthH);
0039 if(tc.ScaleH<MinHGscale && tc.ScaleH > 0) MinHGscale=tc.ScaleH;
0040 if(tc.ScaleH>MaxHGscale) MaxHGscale=tc.ScaleH;
0041
0042 gTrendHGLGcorr.AddPoint (x,tc.HGLGCorr );
0043 gTrendHGLGcorr.SetPointError(gTrendHGLGcorr.GetN()-1,0.,0.);
0044 if(tc.HGLGCorr<MinHGLGcorr && tc.HGLGCorr > 0) MinHGLGcorr=tc.HGLGCorr;
0045 if(tc.HGLGCorr>MaxHGLGcorr && tc.HGLGCorr > 0) MaxHGLGcorr=tc.HGLGCorr;
0046
0047 gTrendHGLGOffset.AddPoint (x,tc.HGLGCorrOff );
0048 gTrendHGLGOffset.SetPointError(gTrendHGLGOffset.GetN()-1,0.,0.);
0049 if(tc.HGLGCorrOff<MinHGLGOff && tc.HGLGCorrOff != -1000.) MinHGLGOff=tc.HGLGCorrOff;
0050 if(tc.HGLGCorrOff>MaxHGLGOff && tc.HGLGCorrOff != -1000.) MaxHGLGOff=tc.HGLGCorrOff;
0051
0052 gTrendLGHGcorr.AddPoint (x,tc.LGHGCorr );
0053 gTrendLGHGcorr.SetPointError(gTrendLGHGcorr.GetN()-1,0.,0.);
0054 if(tc.LGHGCorr<MinLGHGcorr && tc.LGHGCorr > 0) MinLGHGcorr=tc.LGHGCorr;
0055 if(tc.LGHGCorr>MaxLGHGcorr && tc.LGHGCorr > 0) MaxLGHGcorr=tc.LGHGCorr;
0056
0057 gTrendLGHGOffset.AddPoint (x,tc.LGHGCorrOff );
0058 gTrendLGHGOffset.SetPointError(gTrendLGHGOffset.GetN()-1,0.,0.);
0059 if(tc.LGHGCorrOff<MinLGHGOff && tc.LGHGCorrOff != -1000.) MinLGHGOff=tc.LGHGCorrOff;
0060 if(tc.LGHGCorrOff>MaxLGHGOff && tc.LGHGCorrOff != -1000.) MaxLGHGOff=tc.LGHGCorrOff;
0061
0062 voltages.push_back(volt);
0063 runNrs.push_back(runNr);
0064 return true;
0065 }
0066
0067
0068 bool TileTrend::FillExtended(double x, int triggers, int runNr, TH1D* histHG, TH1D* histLG, TProfile* profLGHG ){
0069
0070 if (extended == 1 || extended == 2 ){
0071 gTrendTrigger.AddPoint (x,triggers );
0072 gTrendTrigger.SetPointError(gTrendTrigger.GetN()-1,0.,0.);
0073 if(triggers<MinTrigg) MinTrigg = triggers;
0074 if(triggers>MaxTrigg) MaxTrigg = triggers;
0075
0076 if (histHG){
0077 TH1D temp = *histHG;
0078 temp.SetName(Form("%s_Run%i",histHG->GetName(),runNr));
0079 temp.SetDirectory(0);
0080 temp.Scale(1./triggers);
0081 temp.GetYaxis()->SetTitle("Counts/ local mip trigger");
0082 temp.Rebin(2);
0083 if (MinHGSpec > 1./triggers) MinHGSpec = (double)1./triggers;
0084 if (MaxHGSpec < temp.GetMaximum()) MaxHGSpec = temp.GetMaximum();
0085 HGTriggRuns[runNr] = temp;
0086 }
0087 if (histLG){
0088 TH1D temp2 = *histLG;
0089 temp2.SetName(Form("%s_Run%i",histLG->GetName(),runNr));
0090 temp2.SetDirectory(0);
0091 temp2.Scale(1./triggers);
0092 temp2.GetYaxis()->SetTitle("Counts/ local mip trigger");
0093 if (MinLGSpec > 1./triggers) MinLGSpec = (double)1./triggers;
0094 if (MaxLGSpec < temp2.GetMaximum()) MaxLGSpec = temp2.GetMaximum();
0095 LGTriggRuns[runNr] = temp2;
0096 }
0097 }
0098 if (profLGHG){
0099 TProfile temp3 = *profLGHG;
0100 temp3.SetName(Form("%s_Run%i",profLGHG->GetName(),runNr));
0101 temp3.SetDirectory(0);
0102
0103 LGHGTriggRuns[runNr] = temp3;
0104 }
0105
0106 if (extended == 4){
0107 if (histHG){
0108 TH1D temp = *histHG;
0109 temp.SetName(Form("%s_Run%i",histHG->GetName(),runNr));
0110 temp.SetDirectory(0);
0111 double scaler = 1./temp.GetEntries();
0112 temp.Scale(scaler);
0113 temp.GetYaxis()->SetTitle("Counts/ trigger");
0114 temp.Rebin(2);
0115 if (MinHGSpec > scaler) MinHGSpec = (double)scaler;
0116 if (MaxHGSpec < temp.GetMaximum()) MaxHGSpec = temp.GetMaximum();
0117 HGTriggRuns[runNr] = temp;
0118 }
0119 }
0120
0121 return true;
0122 }
0123
0124
0125 void TileTrend::FillMPV(double x, double hgmpv, double ehgmpv, double lgmpv, double elgmpv){
0126 gTrendHGLMPV.AddPoint (x,hgmpv );
0127 gTrendHGLMPV.SetPointError(gTrendHGLMPV.GetN()-1,0.,ehgmpv);
0128 if(hgmpv<MinHGMPV) MinHGMPV = hgmpv;
0129 if(hgmpv>MaxHGMPV) MaxHGMPV = hgmpv;
0130
0131 gTrendLGLMPV.AddPoint (x,lgmpv );
0132 gTrendLGLMPV.SetPointError(gTrendLGLMPV.GetN()-1,0.,elgmpv);
0133 if(lgmpv<MinLGMPV) MinLGMPV = lgmpv;
0134 if(lgmpv>MaxLGMPV) MaxLGMPV = lgmpv;
0135 }
0136
0137
0138 void TileTrend::FillLSigma(double x, double hglsig, double ehglsig, double lglsig, double elglsig){
0139 gTrendHGLSigma.AddPoint (x,hglsig );
0140 gTrendHGLSigma.SetPointError(gTrendHGLSigma.GetN()-1,0.,ehglsig);
0141 if(hglsig<MinHGLSigma ) MinHGLSigma = hglsig;
0142 if(hglsig>MaxHGLSigma ) MaxHGLSigma = hglsig;
0143
0144 gTrendLGLSigma.AddPoint (x,lglsig );
0145 gTrendLGLSigma.SetPointError(gTrendLGLSigma.GetN()-1,0.,elglsig);
0146 if(lglsig<MinLGLSigma ) MinLGLSigma = lglsig;
0147 if(lglsig>MaxLGLSigma ) MaxLGLSigma = lglsig;
0148 }
0149
0150
0151 void TileTrend::FillGSigma(double x, double hggsig, double ehggsig, double lggsig, double elggsig){
0152 gTrendHGGSigma.AddPoint (x,hggsig );
0153 gTrendHGGSigma.SetPointError(gTrendHGGSigma.GetN()-1,0.,ehggsig);
0154 if(hggsig<MinHGGSigma) MinHGGSigma = hggsig;
0155 if(hggsig>MaxHGGSigma) MaxHGGSigma = hggsig;
0156
0157 gTrendLGGSigma.AddPoint (x,lggsig );
0158 gTrendLGGSigma.SetPointError(gTrendLGGSigma.GetN()-1,0.,elggsig);
0159 if(lggsig<MinLGGSigma) MinLGGSigma = lggsig;
0160 if(lggsig>MaxLGGSigma) MaxLGGSigma = lggsig;
0161 }
0162
0163
0164 void TileTrend::FillSB(double x, double sbsig, double sbnoise){
0165 gTrendSBNoise.AddPoint (x,sbnoise );
0166 gTrendSBNoise.SetPointError(gTrendSBNoise.GetN()-1,0.,0.);
0167 if(sbnoise<MinSBNoise) MinSBNoise = sbnoise;
0168 if(sbnoise>MaxSBNoise) MaxSBNoise = sbnoise;
0169
0170 gTrendSBSignal.AddPoint (x,sbsig );
0171 gTrendSBSignal.SetPointError(gTrendSBSignal.GetN()-1,0.,0.);
0172 if(sbsig<MinSBSignal) MinSBSignal = sbsig;
0173 if(sbsig>MaxSBSignal) MaxSBSignal = sbsig;
0174 }
0175
0176
0177 void TileTrend::FillCorrOffset(double x, double lghgoff, double lghgoff_e, double hglgoff,double hglgoff_e ){
0178 gTrendLGHGOffset.AddPoint (x,lghgoff );
0179 gTrendLGHGOffset.SetPointError(gTrendLGHGOffset.GetN()-1,0.,lghgoff_e);
0180 if(lghgoff<MinLGHGOff && lghgoff != -10000.) MinLGHGOff = lghgoff;
0181 if(lghgoff>MaxLGHGOff && lghgoff != -10000.) MaxLGHGOff = lghgoff;
0182
0183 gTrendHGLGOffset.AddPoint (x,hglgoff );
0184 gTrendHGLGOffset.SetPointError(gTrendHGLGOffset.GetN()-1,0.,hglgoff_e);
0185 if(hglgoff<MinHGLGOff && hglgoff != -10000.) MinHGLGOff = hglgoff;
0186 if(hglgoff>MaxHGLGOff && hglgoff != -10000.) MaxHGLGOff = hglgoff;
0187 }
0188
0189
0190
0191
0192
0193
0194 TH1D* TileTrend::GetHGTriggRun(int run){
0195 std::map<int, TH1D>::iterator currRun;
0196 currRun=HGTriggRuns.find(run);
0197 if(currRun!=HGTriggRuns.end()){
0198 return &currRun->second;
0199 } else {
0200 return nullptr;
0201 }
0202 }
0203
0204 TH1D* TileTrend::GetLGTriggRun(int run){
0205 std::map<int, TH1D>::iterator currRun;
0206 currRun=LGTriggRuns.find(run);
0207 if(currRun!=LGTriggRuns.end()){
0208 return &currRun->second;
0209 } else {
0210 return nullptr;
0211 }
0212 }
0213
0214
0215 TProfile* TileTrend::GetLGHGTriggRun(int run){
0216 std::map<int, TProfile>::iterator currRun;
0217 currRun=LGHGTriggRuns.find(run);
0218 if(currRun!=LGHGTriggRuns.end()){
0219 return &currRun->second;
0220 } else {
0221 return nullptr;
0222 }
0223 }
0224
0225
0226
0227
0228
0229 bool TileTrend::DrawLGped(TString opt){
0230 gTrendLGped.Draw(opt.Data());
0231 return true;
0232 }
0233
0234 bool TileTrend::DrawHGped(TString opt){
0235 gTrendHGped.Draw(opt.Data());
0236 return true;
0237 }
0238
0239 bool TileTrend::DrawLGscale(TString opt){
0240 gTrendLGscale.Draw(opt.Data());
0241 return true;
0242 }
0243
0244 bool TileTrend::DrawHGscale(TString opt){
0245 gTrendHGscale.Draw(opt.Data());
0246 return true;
0247 }
0248
0249 bool TileTrend::DrawHGLGcorr(TString opt){
0250 gTrendHGLGcorr.Draw(opt.Data());
0251 return true;
0252 }
0253
0254 bool TileTrend::DrawLGHGcorr(TString opt){
0255 gTrendLGHGcorr.Draw(opt.Data());
0256 return true;
0257 }
0258
0259 bool TileTrend::DrawTrigger(TString opt){
0260 gTrendTrigger.Draw(opt.Data());
0261 return true;
0262 }
0263
0264 bool TileTrend::DrawSBNoise(TString opt){
0265 gTrendSBNoise.Draw(opt.Data());
0266 return true;
0267 }
0268
0269 bool TileTrend::DrawSBSignal(TString opt){
0270 gTrendSBSignal.Draw(opt.Data());
0271 return true;
0272 }
0273
0274 bool TileTrend::DrawHGLMPV(TString opt){
0275 gTrendHGLMPV.Draw(opt.Data());
0276 return true;
0277 }
0278
0279 bool TileTrend::DrawLGLMPV(TString opt){
0280 gTrendLGLMPV.Draw(opt.Data());
0281 return true;
0282 }
0283
0284 bool TileTrend::DrawHGLSigma(TString opt){
0285 gTrendHGLSigma.Draw(opt.Data());
0286 return true;
0287 }
0288
0289 bool TileTrend::DrawLGLSigma(TString opt){
0290 gTrendLGLSigma.Draw(opt.Data());
0291 return true;
0292 }
0293
0294 bool TileTrend::DrawHGGSigma(TString opt){
0295 gTrendHGGSigma.Draw(opt.Data());
0296 return true;
0297 }
0298
0299 bool TileTrend::DrawLGGSigma(TString opt){
0300 gTrendLGGSigma.Draw(opt.Data());
0301 return true;
0302 }
0303
0304 bool TileTrend::DrawHGLGOffset(TString opt){
0305 gTrendHGLGOffset.Draw(opt.Data());
0306 return true;
0307 }
0308
0309 bool TileTrend::DrawLGHGOffset(TString opt){
0310 gTrendLGHGOffset.Draw(opt.Data());
0311 return true;
0312 }
0313
0314
0315
0316
0317
0318 bool TileTrend::SetLineColor(uint col){
0319 gTrendLGped .SetLineColor(col);
0320 gTrendHGped .SetLineColor(col);
0321 gTrendLGscale .SetLineColor(col);
0322 gTrendHGscale .SetLineColor(col);
0323 gTrendHGLGcorr .SetLineColor(col);
0324 gTrendLGHGcorr .SetLineColor(col);
0325 gTrendHGLGOffset .SetLineColor(col);
0326 gTrendLGHGOffset .SetLineColor(col);
0327 if (extended == 1 || extended == 2 ){
0328 gTrendTrigger .SetLineColor(col);
0329 gTrendSBNoise .SetLineColor(col);
0330 gTrendSBSignal.SetLineColor(col);
0331 }
0332 if (extended == 1){
0333 gTrendHGLMPV .SetLineColor(col);
0334 gTrendLGLMPV .SetLineColor(col);
0335 gTrendHGLSigma.SetLineColor(col);
0336 gTrendLGLSigma.SetLineColor(col);
0337 gTrendHGGSigma.SetLineColor(col);
0338 gTrendLGGSigma.SetLineColor(col);
0339 }
0340 return true;
0341 }
0342
0343 bool TileTrend::SetMarkerColor(uint col){
0344 gTrendLGped .SetMarkerColor(col);
0345 gTrendHGped .SetMarkerColor(col);
0346 gTrendLGscale .SetMarkerColor(col);
0347 gTrendHGscale .SetMarkerColor(col);
0348 gTrendHGLGcorr .SetMarkerColor(col);
0349 gTrendLGHGcorr .SetMarkerColor(col);
0350 gTrendHGLGOffset .SetMarkerColor(col);
0351 gTrendLGHGOffset .SetMarkerColor(col);
0352 if (extended == 1 || extended == 2 ){
0353 gTrendTrigger .SetMarkerColor(col);
0354 gTrendSBNoise .SetMarkerColor(col);
0355 gTrendSBSignal.SetMarkerColor(col);
0356 }
0357 if (extended == 1){
0358 gTrendHGLMPV .SetMarkerColor(col);
0359 gTrendLGLMPV .SetMarkerColor(col);
0360 gTrendHGLSigma.SetMarkerColor(col);
0361 gTrendLGLSigma.SetMarkerColor(col);
0362 gTrendHGGSigma.SetMarkerColor(col);
0363 gTrendLGGSigma.SetMarkerColor(col);
0364 }
0365 return true;
0366 }
0367
0368 bool TileTrend::SetMarkerStyle(uint col){
0369 gTrendLGped .SetMarkerStyle(col);
0370 gTrendHGped .SetMarkerStyle(col);
0371 gTrendLGscale .SetMarkerStyle(col);
0372 gTrendHGscale .SetMarkerStyle(col);
0373 gTrendHGLGcorr .SetMarkerStyle(col);
0374 gTrendLGHGcorr .SetMarkerStyle(col);
0375 gTrendHGLGOffset .SetMarkerStyle(col);
0376 gTrendLGHGOffset .SetMarkerStyle(col);
0377 if (extended == 1 || extended == 2 ){
0378 gTrendTrigger .SetMarkerStyle(col);
0379 gTrendSBNoise .SetMarkerStyle(col);
0380 gTrendSBSignal.SetMarkerStyle(col);
0381 }
0382 if (extended == 1){
0383 gTrendHGLMPV .SetMarkerStyle(col);
0384 gTrendLGLMPV .SetMarkerStyle(col);
0385 gTrendHGLSigma.SetMarkerStyle(col);
0386 gTrendLGLSigma.SetMarkerStyle(col);
0387 gTrendHGGSigma.SetMarkerStyle(col);
0388 gTrendLGGSigma.SetMarkerStyle(col);
0389 }
0390 return true;
0391 }
0392
0393 bool TileTrend::SetXAxisTitle(TString title){
0394 gTrendLGped .GetXaxis()->SetTitle(title.Data());
0395 gTrendHGped .GetXaxis()->SetTitle(title.Data());
0396 gTrendLGscale .GetXaxis()->SetTitle(title.Data());
0397 gTrendHGscale .GetXaxis()->SetTitle(title.Data());
0398 gTrendHGLGcorr .GetXaxis()->SetTitle(title.Data());
0399 gTrendLGHGcorr .GetXaxis()->SetTitle(title.Data());
0400 gTrendHGLGOffset .GetXaxis()->SetTitle(title.Data());
0401 gTrendLGHGOffset .GetXaxis()->SetTitle(title.Data());
0402 if (extended == 1 || extended == 2 ){
0403 gTrendTrigger .GetXaxis()->SetTitle(title.Data());
0404 gTrendSBNoise .GetXaxis()->SetTitle(title.Data());
0405 gTrendSBSignal.GetXaxis()->SetTitle(title.Data());
0406 }
0407 if (extended == 1){
0408 gTrendHGLMPV .GetXaxis()->SetTitle(title.Data());
0409 gTrendLGLMPV .GetXaxis()->SetTitle(title.Data());
0410 gTrendHGLSigma.GetXaxis()->SetTitle(title.Data());
0411 gTrendLGLSigma.GetXaxis()->SetTitle(title.Data());
0412 gTrendHGGSigma.GetXaxis()->SetTitle(title.Data());
0413 gTrendLGGSigma.GetXaxis()->SetTitle(title.Data());
0414 }
0415 return true;
0416 }
0417
0418
0419
0420
0421 void TileTrend::Sort(){
0422 gTrendLGped .Sort();
0423 gTrendHGped .Sort();
0424 gTrendLGscale .Sort();
0425 gTrendHGscale .Sort();
0426 gTrendHGLGcorr .Sort();
0427 gTrendLGHGcorr .Sort();
0428 gTrendHGLGOffset .Sort();
0429 gTrendLGHGOffset .Sort();
0430 if (extended == 1 || extended == 2 ){
0431 gTrendTrigger .Sort();
0432 gTrendSBNoise .Sort();
0433 gTrendSBSignal.Sort();
0434 }
0435 if (extended == 1){
0436 gTrendHGLMPV .Sort();
0437 gTrendLGLMPV .Sort();
0438 gTrendHGLSigma.Sort();
0439 gTrendLGLSigma.Sort();
0440 gTrendHGGSigma.Sort();
0441 gTrendLGGSigma.Sort();
0442 }
0443 return;
0444 }
0445
0446
0447
0448
0449 bool TileTrend::Write(TFile* f){
0450 f->cd();
0451 gTrendLGped .Write();
0452 gTrendHGped .Write();
0453 gTrendLGscale .Write();
0454 gTrendHGscale .Write();
0455 gTrendHGLGcorr .Write();
0456 gTrendLGHGcorr .Write();
0457 gTrendHGLGOffset .Write();
0458 gTrendLGHGOffset .Write();
0459 if (extended == 1 || extended == 2 ){
0460 gTrendTrigger .Write();
0461 gTrendSBNoise .Write();
0462 gTrendSBSignal.Write();
0463 }
0464 if (extended == 1){
0465 gTrendHGLMPV .Write();
0466 gTrendLGLMPV .Write();
0467 gTrendHGLSigma.Write();
0468 gTrendLGLSigma.Write();
0469 gTrendHGGSigma.Write();
0470 gTrendLGGSigma.Write();
0471 }
0472 return true;
0473 }
