62 B2INFO(
"eclTimeShiftsAlgorithm parameters:");
65 B2INFO(
"timeShiftForPlotStyle = {");
66 for (
int crateTest = 0; crateTest < 51; crateTest++) {
80 const int iRun = expRunList[0].second;
81 const int iExp = expRunList[0].first;
91 vector< vector<double> > allCrates_crate_times ;
92 vector< vector<double> > allCrates_run_nums ;
93 vector< vector<double> > allCrates_time_unc ;
94 vector< vector<double> > allCrates_crystalCrate_times ;
95 vector< vector<double> > allCrates_crystalCrate_times_unc ;
97 vector<int> allRunNums;
99 vector<double> mean_crystalCrate_time_ns(
m_numCrates, 0);
101 vector< double > blank_vector = {} ;
102 vector< int > blank_vector_int = {} ;
103 for (
int temp_crate_id = 0; temp_crate_id <
m_numCrates; temp_crate_id++) {
104 allCrates_crate_times.push_back(blank_vector) ;
105 allCrates_run_nums.push_back(blank_vector) ;
106 allCrates_time_unc.push_back(blank_vector) ;
107 allCrates_crystalCrate_times.push_back(blank_vector) ;
108 allCrates_crystalCrate_times_unc.push_back(blank_vector) ;
122 B2ERROR(
"Tree of calibration constants does not exist.");
125 B2INFO(
"Number of Entries in tree_perCrystal was " << tree_perCrys->GetEntries());
132 tree_perCrys->SetBranchAddress(
"crystalID", &
m_crystalID);
133 tree_perCrys->SetBranchAddress(
"crateID", &
m_crateID);
141 int referenceRunNum = -1;
142 int referenceExpNum = -1;
144 int previousRunNumTree = -1 ;
147 vector<double> Crate_time_unc_ns_tree(
m_numCrates) ;
148 vector<double> crystalCrate_time_ns_tree(
m_numCrates);
149 vector<double> crystalCrate_time_unc_ns_tree(
m_numCrates);
152 Int_t numEntriesCrysTree = (Int_t)tree_perCrys->GetEntries();
155 for (Int_t tree_crys_i = 0; tree_crys_i < numEntriesCrysTree; tree_crys_i++) {
156 for (Int_t tree_crys_j = 0; tree_crys_j <
m_numCrystals; tree_crys_j++) {
157 tree_perCrys->GetEntry(tree_crys_i);
164 if (tree_crys_j == 0) {
173 B2ERROR(
"m_exp_perCrystal, referenceExpNum" <<
m_exp_perCrystal <<
", " << referenceExpNum);
174 B2ERROR(
"m_run_perCrystal, referenceRunNum" <<
m_run_perCrystal <<
", " << referenceRunNum);
175 B2ERROR(
"m_run_perCrystal, previousRunNumTree" <<
m_run_perCrystal <<
", " << previousRunNumTree);
176 B2ERROR(
"Exp/run number problem");
184 Crate_time_unc_ns_tree[crateID_temp - 1] =
m_crateTimeUnc * TICKS_TO_NS ;
187 B2INFO(
"m_exp_perCrystal, m_run_perCrystal, cell ID (0..8735), m_crateID, m_crateTimeConst = " <<
m_exp_perCrystal <<
", " <<
191 crystalCrate_time_unc_ns_tree[crateID_temp - 1] = TICKS_TO_NS *
sqrt(
194 }
else if (tree_crys_j == 0 || tree_crys_j == 8735) {
195 B2INFO(
"m_exp_perCrystal, m_run_perCrystal, cell ID (0..8735), m_crateID, m_crateTimeConst = " <<
m_exp_perCrystal <<
", " <<
198 B2DEBUG(22,
"m_exp_perCrystal, m_run_perCrystal, cell ID (0..8735), m_crateID, m_crateTimeConst = " <<
m_exp_perCrystal <<
", " <<
207 bool savedThisRunNum =
false;
208 for (
int iCrate = 0; iCrate <
m_numCrates; iCrate++) {
209 double tcrate = Crate_time_ns_tree[iCrate] ;
210 double tcrate_unc = Crate_time_unc_ns_tree[iCrate];
211 double tcrystalCrate = crystalCrate_time_ns_tree[iCrate];
212 double tcrystalCrate_unc = crystalCrate_time_unc_ns_tree[iCrate];
218 allCrates_crate_times[iCrate].push_back(tcrate) ;
220 allCrates_time_unc[iCrate].push_back(tcrate_unc) ;
221 allCrates_crystalCrate_times[iCrate].push_back(tcrystalCrate) ;
222 allCrates_crystalCrate_times_unc[iCrate].push_back(tcrystalCrate_unc) ;
224 mean_crystalCrate_time_ns[iCrate] += tcrystalCrate ;
226 if (!savedThisRunNum) {
228 savedThisRunNum =
true;
236 B2INFO(
"Crate " << ic + 1 <<
", t_crate = " << Crate_time_tick_tree[ic] <<
" ticks = "
237 << Crate_time_ns_tree[ic] <<
" +- " << Crate_time_unc_ns_tree[ic]
238 <<
" ns; t crys+crate (no shifts) = " << crystalCrate_time_ns_tree[ic] <<
" +- "
239 << crystalCrate_time_unc_ns_tree[ic] <<
" ns") ;
247 B2INFO(
"Finished reading tree calibration constants. Now extracting here by stepping through runs.");
257 bool minRunNumBool =
false;
258 bool maxRunNumBool =
false;
264 int expNumber = expRun.first;
265 int runNumber = expRun.second;
266 if (!minRunNumBool) {
267 minExpNum = expNumber;
268 minRunNum = runNumber;
269 minRunNumBool =
true;
271 if (!maxRunNumBool) {
272 maxExpNum = expNumber;
273 maxRunNum = runNumber;
274 maxRunNumBool =
true;
276 if (((minRunNum > runNumber) && (minExpNum >= expNumber)) ||
277 (minExpNum > expNumber)) {
278 minExpNum = expNumber;
279 minRunNum = runNumber;
281 if (((maxRunNum < runNumber) && (maxExpNum <= expNumber)) ||
282 (maxExpNum < expNumber)) {
283 maxExpNum = expNumber;
284 maxRunNum = runNumber;
288 B2INFO(
"minExpNum = " << minExpNum) ;
289 B2INFO(
"minRunNum = " << minRunNum) ;
290 B2INFO(
"maxExpNum = " << maxExpNum) ;
291 B2INFO(
"maxRunNum = " << maxRunNum) ;
294 if (minExpNum != maxExpNum) {
295 B2ERROR(
"The runs must all come from the same experiment");
299 int experiment = minExpNum;
317 ExpRun chosenRun = runs.front();
318 B2INFO(
"merging using the ExpRun (" << chosenRun.second <<
"," << chosenRun.first <<
")");
324 bool allObjectsFound =
true;
329 allObjectsFound =
false;
330 B2ERROR(
"No valid DBObject found for 'ECLCrystalTimeOffset'");
335 allObjectsFound =
false;
336 B2ERROR(
"No valid DBObject found for 'ECLCrateTimeOffset'");
340 allObjectsFound =
false;
341 B2ERROR(
"No valid DBObject found for 'refCrysIDzeroingCrate'");
345 if (allObjectsFound) {
346 B2INFO(
"Valid objects found for 'ECLCrystalTimeOffset'");
347 B2INFO(
"Valid object found for 'ECLCrateTimeOffset'");
348 B2INFO(
"Valid object found for 'refCrysIDzeroingCrate'");
350 B2INFO(
"eclTimeShiftsAlgorithm: Exiting with failure. Some missing valid objects.");
359 B2INFO(
"Loaded 'ECLCrystalTimeOffset' calibrations");
364 B2INFO(
"Loaded 'ECLCrateTimeOffset' calibration with default exp/run");
366 B2INFO(
"eclTimeShiftsAlgorithm:: loaded ECLCrateTimeOffset from the database"
370 for (
int cellID = 1; cellID <=
m_numCrystals; cellID += 511) {
371 B2INFO(
"crystalCalib = " << crystalCalib[cellID - 1]);
372 B2INFO(
"crateCalib = " << crateCalib[cellID - 1]);
376 for (
int icrate = 0; icrate <
m_numCrates; icrate++) {
377 B2INFO(
"reference crystal for crate " << icrate + 1 <<
" = " << refCrystals[icrate]);
384 for (
int run = minRunNum; run <= maxRunNum; run++) {
385 B2INFO(
"---------") ;
386 B2INFO(
"Looking at run " << run) ;
389 if (it != allRunNums.end()) {
390 int pos = it - allRunNums.begin() ;
391 B2INFO(
"allRunNums[" << pos <<
"] = " << allRunNums[pos]);
392 B2INFO(
"Run " << run <<
" already processed so skipping it.");
395 B2INFO(
"New run. Starting to extract information");
399 int eventNumberForCrates = 1;
407 evtPtr.
construct(eventNumberForCrates, run, experiment);
420 crystalMapper->initFromDB();
423 B2INFO(
"eclTimeShiftsAlgorithm:: loaded ECLCrystalTimeOffset from the database"
426 B2INFO(
"eclTimeShiftsAlgorithm:: loaded ECLCrateTimeOffset from the database"
434 vector<float> crystalTimeOffsetsCalib;
435 vector<float> crystalTimeOffsetsCalibUnc;
439 vector<float> crateTimeOffsetsCalib;
440 vector<float> crateTimeOffsetsCalibUnc;
452 vector<double> crystalCrate_time_unc_ns(
m_numCrates);
455 int crateID_temp = crystalMapper->getCrateID(crysID) ;
456 Crate_time_ns[crateID_temp - 1] = crateTimeOffsetsCalib[crysID - 1] * TICKS_TO_NS ;
457 Crate_time_tick[crateID_temp - 1] = crateTimeOffsetsCalib[crysID - 1] ;
458 Crate_time_unc_ns[crateID_temp - 1] = crateTimeOffsetsCalibUnc[crysID - 1] * TICKS_TO_NS ;
460 if (crysID == refCrystals[crateID_temp - 1]) {
461 crystalCrate_time_ns[crateID_temp - 1] = (crystalTimeOffsetsCalib[crysID - 1] +
462 crateTimeOffsetsCalib[crysID - 1]) * TICKS_TO_NS;
464 crystalCrate_time_unc_ns[crateID_temp - 1] = TICKS_TO_NS *
sqrt(
465 (crateTimeOffsetsCalibUnc[crysID - 1] * crateTimeOffsetsCalibUnc[crysID - 1]) +
466 (crystalTimeOffsetsCalibUnc[crysID - 1] * crystalTimeOffsetsCalibUnc[crysID - 1])) ;
471 for (
int iCrate = 0; iCrate <
m_numCrates; iCrate++) {
472 double tcrate = Crate_time_ns[iCrate] ;
473 double tcrate_unc = Crate_time_unc_ns[iCrate];
474 double tcrystalCrate = crystalCrate_time_ns[iCrate];
475 double tcrystalCrate_unc = crystalCrate_time_unc_ns[iCrate];
481 allCrates_crate_times[iCrate].push_back(tcrate) ;
482 allCrates_run_nums[iCrate].push_back(run) ;
483 allCrates_time_unc[iCrate].push_back(tcrate_unc) ;
484 allCrates_crystalCrate_times[iCrate].push_back(tcrystalCrate) ;
485 allCrates_crystalCrate_times_unc[iCrate].push_back(tcrystalCrate_unc) ;
487 mean_crystalCrate_time_ns[iCrate] += tcrystalCrate ;
495 B2INFO(
"Crate " << ic + 1 <<
", t_crate = " << Crate_time_tick[ic] <<
" ticks = "
496 << Crate_time_ns[ic] <<
" +- " << Crate_time_unc_ns[ic]
497 <<
" ns; t crys+crate (no shift) = " << crystalCrate_time_ns[ic] <<
" +- "
498 << crystalCrate_time_unc_ns[ic] <<
" ns") ;
505 B2INFO(
LogVar(
"IOV_exp_high", IOV_exp_high));
506 B2INFO(
LogVar(
"IOV_run_high", IOV_run_high));
507 if (IOV_run_high == -1) {
508 B2INFO(
"IOV_run_high is -1 so stop looping over all runs");
511 B2INFO(
"Set run number to higher iov run number");
514 B2INFO(
"now set run = " << run);
527 B2INFO(
"Shift all run crys+crate+off times. Show the results for a subset of crates/runs:");
528 for (
int iCrate = 0; iCrate <
m_numCrates; iCrate++) {
529 double mean_time = mean_crystalCrate_time_ns[iCrate] / allCrates_crate_times[iCrate].size() ;
530 B2INFO(
"Mean crys+crate times for all runs used as offset (crate " << iCrate + 1 <<
") = " << mean_time);
532 for (
long unsigned int jRun = 0; jRun < allCrates_crate_times[iCrate].size(); jRun++) {
534 if (jRun < 50 || iCrate == 1 || iCrate == 40 || iCrate == 51) {
535 B2INFO(
"allCrates_crystalCrate_times(crate " << iCrate + 1 <<
", run counter " << jRun + 1 <<
", runNum " <<
536 allCrates_run_nums[iCrate][jRun] <<
" | after shifting mean) = " <<
537 allCrates_crystalCrate_times[iCrate][jRun]);
548 TFile* tcratefile = 0;
551 string runNumsString = string(
"_") + to_string(minExpNum) +
"_" + to_string(minRunNum) + string(
"-") +
552 to_string(maxExpNum) +
"_" + to_string(maxRunNum);
554 TString fname = debugFilename;
556 tcratefile =
new TFile(fname,
"recreate");
558 B2INFO(
"Debugging histograms written to " << fname);
561 B2INFO(
"Starting to make crate time jump plots for crate " << i + 1);
562 shared_ptr< TCanvas > cSmart(
new TCanvas);
564 Double_t* single_crate_crate_times = &allCrates_crate_times[i][0] ;
565 Double_t* single_crate_run_nums = &allCrates_run_nums[i][0] ;
566 Double_t* single_crate_time_unc = &allCrates_time_unc[i][0] ;
567 Double_t* single_crate_crystalCrate_times = &allCrates_crystalCrate_times[i][0] ;
568 Double_t* single_crate_crystalCrate_times_unc = &allCrates_crystalCrate_times_unc[i][0] ;
569 B2INFO(
"Done setting up the arrays for the crate " << i + 1);
572 ss << setw(2) << setfill(
'0') << i + 1 ;
573 string paddedCrateID(ss.str());
576 shared_ptr< TGraphErrors > g_tcrate_vs_runNum(
new TGraphErrors(allCrates_crate_times[i].size(), single_crate_run_nums,
577 single_crate_crate_times, NULL, single_crate_time_unc)) ;
580 string tgraph_title = string(
"e") + to_string(minExpNum) + string(
"r") + to_string(minRunNum) +
581 string(
"-e") + to_string(maxExpNum) + string(
"r") + to_string(maxRunNum) ;
583 string tgraph_name_short =
"crateTimeVSrunNum_" ;
584 tgraph_name_short = tgraph_name_short + runNumsString +
"_crate";
586 tgraph_title = tgraph_title + string(
"_crate") + paddedCrateID ;
587 tgraph_name_short = tgraph_name_short + paddedCrateID ;
588 tgraph_title = tgraph_title + string(
" (") + to_string(
m_tcrate_min_cut) + string(
" < tcrate < ") +
592 g_tcrate_vs_runNum->SetName(tgraph_name_short.c_str()) ;
593 g_tcrate_vs_runNum->SetTitle(tgraph_title.c_str()) ;
594 g_tcrate_vs_runNum->GetXaxis()->SetTitle(
"Run number") ;
595 g_tcrate_vs_runNum->GetYaxis()->SetTitle(
"Crate time [ns]") ;
599 g_tcrate_vs_runNum->Draw(
"AP") ;
600 g_tcrate_vs_runNum->SetMarkerSize(0.8) ;
601 g_tcrate_vs_runNum->Draw(
"AP") ;
603 shared_ptr< TLatex > Leg1(
new TLatex);
605 Leg1->SetTextAlign(11);
606 Leg1->SetTextFont(42);
607 Leg1->SetTextSize(0.035);
608 Leg1->SetTextColor(1);
611 g_tcrate_vs_runNum->Write() ;
612 cSmart->SaveAs((tgraph_name_short +
string(
".pdf")).c_str()) ;
614 B2INFO(
"Saved pdf: " << tgraph_name_short <<
".pdf");
618 shared_ptr< TGraphErrors > g_crateCrystalTime_vs_runNum(
new TGraphErrors(allCrates_crystalCrate_times[i].size(),
619 single_crate_run_nums,
620 single_crate_crystalCrate_times, NULL, single_crate_crystalCrate_times_unc)) ;
622 tgraph_title = string(
"e") + to_string(minExpNum) + string(
"r") + to_string(minRunNum) +
623 string(
"-e") + to_string(maxExpNum) + string(
"r") + to_string(maxRunNum) ;
625 tgraph_name_short =
"crystalCrateTimeVSrunNum_" ;
626 tgraph_name_short = tgraph_name_short + runNumsString +
"_crate";
628 tgraph_title = tgraph_title + string(
"_crate") + paddedCrateID ;
629 tgraph_name_short = tgraph_name_short + paddedCrateID ;
630 tgraph_title = tgraph_title + string(
" (") + to_string(
m_tcrate_min_cut) + string(
" < tcrate < ") +
635 g_crateCrystalTime_vs_runNum->SetName(tgraph_name_short.c_str()) ;
636 g_crateCrystalTime_vs_runNum->SetTitle(tgraph_title.c_str()) ;
637 g_crateCrystalTime_vs_runNum->GetXaxis()->SetTitle(
"Run number") ;
638 g_crateCrystalTime_vs_runNum->GetYaxis()->SetTitle(
"Crate time + Crystal time + centring overall offset [ns]") ;
642 g_crateCrystalTime_vs_runNum->Draw(
"AP") ;
643 g_crateCrystalTime_vs_runNum->SetMarkerSize(0.8) ;
644 g_crateCrystalTime_vs_runNum->Draw(
"AP") ;
646 g_crateCrystalTime_vs_runNum->Write() ;
647 cSmart->SaveAs((tgraph_name_short +
string(
".pdf")).c_str()) ;
649 B2INFO(
"Saved pdf: " << tgraph_name_short <<
".pdf");
658 int numRunsWithCrateTimes = allCrates_crystalCrate_times[i].size();
659 vector<Double_t> counterVec(numRunsWithCrateTimes);
664 vector<pair<int, double> > runNum_index_pairs;
668 for (
int pairIndex = 0; pairIndex < numRunsWithCrateTimes; pairIndex++) {
669 runNum_index_pairs.push_back(make_pair(allCrates_run_nums[i][pairIndex], pairIndex));
672 B2INFO(
"Crate id = " << i + 1);
673 B2INFO(
"Unsorted run numbers");
674 for (
int runCounter = 0; runCounter < numRunsWithCrateTimes; runCounter++) {
675 B2INFO(
"Run number, run number vector index = " << runNum_index_pairs[runCounter].first <<
", " <<
676 runNum_index_pairs[runCounter].second);
680 sort(runNum_index_pairs.begin(), runNum_index_pairs.end());
683 for (
int runCounter = 0; runCounter < numRunsWithCrateTimes; runCounter++) {
684 counterVec[runNum_index_pairs[runCounter].second] = runCounter + 1;
687 B2INFO(
"Run numbers with index and times");
688 for (
int runCounter = 0; runCounter < numRunsWithCrateTimes; runCounter++) {
689 int idx = (int) round(counterVec[runCounter]);
690 B2INFO(
"Vector index, Run number, run number sorting order index, tcrystal+tcrate+shifts = " << runCounter <<
", " <<
691 allCrates_run_nums[i][runCounter] <<
", " << idx <<
", " << single_crate_crystalCrate_times[idx - 1] <<
" ns");
695 if (numRunsWithCrateTimes > 0) {
696 shared_ptr< TGraphErrors > g_crateCrystalTime_vs_runCounter(
new TGraphErrors(numRunsWithCrateTimes, &counterVec[0],
697 single_crate_crystalCrate_times, NULL, single_crate_crystalCrate_times_unc)) ;
699 tgraph_title = string(
"e") + to_string(minExpNum) + string(
"r") + to_string(minRunNum) +
700 string(
"-e") + to_string(maxExpNum) + string(
"r") + to_string(maxRunNum) ;
703 tgraph_name_short =
"crystalCrateTimeVSrunCounter_" ;
704 tgraph_name_short = tgraph_name_short + runNumsString +
"_crate";
707 tgraph_title = tgraph_title + string(
"_crate") + paddedCrateID ;
708 tgraph_name_short = tgraph_name_short + paddedCrateID ;
709 tgraph_title = tgraph_title + string(
" (") + to_string(
m_tcrate_min_cut) + string(
" < tcrate < ") +
714 g_crateCrystalTime_vs_runCounter->SetName(tgraph_name_short.c_str()) ;
715 g_crateCrystalTime_vs_runCounter->SetTitle(tgraph_title.c_str()) ;
716 g_crateCrystalTime_vs_runCounter->GetXaxis()->SetTitle(
"Run counter (remove gaps from run numbers)") ;
717 g_crateCrystalTime_vs_runCounter->GetYaxis()->SetTitle(
"Crate time + Crystal time + centring overall offset [ns]") ;
720 g_crateCrystalTime_vs_runCounter->GetXaxis()->SetRangeUser(0, numRunsWithCrateTimes + 1) ;
722 g_crateCrystalTime_vs_runCounter->Draw(
"AP") ;
723 g_crateCrystalTime_vs_runCounter->SetMarkerSize(0.8) ;
724 g_crateCrystalTime_vs_runCounter->Draw(
"AP") ;
726 g_crateCrystalTime_vs_runCounter->Write() ;
727 cSmart->SaveAs((tgraph_name_short +
string(
".pdf")).c_str()) ;
728 B2INFO(
"Saved pdf: " << tgraph_name_short <<
".pdf");
730 B2INFO(
"Finished making crate time jump plots for crate " << i + 1);
732 B2INFO(
"Crate " << i + 1 <<
" has no entries that pass all the cuts so no crystalCrateTimeVSrunCounter_crate plot will be made.");
741 double smallThreshold = 1 ;
742 double largeThreshold = 6.5 ;
744 B2INFO(
"======================= Crate time jumps =========================");
745 B2INFO(
"======================= Small threshold jumps ====================");
746 B2INFO(
"Crate ID = 1..52");
747 B2INFO(
"==================================================================");
750 int numRunsWithCrateTimes = allCrates_crystalCrate_times[i].size();
751 for (
int runCounter = 0; runCounter < numRunsWithCrateTimes - 1; runCounter++) {
752 int run_i = allCrates_run_nums[i][runCounter] ;
753 int run_f = allCrates_run_nums[i][runCounter + 1] ;
754 double time_i = allCrates_crystalCrate_times[i][runCounter] ;
755 double time_f = allCrates_crystalCrate_times[i][runCounter + 1] ;
757 if (fabs(time_f - time_i) > smallThreshold) {
758 B2INFO(
"Crate " << i + 1 <<
" has crate time jump > " << smallThreshold <<
" ns: t(run " << run_f <<
") = " << time_f <<
759 " ns - t(run " << run_i <<
") = " << time_i <<
" ns = " << time_f - time_i);
765 B2INFO(
"~~~~~~~~~~~~~~~~~~~~~~~ Large threshold jumps ~~~~~~~~~~~~~~~~~~~~");
766 B2INFO(
"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
769 int numRunsWithCrateTimes = allCrates_crystalCrate_times[i].size();
770 for (
int runCounter = 0; runCounter < numRunsWithCrateTimes - 1; runCounter++) {
771 int run_i = allCrates_run_nums[i][runCounter] ;
772 int run_f = allCrates_run_nums[i][runCounter + 1] ;
773 double time_i = allCrates_crystalCrate_times[i][runCounter] ;
774 double time_f = allCrates_crystalCrate_times[i][runCounter + 1] ;
776 if (fabs(time_f - time_i) > largeThreshold) {
777 B2INFO(
"WARNING: Crate " << i + 1 <<
" has crate time jump > " << largeThreshold <<
" ns: t(run " << run_f <<
") = " << time_f <<
778 " ns - t(run " << run_i <<
") = " << time_i <<
" ns = " << time_f - time_i);
787 TDirectory* executeDir = gDirectory;