Belle II Software development
Public Types | Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
eclTimeShiftsAlgorithm Class Reference

Calibrate ecl crystals using previously created payloads. More...

#include <eclTimeShiftsAlgorithm.h>

Inheritance diagram for eclTimeShiftsAlgorithm:
CalibrationAlgorithm

Public Types

enum  EResult {
  c_OK ,
  c_Iterate ,
  c_NotEnoughData ,
  c_Failure ,
  c_Undefined
}
 The result of calibration. More...
 

Public Member Functions

 eclTimeShiftsAlgorithm ()
 ..Constructor
 
 ~eclTimeShiftsAlgorithm ()
 ..Destructor
 
std::string getPrefix () const
 Get the prefix used for getting calibration data.
 
bool checkPyExpRun (PyObject *pyObj)
 Checks that a PyObject can be successfully converted to an ExpRun type.
 
Calibration::ExpRun convertPyExpRun (PyObject *pyObj)
 Performs the conversion of PyObject to ExpRun.
 
std::string getCollectorName () const
 Alias for prefix.
 
void setPrefix (const std::string &prefix)
 Set the prefix used to identify datastore objects.
 
void setInputFileNames (PyObject *inputFileNames)
 Set the input file names used for this algorithm from a Python list.
 
PyObject * getInputFileNames ()
 Get the input file names used for this algorithm and pass them out as a Python list of unicode strings.
 
std::vector< Calibration::ExpRun > getRunListFromAllData () const
 Get the complete list of runs from inspection of collected data.
 
RunRange getRunRangeFromAllData () const
 Get the complete RunRange from inspection of collected data.
 
IntervalOfValidity getIovFromAllData () const
 Get the complete IoV from inspection of collected data.
 
void fillRunToInputFilesMap ()
 Fill the mapping of ExpRun -> Files.
 
std::string getGranularity () const
 Get the granularity of collected data.
 
EResult execute (std::vector< Calibration::ExpRun > runs={}, int iteration=0, IntervalOfValidity iov=IntervalOfValidity())
 Runs calibration over vector of runs for a given iteration.
 
EResult execute (PyObject *runs, int iteration=0, IntervalOfValidity iov=IntervalOfValidity())
 Runs calibration over Python list of runs. Converts to C++ and then calls the other execute() function.
 
std::list< Database::DBImportQuery > & getPayloads ()
 Get constants (in TObjects) for database update from last execution.
 
std::list< Database::DBImportQuery > getPayloadValues ()
 Get constants (in TObjects) for database update from last execution but passed by VALUE.
 
bool commit ()
 Submit constants from last calibration into database.
 
bool commit (std::list< Database::DBImportQuery > payloads)
 Submit constants from a (potentially previous) set of payloads.
 
const std::string & getDescription () const
 Get the description of the algorithm (set by developers in constructor)
 
bool loadInputJson (const std::string &jsonString)
 Load the m_inputJson variable from a string (useful from Python interface). The return bool indicates success or failure.
 
const std::string dumpOutputJson () const
 Dump the JSON string of the output JSON object.
 
const std::vector< Calibration::ExpRun > findPayloadBoundaries (std::vector< Calibration::ExpRun > runs, int iteration=0)
 Used to discover the ExpRun boundaries that you want the Python CAF to execute on. This is optional and only used in some.
 
template<>
std::shared_ptr< TTree > getObjectPtr (const std::string &name, const std::vector< Calibration::ExpRun > &requestedRuns)
 Specialization of getObjectPtr<TTree>.
 

Public Attributes

std::string debugFilenameBase
 Name of file with debug output, eclTimeShiftsAlgorithm.root by default.
 
double timeShiftForPlotStyle [52]
 List of time offsets, one per crate, used just to centre the time constants around zero.
 
double crysCrateShift_min
 Plotting time min for crystal+crate shift plots.
 
double crysCrateShift_max
 Plotting time max for crystal+crate shift plots.
 
bool algorithmReadPayloads
 Whether or not to have the algorithm code to loop over all the runs and read the payloads itself.
 

Protected Member Functions

EResult calibrate () override
 ..Run algorithm
 
void setInputFileNames (std::vector< std::string > inputFileNames)
 Set the input file names used for this algorithm.
 
virtual bool isBoundaryRequired (const Calibration::ExpRun &)
 Given the current collector data, make a decision about whether or not this run should be the start of a payload boundary.
 
virtual void boundaryFindingSetup (std::vector< Calibration::ExpRun >, int)
 If you need to make some changes to your algorithm class before 'findPayloadBoundaries' is run, make them in this function.
 
virtual void boundaryFindingTearDown ()
 Put your algorithm back into a state ready for normal execution if you need to.
 
const std::vector< Calibration::ExpRun > & getRunList () const
 Get the list of runs for which calibration is called.
 
int getIteration () const
 Get current iteration.
 
std::vector< std::string > getVecInputFileNames () const
 Get the input file names used for this algorithm as a STL vector.
 
template<class T >
std::shared_ptr< T > getObjectPtr (const std::string &name, const std::vector< Calibration::ExpRun > &requestedRuns)
 Get calibration data object by name and list of runs, the Merge function will be called to generate the overall object.
 
template<class T >
std::shared_ptr< T > getObjectPtr (std::string name)
 Get calibration data object (for all runs the calibration is requested for) This function will only work during or after execute() has been called once.
 
template<>
shared_ptr< TTree > getObjectPtr (const string &name, const vector< ExpRun > &requestedRuns)
 We cheekily cast the TChain to TTree for the returned pointer so that the user never knows Hopefully this doesn't cause issues if people do low level stuff to the tree...
 
std::string getGranularityFromData () const
 Get the granularity of collected data.
 
void saveCalibration (TClonesArray *data, const std::string &name)
 Store DBArray payload with given name with default IOV.
 
void saveCalibration (TClonesArray *data, const std::string &name, const IntervalOfValidity &iov)
 Store DBArray with given name and custom IOV.
 
void saveCalibration (TObject *data)
 Store DB payload with default name and default IOV.
 
void saveCalibration (TObject *data, const IntervalOfValidity &iov)
 Store DB payload with default name and custom IOV.
 
void saveCalibration (TObject *data, const std::string &name)
 Store DB payload with given name with default IOV.
 
void saveCalibration (TObject *data, const std::string &name, const IntervalOfValidity &iov)
 Store DB payload with given name and custom IOV.
 
void updateDBObjPtrs (const unsigned int event, const int run, const int experiment)
 Updates any DBObjPtrs by calling update(event) for DBStore.
 
void setDescription (const std::string &description)
 Set algorithm description (in constructor)
 
void clearCalibrationData ()
 Clear calibration data.
 
Calibration::ExpRun getAllGranularityExpRun () const
 Returns the Exp,Run pair that means 'Everything'. Currently unused.
 
void resetInputJson ()
 Clears the m_inputJson member variable.
 
void resetOutputJson ()
 Clears the m_outputJson member variable.
 
template<class T >
void setOutputJsonValue (const std::string &key, const T &value)
 Set a key:value pair for the outputJson object, expected to used internally during calibrate()
 
template<class T >
const T getOutputJsonValue (const std::string &key) const
 Get a value using a key from the JSON output object, not sure why you would want to do this.
 
template<class T >
const T getInputJsonValue (const std::string &key) const
 Get an input JSON value using a key. The normal exceptions are raised when the key doesn't exist.
 
const nlohmann::json & getInputJsonObject () const
 Get the entire top level JSON object. We explicitly say this must be of object type so that we might pick.
 
bool inputJsonKeyExists (const std::string &key) const
 Test for a key in the input JSON object.
 

Protected Attributes

std::vector< Calibration::ExpRun > m_boundaries
 When using the boundaries functionality from isBoundaryRequired, this is used to store the boundaries. It is cleared when.
 

Private Member Functions

std::string getExpRunString (Calibration::ExpRun &expRun) const
 Gets the "exp.run" string repr. of (exp,run)
 
std::string getFullObjectPath (const std::string &name, Calibration::ExpRun expRun) const
 constructs the full TDirectory + Key name of an object in a TFile based on its name and exprun
 

Private Attributes

DBObjPtr< ECLCrystalCalib > m_ECLCrystalTimeOffset
 ECLCrystalTimeOffset payload that we want to read from the DB.
 
DBObjPtr< ECLCrystalCalib > m_ECLCrateTimeOffset
 ECLCrateTimeOffset payload that we want to read from the DB.
 
DBObjPtr< ECLReferenceCrystalPerCrateCalib > m_refCrysIDzeroingCrate
 payload that we want to read from the DB
 
const int m_numCrystals = ECLElementNumbers::c_NCrystals
 Number of Crystals expected.
 
const int m_numCrates = 52
 Number of Crates expected.
 
Int_t m_run_perCrystal
 Run number.
 
Int_t m_exp_perCrystal
 Experiment number

 
Int_t m_crystalID
 Crystal ID number.
 
Double_t m_crateTimeConst
 Crate time calibration constant.
 
Double_t m_crystalTimeConst
 Crystal time calibration constant.
 
Double_t m_crateTimeUnc
 Uncertainty on the crate time calibration constant.
 
Double_t m_crystalTimeUnc
 Uncertainty on the crystal time calibration constant.
 
Int_t m_crateID
 Crate ID number.
 
Int_t m_refCrystalID
 Crystal ID number for the reference crystal.
 
double m_tcrate_min_cut = -150
 Minimum value cut for the crate time calibration constant for plotting.
 
double m_tcrate_max_cut = 150
 Maximum value cut for the crate time calibration constant for plotting

 
double m_tcrate_unc_min_cut = 0.0001
 Minimum value cut for the crate time calibration constant uncertainty for plotting.
 
double m_tcrate_unc_max_cut = 0.4
 Maximum value cut for the crate time calibration constant uncertainty for plotting.
 
std::vector< std::string > m_inputFileNames
 List of input files to the Algorithm, will initially be user defined but then gets the wildcards expanded during execute()
 
std::map< Calibration::ExpRun, std::vector< std::string > > m_runsToInputFiles
 Map of Runs to input files. Gets filled when you call getRunRangeFromAllData, gets cleared when setting input files again.
 
std::string m_granularityOfData
 Granularity of input data. This only changes when the input files change so it isn't specific to an execution.
 
ExecutionData m_data
 Data specific to a SINGLE execution of the algorithm. Gets reset at the beginning of execution.
 
std::string m_description {""}
 Description of the algorithm.
 
std::string m_prefix {""}
 The name of the TDirectory the collector objects are contained within.
 
nlohmann::json m_jsonExecutionInput = nlohmann::json::object()
 Optional input JSON object used to make decisions about how to execute the algorithm code.
 
nlohmann::json m_jsonExecutionOutput = nlohmann::json::object()
 Optional output JSON object that can be set during the execution by the underlying algorithm code.
 

Static Private Attributes

static const Calibration::ExpRun m_allExpRun = make_pair(-1, -1)
 allExpRun
 

Detailed Description

Calibrate ecl crystals using previously created payloads.

Definition at line 36 of file eclTimeShiftsAlgorithm.h.

Member Enumeration Documentation

◆ EResult

enum EResult
inherited

The result of calibration.

Enumerator
c_OK 

Finished successfully =0 in Python.

c_Iterate 

Needs iteration =1 in Python.

c_NotEnoughData 

Needs more data =2 in Python.

c_Failure 

Failed =3 in Python.

c_Undefined 

Not yet known (before execution) =4 in Python.

Definition at line 40 of file CalibrationAlgorithm.h.

40 {
41 c_OK,
42 c_Iterate,
43 c_NotEnoughData,
44 c_Failure,
45 c_Undefined
46 };
Belle2::CalibrationAlgorithm::c_OK
@ c_OK
Finished successfully =0 in Python.
Definition: CalibrationAlgorithm.h:41
Belle2::CalibrationAlgorithm::c_Iterate
@ c_Iterate
Needs iteration =1 in Python.
Definition: CalibrationAlgorithm.h:42
Belle2::CalibrationAlgorithm::c_NotEnoughData
@ c_NotEnoughData
Needs more data =2 in Python.
Definition: CalibrationAlgorithm.h:43
Belle2::CalibrationAlgorithm::c_Failure
@ c_Failure
Failed =3 in Python.
Definition: CalibrationAlgorithm.h:44
Belle2::CalibrationAlgorithm::c_Undefined
@ c_Undefined
Not yet known (before execution) =4 in Python.
Definition: CalibrationAlgorithm.h:45

Constructor & Destructor Documentation

◆ eclTimeShiftsAlgorithm()

eclTimeShiftsAlgorithm ( )

..Constructor

Definition at line 41 of file eclTimeShiftsAlgorithm.cc.

41 :
42 CalibrationAlgorithm("eclTimeShiftsPlottingCollector"),
43 debugFilenameBase("ECL_time_offsets"),
44 timeShiftForPlotStyle{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
45 crysCrateShift_min(-20),
46 crysCrateShift_max(20),
47 algorithmReadPayloads(false),
48 m_ECLCrystalTimeOffset("ECLCrystalTimeOffset"),
49 m_ECLCrateTimeOffset("ECLCrateTimeOffset"),
50 m_refCrysIDzeroingCrate("ECLReferenceCrystalPerCrateCalib")//,
51{
52 setDescription(
53 "Plots the ecl crystal and crate time calibations."
54 );
55}
Belle2::CalibrationAlgorithm
Base class for calibration algorithms.
Definition: CalibrationAlgorithm.h:37
Belle2::CalibrationAlgorithm::setDescription
void setDescription(const std::string &description)
Set algorithm description (in constructor)
Definition: CalibrationAlgorithm.h:321
Belle2::ECL::eclTimeShiftsAlgorithm::algorithmReadPayloads
bool algorithmReadPayloads
Whether or not to have the algorithm code to loop over all the runs and read the payloads itself.
Definition: eclTimeShiftsAlgorithm.h:60
Belle2::ECL::eclTimeShiftsAlgorithm::m_refCrysIDzeroingCrate
DBObjPtr< ECLReferenceCrystalPerCrateCalib > m_refCrysIDzeroingCrate
payload that we want to read from the DB
Definition: eclTimeShiftsAlgorithm.h:76
Belle2::ECL::eclTimeShiftsAlgorithm::m_ECLCrateTimeOffset
DBObjPtr< ECLCrystalCalib > m_ECLCrateTimeOffset
ECLCrateTimeOffset payload that we want to read from the DB.
Definition: eclTimeShiftsAlgorithm.h:73
Belle2::ECL::eclTimeShiftsAlgorithm::crysCrateShift_max
double crysCrateShift_max
Plotting time max for crystal+crate shift plots.
Definition: eclTimeShiftsAlgorithm.h:56
Belle2::ECL::eclTimeShiftsAlgorithm::crysCrateShift_min
double crysCrateShift_min
Plotting time min for crystal+crate shift plots.
Definition: eclTimeShiftsAlgorithm.h:55
Belle2::ECL::eclTimeShiftsAlgorithm::debugFilenameBase
std::string debugFilenameBase
Name of file with debug output, eclTimeShiftsAlgorithm.root by default.
Definition: eclTimeShiftsAlgorithm.h:49
Belle2::ECL::eclTimeShiftsAlgorithm::m_ECLCrystalTimeOffset
DBObjPtr< ECLCrystalCalib > m_ECLCrystalTimeOffset
ECLCrystalTimeOffset payload that we want to read from the DB.
Definition: eclTimeShiftsAlgorithm.h:70
Belle2::ECL::eclTimeShiftsAlgorithm::timeShiftForPlotStyle
double timeShiftForPlotStyle[52]
List of time offsets, one per crate, used just to centre the time constants around zero.
Definition: eclTimeShiftsAlgorithm.h:53

◆ ~eclTimeShiftsAlgorithm()

~eclTimeShiftsAlgorithm ( )
inline

..Destructor

Definition at line 43 of file eclTimeShiftsAlgorithm.h.

43{}

Member Function Documentation

◆ boundaryFindingSetup()

virtual void boundaryFindingSetup ( std::vector< Calibration::ExpRun >  ,
int   
)
inlineprotectedvirtualinherited

If you need to make some changes to your algorithm class before 'findPayloadBoundaries' is run, make them in this function.

Reimplemented in TestBoundarySettingAlgorithm, TestCalibrationAlgorithm, PXDAnalyticGainCalibrationAlgorithm, PXDValidationAlgorithm, SVD3SampleCoGTimeCalibrationAlgorithm, SVD3SampleELSTimeCalibrationAlgorithm, and SVDCoGTimeCalibrationAlgorithm.

Definition at line 252 of file CalibrationAlgorithm.h.

252{};

◆ boundaryFindingTearDown()

virtual void boundaryFindingTearDown ( )
inlineprotectedvirtualinherited

Put your algorithm back into a state ready for normal execution if you need to.

Definition at line 257 of file CalibrationAlgorithm.h.

257{};

◆ calibrate()

CalibrationAlgorithm::EResult calibrate ( )
overrideprotectedvirtual

..Run algorithm

Put root into batch mode so that we don't try to open a graphics window

Apply the cuts to the values extracted from the tree

Write out a few values for quality control purposes

Determine the minimum and maximum run numbers for labelling purposes

Test that the DBObjects are valid

Get the vectors from the input payloads

Loop over all the experiments and runs and extract the crate times

Set up ECL channel mapper and determine the payload IoV and Revision

Populate database contents

Get the vectors from the input payload

Make a crate time offset vector with an entry per crate (instead of per crystal) and convert from ADC counts to ns. Also store the sum of the crystal and crate times

Write out a few values for quality control purposes

Shift all the crystal+crate times by the mean time to naturally roughly centre all the crys+crate+shift times

Now that the timing information has be read in, fill the crate time offsets and general time shifts into the histograms

Implements CalibrationAlgorithm.

Definition at line 57 of file eclTimeShiftsAlgorithm.cc.

58{
60 gROOT->SetBatch();
61
62 B2INFO("eclTimeShiftsAlgorithm parameters:");
63 B2INFO("debugFilenameBase = " << debugFilenameBase);
64 B2INFO("algorithmReadPayloads = " << algorithmReadPayloads);
65 B2INFO("timeShiftForPlotStyle = {");
66 for (int crateTest = 0; crateTest < 51; crateTest++) {
67 B2INFO(timeShiftForPlotStyle[crateTest] << ",");
68 }
69 B2INFO(timeShiftForPlotStyle[51] << "}");
70
71
72 //------------------------------------------------------------------------
73 /* Conversion coefficient from ADC ticks to nanoseconds
74 1/(4fRF) = 0.4913 ns/clock tick, where fRF is the accelerator RF frequency.
75 Same for all crystals. */
76
77 //..First need to set event, run, exp number
78 const auto expRunList = getRunList();
79 const int iEvt = 1;
80 const int iRun = expRunList[0].second;
81 const int iExp = expRunList[0].first;
82 DBObjPtr<Belle2::HardwareClockSettings> clock_info("HardwareClockSettings");
83 updateDBObjPtrs(iEvt, iRun, iExp);
84 const double TICKS_TO_NS = 1.0 / (4.0 * EclConfiguration::getRF()) * 1e3;
85
86
87 //------------------------------------------------------------------------
88 /* Set up variables for storing timing information and cutting on
89 timing quality */
90
91 vector< vector<double> > allCrates_crate_times ;
92 vector< vector<double> > allCrates_run_nums ; // not an integer for plotting purposes
93 vector< vector<double> > allCrates_time_unc ;
94 vector< vector<double> > allCrates_crystalCrate_times ;
95 vector< vector<double> > allCrates_crystalCrate_times_unc ;
96
97 vector<int> allRunNums;
98
99 vector<double> mean_crystalCrate_time_ns(m_numCrates, 0);
100
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) ;
109 }
110 // This results in : allCrates_crate_time[index for crate number][index for run number]
111
112
113
114 //------------------------------------------------------------------------
115 /* Extract the crystal and crate calibration constant information from the
116 tree as extracted by the collector. */
117
118 // Pulling in data from collector output. It now returns shared_ptr<T> so the underlying pointer
119 // will delete itself automatically at the end of this scope unless you do something
120 auto tree_perCrys = getObjectPtr<TTree>("tree_perCrystal");
121 if (!tree_perCrys) {
122 B2ERROR("Tree of calibration constants does not exist.");
123 return c_Failure;
124 }
125 B2INFO("Number of Entries in tree_perCrystal was " << tree_perCrys->GetEntries());
126 B2INFO("Number of Entries in tree_perCrystal / 8736 = " << float(tree_perCrys->GetEntries()) / ECLElementNumbers::c_NCrystals);
127
128
129 // Define the variables to be read in from the tree
130 tree_perCrys->SetBranchAddress("run", &m_run_perCrystal);
131 tree_perCrys->SetBranchAddress("exp", &m_exp_perCrystal);
132 tree_perCrys->SetBranchAddress("crystalID", &m_crystalID);
133 tree_perCrys->SetBranchAddress("crateID", &m_crateID);
134 tree_perCrys->SetBranchAddress("crateTimeConst", &m_crateTimeConst);
135 tree_perCrys->SetBranchAddress("crateTimeUnc", &m_crateTimeUnc);
136 tree_perCrys->SetBranchAddress("crystalTimeConst", &m_crystalTimeConst);
137 tree_perCrys->SetBranchAddress("crystalTimeUnc", &m_crystalTimeUnc);
138 tree_perCrys->SetBranchAddress("refCrystalID", &m_refCrystalID);
139
140
141 int referenceRunNum = -1;
142 int referenceExpNum = -1;
143 //int numAnalysedRuns = 0 ;
144 int previousRunNumTree = -1 ;
145 vector<double> Crate_time_ns_tree(m_numCrates) ;
146 vector<double> Crate_time_tick_tree(m_numCrates) ;
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);
150
151
152 Int_t numEntriesCrysTree = (Int_t)tree_perCrys->GetEntries();
153
154 // Loop through the entire tree
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);
158 //B2INFO("tree_crys_i, tree_crys_j = " << tree_crys_i << ", " << tree_crys_j);
159 if (tree_crys_j != m_numCrystals - 1) {
160 tree_crys_i++;
161 }
162
163 // Make sure that all the information read in for 8736 crystals are all from one (exp,run).
164 if (tree_crys_j == 0) {
165 referenceExpNum = m_exp_perCrystal;
166 referenceRunNum = m_run_perCrystal;
167 B2INFO("Looking at exp,run " << m_exp_perCrystal << ", " << m_run_perCrystal);
168 }
169 if ((m_exp_perCrystal != referenceExpNum) or
170 (m_run_perCrystal != referenceRunNum) or
171 (m_run_perCrystal == previousRunNumTree)) {
172
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");
177 return c_Failure;
178 }
179
180
181 int crateID_temp = m_crateID;
182 Crate_time_ns_tree[crateID_temp - 1] = m_crateTimeConst * TICKS_TO_NS ;
183 Crate_time_tick_tree[crateID_temp - 1] = m_crateTimeConst ;
184 Crate_time_unc_ns_tree[crateID_temp - 1] = m_crateTimeUnc * TICKS_TO_NS ;
185
186 if (m_crystalID == m_refCrystalID) {
187 B2INFO("m_exp_perCrystal, m_run_perCrystal, cell ID (0..8735), m_crateID, m_crateTimeConst = " << m_exp_perCrystal << ", " <<
188 m_run_perCrystal << ", " << tree_crys_j << ", " << m_crateID << ", " << m_crateTimeConst << " ticks") ;
189 crystalCrate_time_ns_tree[crateID_temp - 1] = (m_crystalTimeConst + m_crateTimeConst) * TICKS_TO_NS;
190
191 crystalCrate_time_unc_ns_tree[crateID_temp - 1] = TICKS_TO_NS * sqrt(
192 (m_crateTimeUnc * m_crateTimeUnc) +
193 (m_crystalTimeUnc * m_crystalTimeUnc)) ;
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 << ", " <<
196 m_run_perCrystal << ", " << tree_crys_j << ", " << m_crateID << ", " << m_crateTimeConst << " ns") ;
197 } else {
198 B2DEBUG(22, "m_exp_perCrystal, m_run_perCrystal, cell ID (0..8735), m_crateID, m_crateTimeConst = " << m_exp_perCrystal << ", " <<
199 m_run_perCrystal << ", " << tree_crys_j << ", " << m_crateID << ", " << m_crateTimeConst << " ns") ;
200 }
201
202 }
203
204 //------------------------------------------------------------------------
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];
213
214 if ((tcrate < m_tcrate_max_cut) &&
215 (tcrate > m_tcrate_min_cut) &&
216 (fabs(tcrate_unc) > m_tcrate_unc_min_cut) &&
217 (fabs(tcrate_unc) < m_tcrate_unc_max_cut)) {
218 allCrates_crate_times[iCrate].push_back(tcrate) ;
219 allCrates_run_nums[iCrate].push_back(m_run_perCrystal) ;
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) ;
223
224 mean_crystalCrate_time_ns[iCrate] += tcrystalCrate ;
225
226 if (!savedThisRunNum) {
227 allRunNums.push_back(m_run_perCrystal);
228 savedThisRunNum = true;
229 }
230 }
231 }
232
233 //------------------------------------------------------------------------
235 for (int ic = 0; ic < m_numCrates; ic++) {
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") ;
240 }
241
242 previousRunNumTree = m_run_perCrystal;
243
244 }
245
246
247 B2INFO("Finished reading tree calibration constants. Now extracting here by stepping through runs.");
248
249
250
251
252
253 //------------------------------------------------------------------------
257 bool minRunNumBool = false;
258 bool maxRunNumBool = false;
259 int minRunNum = -1;
260 int maxRunNum = -1;
261 int minExpNum = -1;
262 int maxExpNum = -1;
263 for (auto expRun : getRunList()) {
264 int expNumber = expRun.first;
265 int runNumber = expRun.second;
266 if (!minRunNumBool) {
267 minExpNum = expNumber;
268 minRunNum = runNumber;
269 minRunNumBool = true;
270 }
271 if (!maxRunNumBool) {
272 maxExpNum = expNumber;
273 maxRunNum = runNumber;
274 maxRunNumBool = true;
275 }
276 if (((minRunNum > runNumber) && (minExpNum >= expNumber)) ||
277 (minExpNum > expNumber)) {
278 minExpNum = expNumber;
279 minRunNum = runNumber;
280 }
281 if (((maxRunNum < runNumber) && (maxExpNum <= expNumber)) ||
282 (maxExpNum < expNumber)) {
283 maxExpNum = expNumber;
284 maxRunNum = runNumber;
285 }
286 }
287
288 B2INFO("minExpNum = " << minExpNum) ;
289 B2INFO("minRunNum = " << minRunNum) ;
290 B2INFO("maxExpNum = " << maxExpNum) ;
291 B2INFO("maxRunNum = " << maxRunNum) ;
292
293
294 if (minExpNum != maxExpNum) {
295 B2ERROR("The runs must all come from the same experiment");
296 return c_Failure;
297 }
298
299 int experiment = minExpNum;
300
301
302 //------------------------------------------------------------------------
303 //------------------------------------------------------------------------
304 //------------------------------------------------------------------------
305 //------------------------------------------------------------------------
306 /* Extract out the time offset information from the database directly.
307 This method loops over all run numbers so it can more easily pick up
308 old payloads. It is not the preferred method to use if the payloads
309 have iov gaps.*/
310
311 if (algorithmReadPayloads) {
312 //------------------------------------------------------------------------
313 // Get the input run list (should be only 1) for us to use to update the DBObjectPtrs
314 auto runs = getRunList();
315 /* Take the first run. For the crystal cosmic calibrations, because of the crate
316 calibrations, there is not a known correct run to use within the range. */
317 ExpRun chosenRun = runs.front();
318 B2INFO("merging using the ExpRun (" << chosenRun.second << "," << chosenRun.first << ")");
319 // After here your DBObjPtrs are correct
320 updateDBObjPtrs(1, chosenRun.second, chosenRun.first);
321
322 //------------------------------------------------------------------------
323 // Test the DBObjects we want to exist and fail if not all of them do.
324 bool allObjectsFound = true;
325
327 // Check that the payloads we want to merge are sufficiently loaded
328 if (!m_ECLCrystalTimeOffset) {
329 allObjectsFound = false;
330 B2ERROR("No valid DBObject found for 'ECLCrystalTimeOffset'");
331 }
332
333 // Check that the crate payload is loaded (used for transforming cosmic payload)
334 if (!m_ECLCrateTimeOffset) {
335 allObjectsFound = false;
336 B2ERROR("No valid DBObject found for 'ECLCrateTimeOffset'");
337 }
338
339 if (!m_refCrysIDzeroingCrate) {
340 allObjectsFound = false;
341 B2ERROR("No valid DBObject found for 'refCrysIDzeroingCrate'");
342 }
343
344
345 if (allObjectsFound) {
346 B2INFO("Valid objects found for 'ECLCrystalTimeOffset'");
347 B2INFO("Valid object found for 'ECLCrateTimeOffset'");
348 B2INFO("Valid object found for 'refCrysIDzeroingCrate'");
349 } else {
350 B2INFO("eclTimeShiftsAlgorithm: Exiting with failure. Some missing valid objects.");
351 return c_Failure;
352 }
353
354
355 //------------------------------------------------------------------------
357 vector<float> crystalCalib = m_ECLCrystalTimeOffset->getCalibVector();
358 vector<float> crystalCalibUnc = m_ECLCrystalTimeOffset->getCalibUncVector();
359 B2INFO("Loaded 'ECLCrystalTimeOffset' calibrations");
360
361 vector<float> crateCalib = m_ECLCrateTimeOffset->getCalibVector();
362 vector<float> crateCalibUnc = m_ECLCrateTimeOffset->getCalibUncVector();
363
364 B2INFO("Loaded 'ECLCrateTimeOffset' calibration with default exp/run");
365
366 B2INFO("eclTimeShiftsAlgorithm:: loaded ECLCrateTimeOffset from the database"
367 << LogVar("IoV", m_ECLCrateTimeOffset.getIoV())
368 << LogVar("Checksum", m_ECLCrateTimeOffset.getChecksum()));
369
370 for (int cellID = 1; cellID <= m_numCrystals; cellID += 511) {
371 B2INFO("crystalCalib = " << crystalCalib[cellID - 1]);
372 B2INFO("crateCalib = " << crateCalib[cellID - 1]);
373 }
374
375 vector<short> refCrystals = m_refCrysIDzeroingCrate->getReferenceCrystals();
376 for (int icrate = 0; icrate < m_numCrates; icrate++) {
377 B2INFO("reference crystal for crate " << icrate + 1 << " = " << refCrystals[icrate]);
378 }
379
380
381
382 //------------------------------------------------------------------------
384 for (int run = minRunNum; run <= maxRunNum; run++) {
385 B2INFO("---------") ;
386 B2INFO("Looking at run " << run) ;
387
388 vector<int>::iterator it = find(allRunNums.begin(), allRunNums.end(), 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.");
393 continue;
394 } else {
395 B2INFO("New run. Starting to extract information");
396 }
397
398 // Forloading database for a specific run
399 int eventNumberForCrates = 1;
400
401 StoreObjPtr<EventMetaData> evtPtr;
402 // simulate the initialize() phase where we can register objects in the DataStore
403 DataStore::Instance().setInitializeActive(true);
404 evtPtr.registerInDataStore();
405 DataStore::Instance().setInitializeActive(false);
406 // now construct the event metadata
407 evtPtr.construct(eventNumberForCrates, run, experiment);
408 // and update the database contents
409 DBStore& dbstore = DBStore::Instance();
410 dbstore.update();
411 // this is only needed it the payload might be intra-run dependent,
412 // that is if it might change during one run as well
413 dbstore.updateEvent();
414 updateDBObjPtrs(eventNumberForCrates, run, experiment);
415
416
417 //------------------------------------------------------------------------
419 shared_ptr< ECL::ECLChannelMapper > crystalMapper(new ECL::ECLChannelMapper()) ;
420 crystalMapper->initFromDB();
421
423 B2INFO("eclTimeShiftsAlgorithm:: loaded ECLCrystalTimeOffset from the database"
424 << LogVar("IoV", m_ECLCrystalTimeOffset.getIoV())
425 << LogVar("Checksum", m_ECLCrystalTimeOffset.getChecksum()));
426 B2INFO("eclTimeShiftsAlgorithm:: loaded ECLCrateTimeOffset from the database"
427 << LogVar("IoV", m_ECLCrateTimeOffset.getIoV())
428 << LogVar("Checksum", m_ECLCrateTimeOffset.getChecksum()));
429
430
431 //------------------------------------------------------------------------
434 vector<float> crystalTimeOffsetsCalib;
435 vector<float> crystalTimeOffsetsCalibUnc;
436 crystalTimeOffsetsCalib = m_ECLCrystalTimeOffset->getCalibVector();
437 crystalTimeOffsetsCalibUnc = m_ECLCrystalTimeOffset->getCalibUncVector();
438
439 vector<float> crateTimeOffsetsCalib;
440 vector<float> crateTimeOffsetsCalibUnc;
441 crateTimeOffsetsCalib = m_ECLCrateTimeOffset->getCalibVector();
442 crateTimeOffsetsCalibUnc = m_ECLCrateTimeOffset->getCalibUncVector();
443
444 //------------------------------------------------------------------------
448 vector<double> Crate_time_ns(m_numCrates) ;
449 vector<double> Crate_time_tick(m_numCrates) ;
450 vector<double> Crate_time_unc_ns(m_numCrates) ;
451 vector<double> crystalCrate_time_ns(m_numCrates);
452 vector<double> crystalCrate_time_unc_ns(m_numCrates);
453
454 for (int crysID = 1; crysID <= m_numCrystals; crysID++) {
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 ;
459
460 if (crysID == refCrystals[crateID_temp - 1]) {
461 crystalCrate_time_ns[crateID_temp - 1] = (crystalTimeOffsetsCalib[crysID - 1] +
462 crateTimeOffsetsCalib[crysID - 1]) * TICKS_TO_NS;
463
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])) ;
467 }
468 }
469
470
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];
476
477 if ((tcrate < m_tcrate_max_cut) &&
478 (tcrate > m_tcrate_min_cut) &&
479 (fabs(tcrate_unc) > m_tcrate_unc_min_cut) &&
480 (fabs(tcrate_unc) < m_tcrate_unc_max_cut)) {
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) ;
486
487 mean_crystalCrate_time_ns[iCrate] += tcrystalCrate ;
488 }
489 }
490
491
492 //------------------------------------------------------------------------
494 for (int ic = 0; ic < m_numCrates; ic++) {
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") ;
499 }
500
501 /* Shift the run number to the end of the iov so that we can skip runs
502 that have the payload with the same revision number */
503 int IOV_exp_high = m_ECLCrateTimeOffset.getIoV().getExperimentHigh() ;
504 int IOV_run_high = m_ECLCrateTimeOffset.getIoV().getRunHigh() ;
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");
509 break;
510 } else {
511 B2INFO("Set run number to higher iov run number");
512 run = IOV_run_high;
513 }
514 B2INFO("now set run = " << run);
515 }
516 }
517
518
519
520
521 //------------------------------------------------------------------------
522 //------------------------------------------------------------------------
523 //------------------------------------------------------------------------
524 //------------------------------------------------------------------------
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);
531
532 for (long unsigned int jRun = 0; jRun < allCrates_crate_times[iCrate].size(); jRun++) {
533 allCrates_crystalCrate_times[iCrate][jRun] += -mean_time + timeShiftForPlotStyle[iCrate] ;
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]);
538 }
539 }
540 }
541
542
543
544 //------------------------------------------------------------------------
545 //------------------------------------------------------------------------
548 TFile* tcratefile = 0;
549
550 B2INFO("Debug output rootfile: " << debugFilenameBase);
551 string runNumsString = string("_") + to_string(minExpNum) + "_" + to_string(minRunNum) + string("-") +
552 to_string(maxExpNum) + "_" + to_string(maxRunNum);
553 string debugFilename = debugFilenameBase + runNumsString + string(".root");
554 TString fname = debugFilename;
555
556 tcratefile = new TFile(fname, "recreate");
557 tcratefile->cd();
558 B2INFO("Debugging histograms written to " << fname);
559
560 for (int i = 0; i < m_numCrates; i++) {
561 B2INFO("Starting to make crate time jump plots for crate " << i + 1);
562 shared_ptr< TCanvas > cSmart(new TCanvas);
563
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);
570
571 ostringstream ss;
572 ss << setw(2) << setfill('0') << i + 1 ;
573 string paddedCrateID(ss.str());
574
575 // ----- crate time constants vs run number ------
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)) ;
578 // NULL for run number errors = 0 for all
579
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) ;
582
583 string tgraph_name_short = "crateTimeVSrunNum_" ;
584 tgraph_name_short = tgraph_name_short + runNumsString + "_crate";
585
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 < ") +
589 to_string(m_tcrate_max_cut) + string(" ns, ") + to_string(m_tcrate_unc_min_cut) +
590 string(" < tcrate unc. < ") + to_string(m_tcrate_unc_max_cut) + string(" ns cuts)") ;
591
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]") ;
596
597 g_tcrate_vs_runNum->GetYaxis()->SetRangeUser(m_tcrate_min_cut, m_tcrate_max_cut) ;
598
599 g_tcrate_vs_runNum->Draw("AP") ;
600 g_tcrate_vs_runNum->SetMarkerSize(0.8) ;
601 g_tcrate_vs_runNum->Draw("AP") ;
602
603 shared_ptr< TLatex > Leg1(new TLatex);
604 Leg1->SetNDC();
605 Leg1->SetTextAlign(11);
606 Leg1->SetTextFont(42);
607 Leg1->SetTextSize(0.035);
608 Leg1->SetTextColor(1);
609 Leg1->AppendPad();
610
611 g_tcrate_vs_runNum->Write() ;
612 cSmart->SaveAs((tgraph_name_short + string(".pdf")).c_str()) ;
613
614 B2INFO("Saved pdf: " << tgraph_name_short << ".pdf");
615
616
617 // ----- crystal + crate time constants + offset vs run number ------
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)) ;
621
622 tgraph_title = string("e") + to_string(minExpNum) + string("r") + to_string(minRunNum) +
623 string("-e") + to_string(maxExpNum) + string("r") + to_string(maxRunNum) ;
624
625 tgraph_name_short = "crystalCrateTimeVSrunNum_" ;
626 tgraph_name_short = tgraph_name_short + runNumsString + "_crate";
627
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 < ") +
631 to_string(m_tcrate_max_cut) + string(" ns, ") + to_string(m_tcrate_unc_min_cut) +
632 string(" < tcrate unc. < ") + to_string(m_tcrate_unc_max_cut) + string(" ns cuts)") ;
633
634
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]") ;
639
640 g_crateCrystalTime_vs_runNum->GetYaxis()->SetRangeUser(crysCrateShift_min, crysCrateShift_max) ;
641
642 g_crateCrystalTime_vs_runNum->Draw("AP") ;
643 g_crateCrystalTime_vs_runNum->SetMarkerSize(0.8) ;
644 g_crateCrystalTime_vs_runNum->Draw("AP") ;
645
646 g_crateCrystalTime_vs_runNum->Write() ;
647 cSmart->SaveAs((tgraph_name_short + string(".pdf")).c_str()) ;
648
649 B2INFO("Saved pdf: " << tgraph_name_short << ".pdf");
650
651 // ----- crystal + crate time constants + offset vs run counter------
652 // This will remove gaps and ignore the actual run number
653
654 /* Define a vector to store a renumbering of the run numbers, incrementing
655 by +1 so that there are no gaps. The runs are not in order so the
656 run numbers&indices first have to be sorted before the "run counter"
657 numbers can used.*/
658 int numRunsWithCrateTimes = allCrates_crystalCrate_times[i].size();
659 vector<Double_t> counterVec(numRunsWithCrateTimes);
660
661
662 // Vector to store element
663 // with respective present index
664 vector<pair<int, double> > runNum_index_pairs;
665
666 // Inserting element in pair vector
667 // to keep track of previous indexes
668 for (int pairIndex = 0; pairIndex < numRunsWithCrateTimes; pairIndex++) {
669 runNum_index_pairs.push_back(make_pair(allCrates_run_nums[i][pairIndex], pairIndex));
670 }
671
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);
677 }
678
679 // Sorting pair vector
680 sort(runNum_index_pairs.begin(), runNum_index_pairs.end());
681
682 // Fill the run counter vector
683 for (int runCounter = 0; runCounter < numRunsWithCrateTimes; runCounter++) {
684 counterVec[runNum_index_pairs[runCounter].second] = runCounter + 1;
685 }
686
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");
692 }
693
694
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)) ;
698
699 tgraph_title = string("e") + to_string(minExpNum) + string("r") + to_string(minRunNum) +
700 string("-e") + to_string(maxExpNum) + string("r") + to_string(maxRunNum) ;
701
702
703 tgraph_name_short = "crystalCrateTimeVSrunCounter_" ;
704 tgraph_name_short = tgraph_name_short + runNumsString + "_crate";
705
706
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 < ") +
710 to_string(m_tcrate_max_cut) + string(" ns, ") + to_string(m_tcrate_unc_min_cut) +
711 string(" < tcrate unc. < ") + to_string(m_tcrate_unc_max_cut) + string(" ns cuts)") ;
712
713
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]") ;
718
719 g_crateCrystalTime_vs_runCounter->GetYaxis()->SetRangeUser(crysCrateShift_min, crysCrateShift_max) ;
720 g_crateCrystalTime_vs_runCounter->GetXaxis()->SetRangeUser(0, numRunsWithCrateTimes + 1) ;
721
722 g_crateCrystalTime_vs_runCounter->Draw("AP") ;
723 g_crateCrystalTime_vs_runCounter->SetMarkerSize(0.8) ;
724 g_crateCrystalTime_vs_runCounter->Draw("AP") ;
725
726 g_crateCrystalTime_vs_runCounter->Write() ;
727 cSmart->SaveAs((tgraph_name_short + string(".pdf")).c_str()) ;
728 B2INFO("Saved pdf: " << tgraph_name_short << ".pdf");
729
730 B2INFO("Finished making crate time jump plots for crate " << i + 1);
731 } else {
732 B2INFO("Crate " << i + 1 << " has no entries that pass all the cuts so no crystalCrateTimeVSrunCounter_crate plot will be made.");
733 }
734 }
735
736
737
738
739 /* Loop over all the runs and crates and let the user know when a crate time jump
740 has occurred. Jumps can be of various sizes so have different thresholds. */
741 double smallThreshold = 1 ; //ns
742 double largeThreshold = 6.5 ; //ns
743
744 B2INFO("======================= Crate time jumps =========================");
745 B2INFO("======================= Small threshold jumps ====================");
746 B2INFO("Crate ID = 1..52");
747 B2INFO("==================================================================");
748
749 for (int i = 0; i < m_numCrates; i++) {
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] ;
756
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);
760 }
761 }
762 }
763
764
765 B2INFO("~~~~~~~~~~~~~~~~~~~~~~~ Large threshold jumps ~~~~~~~~~~~~~~~~~~~~");
766 B2INFO("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
767
768 for (int i = 0; i < m_numCrates; i++) {
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] ;
775
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);
779 }
780 }
781 }
782
783
784
785
786 // Just in case, we remember the current TDirectory so we can return to it
787 TDirectory* executeDir = gDirectory;
788
789 tcratefile->Write();
790 tcratefile->Close();
791 // Go back to original TDirectory
792 executeDir->cd();
793
794 return c_OK;
795}
Belle2::CalibrationAlgorithm::updateDBObjPtrs
void updateDBObjPtrs(const unsigned int event, const int run, const int experiment)
Updates any DBObjPtrs by calling update(event) for DBStore.
Definition: CalibrationAlgorithm.cc:404
Belle2::CalibrationAlgorithm::getRunList
const std::vector< Calibration::ExpRun > & getRunList() const
Get the list of runs for which calibration is called.
Definition: CalibrationAlgorithm.h:266
Belle2::DBObjPtr
Class for accessing objects in the database.
Definition: DBObjPtr.h:21
Belle2::DBStore
Singleton class to cache database objects.
Definition: DBStore.h:31
Belle2::DataStore::Instance
static DataStore & Instance()
Instance of singleton Store.
Definition: DataStore.cc:54
Belle2::DataStore::setInitializeActive
void setInitializeActive(bool active)
Setter for m_initializeActive.
Definition: DataStore.cc:94
Belle2::ECL::ECLChannelMapper
This class provides access to ECL channel map that is either a) Loaded from the database (see ecl/dbo...
Definition: ECLChannelMapper.h:29
Belle2::ECL::EclConfiguration::getRF
static double getRF()
See m_rf.
Definition: EclConfiguration.cc:36
Belle2::ECL::eclTimeShiftsAlgorithm::m_crateTimeConst
Double_t m_crateTimeConst
Crate time calibration constant.
Definition: eclTimeShiftsAlgorithm.h:88
Belle2::ECL::eclTimeShiftsAlgorithm::m_tcrate_unc_min_cut
double m_tcrate_unc_min_cut
Minimum value cut for the crate time calibration constant uncertainty for plotting.
Definition: eclTimeShiftsAlgorithm.h:102
Belle2::ECL::eclTimeShiftsAlgorithm::m_numCrates
const int m_numCrates
Number of Crates expected.
Definition: eclTimeShiftsAlgorithm.h:82
Belle2::ECL::eclTimeShiftsAlgorithm::m_tcrate_max_cut
double m_tcrate_max_cut
Maximum value cut for the crate time calibration constant for plotting
Definition: eclTimeShiftsAlgorithm.h:101
Belle2::ECL::eclTimeShiftsAlgorithm::m_tcrate_min_cut
double m_tcrate_min_cut
Minimum value cut for the crate time calibration constant for plotting.
Definition: eclTimeShiftsAlgorithm.h:100
Belle2::ECL::eclTimeShiftsAlgorithm::m_numCrystals
const int m_numCrystals
Number of Crystals expected.
Definition: eclTimeShiftsAlgorithm.h:79
Belle2::ECL::eclTimeShiftsAlgorithm::m_crystalTimeUnc
Double_t m_crystalTimeUnc
Uncertainty on the crystal time calibration constant.
Definition: eclTimeShiftsAlgorithm.h:91
Belle2::ECL::eclTimeShiftsAlgorithm::m_crateTimeUnc
Double_t m_crateTimeUnc
Uncertainty on the crate time calibration constant.
Definition: eclTimeShiftsAlgorithm.h:90
Belle2::ECL::eclTimeShiftsAlgorithm::m_tcrate_unc_max_cut
double m_tcrate_unc_max_cut
Maximum value cut for the crate time calibration constant uncertainty for plotting.
Definition: eclTimeShiftsAlgorithm.h:103
Belle2::ECL::eclTimeShiftsAlgorithm::m_crystalTimeConst
Double_t m_crystalTimeConst
Crystal time calibration constant.
Definition: eclTimeShiftsAlgorithm.h:89
Belle2::ECL::eclTimeShiftsAlgorithm::m_refCrystalID
Int_t m_refCrystalID
Crystal ID number for the reference crystal.
Definition: eclTimeShiftsAlgorithm.h:97
Belle2::StoreAccessorBase::registerInDataStore
bool registerInDataStore(DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut)
Register the object/array in the DataStore.
Definition: StoreAccessorBase.h:52
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:96
Belle2::StoreObjPtr::construct
bool construct(Args &&... params)
Construct an object of type T in this StoreObjPtr, using the provided constructor arguments.
Definition: StoreObjPtr.h:119
LogVar
Class to store variables with their name which were sent to the logging service.
Definition: LogVariableStream.h:24
Belle2::DBStore::Instance
static DBStore & Instance()
Instance of a singleton DBStore.
Definition: DBStore.cc:28
Belle2::DBStore::updateEvent
void updateEvent()
Updates all intra-run dependent objects.
Definition: DBStore.cc:142
Belle2::DBStore::update
void update()
Updates all objects that are outside their interval of validity.
Definition: DBStore.cc:79
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition: beamHelpers.h:28
Belle2::ECLElementNumbers::c_NCrystals
const int c_NCrystals
Number of crystals.
Definition: ECLElementNumbers.h:23
Belle2::ExpRun
Struct containing exp number and run number.
Definition: Splitter.h:51

◆ checkPyExpRun()

bool checkPyExpRun ( PyObject *  pyObj)
inherited

Checks that a PyObject can be successfully converted to an ExpRun type.

Checks if the PyObject can be converted to ExpRun.

Definition at line 28 of file CalibrationAlgorithm.cc.

29{
30 // Is it a sequence?
31 if (PySequence_Check(pyObj)) {
32 Py_ssize_t nObj = PySequence_Length(pyObj);
33 // Does it have 2 objects in it?
34 if (nObj != 2) {
35 B2DEBUG(29, "ExpRun was a Python sequence which didn't have exactly 2 entries!");
36 return false;
37 }
38 PyObject* item1, *item2;
39 item1 = PySequence_GetItem(pyObj, 0);
40 item2 = PySequence_GetItem(pyObj, 1);
41 // Did the GetItem work?
42 if ((item1 == NULL) || (item2 == NULL)) {
43 B2DEBUG(29, "A PyObject pointer was NULL in the sequence");
44 return false;
45 }
46 // Are they longs?
47 if (PyLong_Check(item1) && PyLong_Check(item2)) {
48 long value1, value2;
49 value1 = PyLong_AsLong(item1);
50 value2 = PyLong_AsLong(item2);
51 if (((value1 == -1) || (value2 == -1)) && PyErr_Occurred()) {
52 B2DEBUG(29, "An error occurred while converting the PyLong to long");
53 return false;
54 }
55 } else {
56 B2DEBUG(29, "One or more of the PyObjects in the ExpRun wasn't a long");
57 return false;
58 }
59 // Make sure to kill off the reference GetItem gave us responsibility for
60 Py_DECREF(item1);
61 Py_DECREF(item2);
62 } else {
63 B2DEBUG(29, "ExpRun was not a Python sequence.");
64 return false;
65 }
66 return true;
67}

◆ clearCalibrationData()

void clearCalibrationData ( )
inlineprotectedinherited

Clear calibration data.

Definition at line 324 of file CalibrationAlgorithm.h.

324{m_data.clearCalibrationData();}
Belle2::CalibrationAlgorithm::ExecutionData::clearCalibrationData
void clearCalibrationData()
Clear calibration data.
Definition: CalibrationAlgorithm.h:69
Belle2::CalibrationAlgorithm::m_data
ExecutionData m_data
Data specific to a SINGLE execution of the algorithm. Gets reset at the beginning of execution.
Definition: CalibrationAlgorithm.h:382

◆ commit() [1/2]

bool commit ( )
inherited

Submit constants from last calibration into database.

Definition at line 302 of file CalibrationAlgorithm.cc.

303{
304 if (getPayloads().empty())
305 return false;
306 list<Database::DBImportQuery> payloads = getPayloads();
307 B2INFO("Committing " << payloads.size() << " payloads to database.");
308 return Database::Instance().storeData(payloads);
309}
Belle2::CalibrationAlgorithm::getPayloads
std::list< Database::DBImportQuery > & getPayloads()
Get constants (in TObjects) for database update from last execution.
Definition: CalibrationAlgorithm.h:204
Belle2::Database::Instance
static Database & Instance()
Instance of a singleton Database.
Definition: Database.cc:42
Belle2::Database::storeData
bool storeData(const std::string &name, TObject *object, const IntervalOfValidity &iov)
Store an object in the database.
Definition: Database.cc:141

◆ commit() [2/2]

bool commit ( std::list< Database::DBImportQuery >  payloads)
inherited

Submit constants from a (potentially previous) set of payloads.

Definition at line 311 of file CalibrationAlgorithm.cc.

312{
313 if (payloads.empty())
314 return false;
315 return Database::Instance().storeData(payloads);
316}

◆ convertPyExpRun()

ExpRun convertPyExpRun ( PyObject *  pyObj)
inherited

Performs the conversion of PyObject to ExpRun.

Converts the PyObject to an ExpRun. We've preoviously checked the object so this assumes a lot about the PyObject.

Definition at line 70 of file CalibrationAlgorithm.cc.

71{
72 ExpRun expRun;
73 PyObject* itemExp, *itemRun;
74 itemExp = PySequence_GetItem(pyObj, 0);
75 itemRun = PySequence_GetItem(pyObj, 1);
76 expRun.first = PyLong_AsLong(itemExp);
77 Py_DECREF(itemExp);
78 expRun.second = PyLong_AsLong(itemRun);
79 Py_DECREF(itemRun);
80 return expRun;
81}

◆ dumpOutputJson()

const std::string dumpOutputJson ( ) const
inlineinherited

Dump the JSON string of the output JSON object.

Definition at line 223 of file CalibrationAlgorithm.h.

223{return m_jsonExecutionOutput.dump();}
Belle2::CalibrationAlgorithm::m_jsonExecutionOutput
nlohmann::json m_jsonExecutionOutput
Optional output JSON object that can be set during the execution by the underlying algorithm code.
Definition: CalibrationAlgorithm.h:403

◆ execute() [1/2]

CalibrationAlgorithm::EResult execute ( PyObject *  runs,
int  iteration = 0,
IntervalOfValidity  iov = IntervalOfValidity() 
)
inherited

Runs calibration over Python list of runs. Converts to C++ and then calls the other execute() function.

Definition at line 83 of file CalibrationAlgorithm.cc.

84{
85 B2DEBUG(29, "Running execute() using Python Object as input argument");
86 // Reset the execution specific data in case the algorithm was previously called
87 m_data.reset();
88 m_data.setIteration(iteration);
89 vector<ExpRun> vecRuns;
90 // Is it a list?
91 if (PySequence_Check(runs)) {
92 boost::python::handle<> handle(boost::python::borrowed(runs));
93 boost::python::list listRuns(handle);
94
95 int nList = boost::python::len(listRuns);
96 for (int iList = 0; iList < nList; ++iList) {
97 boost::python::object pyExpRun(listRuns[iList]);
98 if (!checkPyExpRun(pyExpRun.ptr())) {
99 B2ERROR("Received Python ExpRuns couldn't be converted to C++");
100 m_data.setResult(c_Failure);
101 return c_Failure;
102 } else {
103 vecRuns.push_back(convertPyExpRun(pyExpRun.ptr()));
104 }
105 }
106 } else {
107 B2ERROR("Tried to set the input runs but we didn't receive a Python sequence object (list,tuple).");
108 m_data.setResult(c_Failure);
109 return c_Failure;
110 }
111 return execute(vecRuns, iteration, iov);
112}
Belle2::CalibrationAlgorithm::ExecutionData::setResult
void setResult(EResult result)
Setter for current iteration.
Definition: CalibrationAlgorithm.h:88
Belle2::CalibrationAlgorithm::ExecutionData::setIteration
void setIteration(int iteration)
Setter for current iteration.
Definition: CalibrationAlgorithm.h:80
Belle2::CalibrationAlgorithm::ExecutionData::reset
void reset()
Resets this class back to what is needed at the beginning of an execution.
Definition: CalibrationAlgorithm.h:58
Belle2::CalibrationAlgorithm::checkPyExpRun
bool checkPyExpRun(PyObject *pyObj)
Checks that a PyObject can be successfully converted to an ExpRun type.
Definition: CalibrationAlgorithm.cc:28
Belle2::CalibrationAlgorithm::execute
EResult execute(std::vector< Calibration::ExpRun > runs={}, int iteration=0, IntervalOfValidity iov=IntervalOfValidity())
Runs calibration over vector of runs for a given iteration.
Definition: CalibrationAlgorithm.cc:114
Belle2::CalibrationAlgorithm::convertPyExpRun
Calibration::ExpRun convertPyExpRun(PyObject *pyObj)
Performs the conversion of PyObject to ExpRun.
Definition: CalibrationAlgorithm.cc:70

◆ execute() [2/2]

CalibrationAlgorithm::EResult execute ( std::vector< Calibration::ExpRun >  runs = {},
int  iteration = 0,
IntervalOfValidity  iov = IntervalOfValidity() 
)
inherited

Runs calibration over vector of runs for a given iteration.

You can also specify the IoV to save the database payload as. By default the Algorithm will create an IoV from your requested ExpRuns, or from the overall ExpRuns of the input data if you haven't specified ExpRuns in this function.

No checks are performed to make sure that a IoV you specify matches the data you ran over, it simply labels the IoV to commit to the database later.

Definition at line 114 of file CalibrationAlgorithm.cc.

115{
116 // Check if we are calling this function directly and need to reset, or through Python where it was already done.
117 if (m_data.getResult() != c_Undefined) {
118 m_data.reset();
119 m_data.setIteration(iteration);
120 }
121
122 if (m_inputFileNames.empty()) {
123 B2ERROR("There aren't any input files set. Please use CalibrationAlgorithm::setInputFiles()");
124 m_data.setResult(c_Failure);
125 return c_Failure;
126 }
127
128 // Did we receive runs to execute over explicitly?
129 if (!(runs.empty())) {
130 for (auto expRun : runs) {
131 B2DEBUG(29, "ExpRun requested = (" << expRun.first << ", " << expRun.second << ")");
132 }
133 // We've asked explicitly for certain runs, but we should check if the data granularity is 'run'
134 if (strcmp(getGranularity().c_str(), "all") == 0) {
135 B2ERROR(("The data is collected with granularity=all (exp=-1,run=-1), but you seem to request calibration for specific runs."
136 " We'll continue but using ALL the input data given instead of the specific runs requested."));
137 }
138 } else {
139 // If no runs are provided, infer the runs from all collected data
140 runs = getRunListFromAllData();
141 // Let's check that we have some now
142 if (runs.empty()) {
143 B2ERROR("No collected data in input files.");
144 m_data.setResult(c_Failure);
145 return c_Failure;
146 }
147 for (auto expRun : runs) {
148 B2DEBUG(29, "ExpRun requested = (" << expRun.first << ", " << expRun.second << ")");
149 }
150 }
151
152 m_data.setRequestedRuns(runs);
153 if (iov.empty()) {
154 // If no user specified IoV we use the IoV from the executed run list
155 iov = IntervalOfValidity(runs[0].first, runs[0].second, runs[runs.size() - 1].first, runs[runs.size() - 1].second);
156 }
157 m_data.setRequestedIov(iov);
158 // After here, the getObject<...>(...) helpers start to work
159
160 CalibrationAlgorithm::EResult result = calibrate();
161 m_data.setResult(result);
162 return result;
163}
Belle2::CalibrationAlgorithm::ExecutionData::setRequestedIov
void setRequestedIov(const IntervalOfValidity &iov=IntervalOfValidity(0, 0, -1, -1))
Sets the requested IoV for this execution, based on the.
Definition: CalibrationAlgorithm.h:90
Belle2::CalibrationAlgorithm::ExecutionData::setRequestedRuns
void setRequestedRuns(const std::vector< Calibration::ExpRun > &requestedRuns)
Sets the vector of ExpRuns.
Definition: CalibrationAlgorithm.h:76
Belle2::CalibrationAlgorithm::ExecutionData::getResult
EResult getResult() const
Getter for current result.
Definition: CalibrationAlgorithm.h:86
Belle2::CalibrationAlgorithm::getRunListFromAllData
std::vector< Calibration::ExpRun > getRunListFromAllData() const
Get the complete list of runs from inspection of collected data.
Definition: CalibrationAlgorithm.cc:318
Belle2::CalibrationAlgorithm::m_inputFileNames
std::vector< std::string > m_inputFileNames
List of input files to the Algorithm, will initially be user defined but then gets the wildcards expa...
Definition: CalibrationAlgorithm.h:373
Belle2::CalibrationAlgorithm::EResult
EResult
The result of calibration.
Definition: CalibrationAlgorithm.h:40
Belle2::CalibrationAlgorithm::calibrate
virtual EResult calibrate()=0
Run algo on data - pure virtual: needs to be implemented.
Belle2::CalibrationAlgorithm::getGranularity
std::string getGranularity() const
Get the granularity of collected data.
Definition: CalibrationAlgorithm.h:188
Belle2::IntervalOfValidity
A class that describes the interval of experiments/runs for which an object in the database is valid.
Definition: IntervalOfValidity.h:25

◆ fillRunToInputFilesMap()

void fillRunToInputFilesMap ( )
inherited

Fill the mapping of ExpRun -> Files.

Definition at line 330 of file CalibrationAlgorithm.cc.

331{
332 m_runsToInputFiles.clear();
333 // Save TDirectory to change back at the end
334 TDirectory* dir = gDirectory;
335 RunRange* runRange;
336 // Construct the TDirectory name where we expect our objects to be
337 string runRangeObjName(getPrefix() + "/" + RUN_RANGE_OBJ_NAME);
338 for (const auto& fileName : m_inputFileNames) {
339 //Open TFile to get the objects
340 unique_ptr<TFile> f;
341 f.reset(TFile::Open(fileName.c_str(), "READ"));
342 runRange = dynamic_cast<RunRange*>(f->Get(runRangeObjName.c_str()));
343 if (runRange) {
344 // Insert or extend the run -> file mapping for this ExpRun
345 auto expRuns = runRange->getExpRunSet();
346 for (const auto& expRun : expRuns) {
347 auto runFiles = m_runsToInputFiles.find(expRun);
348 if (runFiles != m_runsToInputFiles.end()) {
349 (runFiles->second).push_back(fileName);
350 } else {
351 m_runsToInputFiles.insert(std::make_pair(expRun, std::vector<std::string> {fileName}));
352 }
353 }
354 } else {
355 B2WARNING("Missing a RunRange object for file: " << fileName);
356 }
357 }
358 dir->cd();
359}
Belle2::CalibrationAlgorithm::getPrefix
std::string getPrefix() const
Get the prefix used for getting calibration data.
Definition: CalibrationAlgorithm.h:146
Belle2::CalibrationAlgorithm::m_runsToInputFiles
std::map< Calibration::ExpRun, std::vector< std::string > > m_runsToInputFiles
Map of Runs to input files. Gets filled when you call getRunRangeFromAllData, gets cleared when setti...
Definition: CalibrationAlgorithm.h:376
Belle2::RunRange
Mergeable object holding (unique) set of (exp,run) pairs.
Definition: RunRange.h:25
Belle2::RunRange::getExpRunSet
const std::set< Calibration::ExpRun > & getExpRunSet()
Get access to the stored set.
Definition: RunRange.h:64

◆ findPayloadBoundaries()

const std::vector< ExpRun > findPayloadBoundaries ( std::vector< Calibration::ExpRun >  runs,
int  iteration = 0 
)
inherited

Used to discover the ExpRun boundaries that you want the Python CAF to execute on. This is optional and only used in some.

Definition at line 520 of file CalibrationAlgorithm.cc.

521{
522 m_boundaries.clear();
523 if (m_inputFileNames.empty()) {
524 B2ERROR("There aren't any input files set. Please use CalibrationAlgorithm::setInputFiles()");
525 return m_boundaries;
526 }
527 // Reset the internal execution data just in case something is hanging around
528 m_data.reset();
529 if (runs.empty()) {
530 // Want to loop over all runs we could possibly know about
531 runs = getRunListFromAllData();
532 }
533 // Let's check that we have some now
534 if (runs.empty()) {
535 B2ERROR("No collected data in input files.");
536 return m_boundaries;
537 }
538 // In order to find run boundaries we must have collected with data granularity == 'run'
539 if (strcmp(getGranularity().c_str(), "all") == 0) {
540 B2ERROR("The data is collected with granularity='all' (exp=-1,run=-1), and we can't use that to find run boundaries.");
541 return m_boundaries;
542 }
543 m_data.setIteration(iteration);
544 // User defined setup function
545 boundaryFindingSetup(runs, iteration);
546 std::vector<ExpRun> runList;
547 // Loop over run list and call derived class "isBoundaryRequired" member function
548 for (auto currentRun : runs) {
549 runList.push_back(currentRun);
550 m_data.setRequestedRuns(runList);
551 // After here, the getObject<...>(...) helpers start to work
552 if (isBoundaryRequired(currentRun)) {
553 m_boundaries.push_back(currentRun);
554 }
555 // Only want run-by-run
556 runList.clear();
557 // Don't want memory hanging around
558 m_data.clearCalibrationData();
559 }
560 m_data.reset();
561 boundaryFindingTearDown();
562 return m_boundaries;
563}
Belle2::CalibrationAlgorithm::m_boundaries
std::vector< Calibration::ExpRun > m_boundaries
When using the boundaries functionality from isBoundaryRequired, this is used to store the boundaries...
Definition: CalibrationAlgorithm.h:261
Belle2::CalibrationAlgorithm::boundaryFindingTearDown
virtual void boundaryFindingTearDown()
Put your algorithm back into a state ready for normal execution if you need to.
Definition: CalibrationAlgorithm.h:257
Belle2::CalibrationAlgorithm::boundaryFindingSetup
virtual void boundaryFindingSetup(std::vector< Calibration::ExpRun >, int)
If you need to make some changes to your algorithm class before 'findPayloadBoundaries' is run,...
Definition: CalibrationAlgorithm.h:252
Belle2::CalibrationAlgorithm::isBoundaryRequired
virtual bool isBoundaryRequired(const Calibration::ExpRun &)
Given the current collector data, make a decision about whether or not this run should be the start o...
Definition: CalibrationAlgorithm.h:243

◆ getAllGranularityExpRun()

Calibration::ExpRun getAllGranularityExpRun ( ) const
inlineprotectedinherited

Returns the Exp,Run pair that means 'Everything'. Currently unused.

Definition at line 327 of file CalibrationAlgorithm.h.

327{return m_allExpRun;}
Belle2::CalibrationAlgorithm::m_allExpRun
static const Calibration::ExpRun m_allExpRun
allExpRun
Definition: CalibrationAlgorithm.h:364

◆ getCollectorName()

std::string getCollectorName ( ) const
inlineinherited

Alias for prefix.

For convenience and less writing, we say developers to set this to default collector module name in constructor of base class. One can however use the dublets of collector+algorithm multiple times with different settings. To bind these together correctly, the prefix has to be set the same for algo and collector. So we call the setter setPrefix rather than setModuleName or whatever. This getter will work out of the box for default cases -> return the name of module you have to add to your path to collect data for this algorithm.

Definition at line 164 of file CalibrationAlgorithm.h.

164{return getPrefix();}

◆ getDescription()

const std::string & getDescription ( ) const
inlineinherited

Get the description of the algorithm (set by developers in constructor)

Definition at line 216 of file CalibrationAlgorithm.h.

216{return m_description;}
Belle2::CalibrationAlgorithm::m_description
std::string m_description
Description of the algorithm.
Definition: CalibrationAlgorithm.h:385

◆ getExpRunString()

string getExpRunString ( Calibration::ExpRun &  expRun) const
privateinherited

Gets the "exp.run" string repr. of (exp,run)

Definition at line 254 of file CalibrationAlgorithm.cc.

255{
256 string expRunString;
257 expRunString += to_string(expRun.first);
258 expRunString += ".";
259 expRunString += to_string(expRun.second);
260 return expRunString;
261}

◆ getFullObjectPath()

string getFullObjectPath ( const std::string &  name,
Calibration::ExpRun  expRun 
) const
privateinherited

constructs the full TDirectory + Key name of an object in a TFile based on its name and exprun

Definition at line 263 of file CalibrationAlgorithm.cc.

264{
265 string dirName = getPrefix() + "/" + name;
266 string objName = name + "_" + getExpRunString(expRun);
267 return dirName + "/" + objName;
268}
Belle2::CalibrationAlgorithm::getExpRunString
std::string getExpRunString(Calibration::ExpRun &expRun) const
Gets the "exp.run" string repr. of (exp,run)
Definition: CalibrationAlgorithm.cc:254

◆ getGranularity()

std::string getGranularity ( ) const
inlineinherited

Get the granularity of collected data.

Definition at line 188 of file CalibrationAlgorithm.h.

188{return m_granularityOfData;};
Belle2::CalibrationAlgorithm::m_granularityOfData
std::string m_granularityOfData
Granularity of input data. This only changes when the input files change so it isn't specific to an e...
Definition: CalibrationAlgorithm.h:379

◆ getGranularityFromData()

string getGranularityFromData ( ) const
protectedinherited

Get the granularity of collected data.

Definition at line 383 of file CalibrationAlgorithm.cc.

384{
385 // Save TDirectory to change back at the end
386 TDirectory* dir = gDirectory;
387 RunRange* runRange;
388 string runRangeObjName(getPrefix() + "/" + RUN_RANGE_OBJ_NAME);
389 // We only check the first file
390 string fileName = m_inputFileNames[0];
391 unique_ptr<TFile> f;
392 f.reset(TFile::Open(fileName.c_str(), "READ"));
393 runRange = dynamic_cast<RunRange*>(f->Get(runRangeObjName.c_str()));
394 if (!runRange) {
395 B2FATAL("The input file " << fileName << " does not contain a RunRange object at "
396 << runRangeObjName << ". Please set your input files to exclude it.");
397 return "";
398 }
399 string granularity = runRange->getGranularity();
400 dir->cd();
401 return granularity;
402}
Belle2::RunRange::getGranularity
std::string getGranularity() const
Gets the m_granularity.
Definition: RunRange.h:110

◆ getInputFileNames()

PyObject * getInputFileNames ( )
inherited

Get the input file names used for this algorithm and pass them out as a Python list of unicode strings.

Definition at line 245 of file CalibrationAlgorithm.cc.

246{
247 PyObject* objInputFileNames = PyList_New(m_inputFileNames.size());
248 for (size_t i = 0; i < m_inputFileNames.size(); ++i) {
249 PyList_SetItem(objInputFileNames, i, Py_BuildValue("s", m_inputFileNames[i].c_str()));
250 }
251 return objInputFileNames;
252}

◆ getInputJsonObject()

const nlohmann::json & getInputJsonObject ( ) const
inlineprotectedinherited

Get the entire top level JSON object. We explicitly say this must be of object type so that we might pick.

Definition at line 357 of file CalibrationAlgorithm.h.

357{return m_jsonExecutionInput;}
Belle2::CalibrationAlgorithm::m_jsonExecutionInput
nlohmann::json m_jsonExecutionInput
Optional input JSON object used to make decisions about how to execute the algorithm code.
Definition: CalibrationAlgorithm.h:397

◆ getInputJsonValue()

const T getInputJsonValue ( const std::string &  key) const
inlineprotectedinherited

Get an input JSON value using a key. The normal exceptions are raised when the key doesn't exist.

Definition at line 350 of file CalibrationAlgorithm.h.

351 {
352 return m_jsonExecutionInput.at(key);
353 }

◆ getIovFromAllData()

IntervalOfValidity getIovFromAllData ( ) const
inherited

Get the complete IoV from inspection of collected data.

Definition at line 325 of file CalibrationAlgorithm.cc.

326{
327 return getRunRangeFromAllData().getIntervalOfValidity();
328}
Belle2::CalibrationAlgorithm::getRunRangeFromAllData
RunRange getRunRangeFromAllData() const
Get the complete RunRange from inspection of collected data.
Definition: CalibrationAlgorithm.cc:361
Belle2::RunRange::getIntervalOfValidity
IntervalOfValidity getIntervalOfValidity()
Make IntervalOfValidity from the set, spanning all runs. Works because sets are sorted by default.
Definition: RunRange.h:70

◆ getIteration()

int getIteration ( ) const
inlineprotectedinherited

Get current iteration.

Definition at line 269 of file CalibrationAlgorithm.h.

269{ return m_data.getIteration(); }
Belle2::CalibrationAlgorithm::ExecutionData::getIteration
int getIteration() const
Getter for current iteration.
Definition: CalibrationAlgorithm.h:78

◆ getObjectPtr()

std::shared_ptr< T > getObjectPtr ( std::string  name)
inlineprotectedinherited

Get calibration data object (for all runs the calibration is requested for) This function will only work during or after execute() has been called once.

Definition at line 285 of file CalibrationAlgorithm.h.

286 {
287 if (m_runsToInputFiles.size() == 0)
288 fillRunToInputFilesMap();
289 return getObjectPtr<T>(name, m_data.getRequestedRuns());
290 }
Belle2::CalibrationAlgorithm::ExecutionData::getRequestedRuns
const std::vector< Calibration::ExpRun > & getRequestedRuns() const
Returns the vector of ExpRuns.
Definition: CalibrationAlgorithm.h:74
Belle2::CalibrationAlgorithm::fillRunToInputFilesMap
void fillRunToInputFilesMap()
Fill the mapping of ExpRun -> Files.
Definition: CalibrationAlgorithm.cc:330

◆ getOutputJsonValue()

const T getOutputJsonValue ( const std::string &  key) const
inlineprotectedinherited

Get a value using a key from the JSON output object, not sure why you would want to do this.

Definition at line 342 of file CalibrationAlgorithm.h.

343 {
344 return m_jsonExecutionOutput.at(key);
345 }

◆ getPayloads()

std::list< Database::DBImportQuery > & getPayloads ( )
inlineinherited

Get constants (in TObjects) for database update from last execution.

Definition at line 204 of file CalibrationAlgorithm.h.

204{return m_data.getPayloads();}
Belle2::CalibrationAlgorithm::ExecutionData::getPayloads
std::list< Database::DBImportQuery > & getPayloads()
Get constants (in TObjects) for database update from last calibration.
Definition: CalibrationAlgorithm.h:94

◆ getPayloadValues()

std::list< Database::DBImportQuery > getPayloadValues ( )
inlineinherited

Get constants (in TObjects) for database update from last execution but passed by VALUE.

Definition at line 207 of file CalibrationAlgorithm.h.

207{return m_data.getPayloadValues();}
Belle2::CalibrationAlgorithm::ExecutionData::getPayloadValues
std::list< Database::DBImportQuery > getPayloadValues()
Get constants (in TObjects) for database update from last calibration but passed by VALUE.
Definition: CalibrationAlgorithm.h:96

◆ getPrefix()

std::string getPrefix ( ) const
inlineinherited

Get the prefix used for getting calibration data.

Definition at line 146 of file CalibrationAlgorithm.h.

146{return m_prefix;}
Belle2::CalibrationAlgorithm::m_prefix
std::string m_prefix
The name of the TDirectory the collector objects are contained within.
Definition: CalibrationAlgorithm.h:388

◆ getRunList()

const std::vector< Calibration::ExpRun > & getRunList ( ) const
inlineprotectedinherited

Get the list of runs for which calibration is called.

Definition at line 266 of file CalibrationAlgorithm.h.

266{return m_data.getRequestedRuns();}

◆ getRunListFromAllData()

vector< ExpRun > getRunListFromAllData ( ) const
inherited

Get the complete list of runs from inspection of collected data.

Definition at line 318 of file CalibrationAlgorithm.cc.

319{
320 RunRange runRange = getRunRangeFromAllData();
321 set<ExpRun> expRunSet = runRange.getExpRunSet();
322 return vector<ExpRun>(expRunSet.begin(), expRunSet.end());
323}

◆ getRunRangeFromAllData()

RunRange getRunRangeFromAllData ( ) const
inherited

Get the complete RunRange from inspection of collected data.

Definition at line 361 of file CalibrationAlgorithm.cc.

362{
363 // Save TDirectory to change back at the end
364 TDirectory* dir = gDirectory;
365 RunRange runRange;
366 // Construct the TDirectory name where we expect our objects to be
367 string runRangeObjName(getPrefix() + "/" + RUN_RANGE_OBJ_NAME);
368 for (const auto& fileName : m_inputFileNames) {
369 //Open TFile to get the objects
370 unique_ptr<TFile> f;
371 f.reset(TFile::Open(fileName.c_str(), "READ"));
372 RunRange* runRangeOther = dynamic_cast<RunRange*>(f->Get(runRangeObjName.c_str()));
373 if (runRangeOther) {
374 runRange.merge(runRangeOther);
375 } else {
376 B2WARNING("Missing a RunRange object for file: " << fileName);
377 }
378 }
379 dir->cd();
380 return runRange;
381}
Belle2::RunRange::merge
virtual void merge(const RunRange *other)
Implementation of merging - other is added to the set (union)
Definition: RunRange.h:52

◆ getVecInputFileNames()

std::vector< std::string > getVecInputFileNames ( ) const
inlineprotectedinherited

Get the input file names used for this algorithm as a STL vector.

Definition at line 275 of file CalibrationAlgorithm.h.

275{return m_inputFileNames;}

◆ inputJsonKeyExists()

bool inputJsonKeyExists ( const std::string &  key) const
inlineprotectedinherited

Test for a key in the input JSON object.

Definition at line 360 of file CalibrationAlgorithm.h.

360{return m_jsonExecutionInput.count(key);}

◆ isBoundaryRequired()

virtual bool isBoundaryRequired ( const Calibration::ExpRun &  )
inlineprotectedvirtualinherited

Given the current collector data, make a decision about whether or not this run should be the start of a payload boundary.

Reimplemented in TestBoundarySettingAlgorithm, PXDAnalyticGainCalibrationAlgorithm, PXDValidationAlgorithm, TestCalibrationAlgorithm, SVD3SampleCoGTimeCalibrationAlgorithm, SVD3SampleELSTimeCalibrationAlgorithm, and SVDCoGTimeCalibrationAlgorithm.

Definition at line 243 of file CalibrationAlgorithm.h.

244 {
245 B2ERROR("You didn't implement a isBoundaryRequired() member function in your CalibrationAlgorithm but you are calling it!");
246 return false;
247 }

◆ loadInputJson()

bool loadInputJson ( const std::string &  jsonString)
inherited

Load the m_inputJson variable from a string (useful from Python interface). The return bool indicates success or failure.

Definition at line 502 of file CalibrationAlgorithm.cc.

503{
504 try {
505 auto jsonInput = nlohmann::json::parse(jsonString);
506 // Input string has an object (dict) as the top level object?
507 if (jsonInput.is_object()) {
508 m_jsonExecutionInput = jsonInput;
509 return true;
510 } else {
511 B2ERROR("JSON input string isn't an object type i.e. not a '{}' at the top level.");
512 return false;
513 }
514 } catch (nlohmann::json::parse_error&) {
515 B2ERROR("Parsing of JSON input string failed");
516 return false;
517 }
518}

◆ resetInputJson()

void resetInputJson ( )
inlineprotectedinherited

Clears the m_inputJson member variable.

Definition at line 330 of file CalibrationAlgorithm.h.

330{m_jsonExecutionInput.clear();}

◆ resetOutputJson()

void resetOutputJson ( )
inlineprotectedinherited

Clears the m_outputJson member variable.

Definition at line 333 of file CalibrationAlgorithm.h.

333{m_jsonExecutionOutput.clear();}

◆ saveCalibration() [1/6]

void saveCalibration ( TClonesArray *  data,
const std::string &  name 
)
protectedinherited

Store DBArray payload with given name with default IOV.

Definition at line 297 of file CalibrationAlgorithm.cc.

298{
299 saveCalibration(data, name, m_data.getRequestedIov());
300}
Belle2::CalibrationAlgorithm::ExecutionData::getRequestedIov
const IntervalOfValidity & getRequestedIov() const
Getter for requested IOV.
Definition: CalibrationAlgorithm.h:92
Belle2::CalibrationAlgorithm::saveCalibration
void saveCalibration(TClonesArray *data, const std::string &name)
Store DBArray payload with given name with default IOV.
Definition: CalibrationAlgorithm.cc:297

◆ saveCalibration() [2/6]

void saveCalibration ( TClonesArray *  data,
const std::string &  name,
const IntervalOfValidity &  iov 
)
protectedinherited

Store DBArray with given name and custom IOV.

Definition at line 276 of file CalibrationAlgorithm.cc.

277{
278 B2DEBUG(29, "Saving calibration TClonesArray '" << name << "' to payloads list.");
279 getPayloads().emplace_back(name, data, iov);
280}

◆ saveCalibration() [3/6]

void saveCalibration ( TObject *  data)
protectedinherited

Store DB payload with default name and default IOV.

Definition at line 287 of file CalibrationAlgorithm.cc.

288{
289 saveCalibration(data, DataStore::objectName(data->IsA(), ""));
290}
Belle2::DataStore::objectName
static std::string objectName(const TClass *t, const std::string &name)
Return the storage name for an object of the given TClass and name.
Definition: DataStore.cc:151

◆ saveCalibration() [4/6]

void saveCalibration ( TObject *  data,
const IntervalOfValidity &  iov 
)
protectedinherited

Store DB payload with default name and custom IOV.

Definition at line 282 of file CalibrationAlgorithm.cc.

283{
284 saveCalibration(data, DataStore::objectName(data->IsA(), ""), iov);
285}

◆ saveCalibration() [5/6]

void saveCalibration ( TObject *  data,
const std::string &  name 
)
protectedinherited

Store DB payload with given name with default IOV.

Definition at line 292 of file CalibrationAlgorithm.cc.

293{
294 saveCalibration(data, name, m_data.getRequestedIov());
295}

◆ saveCalibration() [6/6]

void saveCalibration ( TObject *  data,
const std::string &  name,
const IntervalOfValidity &  iov 
)
protectedinherited

Store DB payload with given name and custom IOV.

Definition at line 270 of file CalibrationAlgorithm.cc.

271{
272 B2DEBUG(29, "Saving calibration TObject = '" << name << "' to payloads list.");
273 getPayloads().emplace_back(name, data, iov);
274}

◆ setDescription()

void setDescription ( const std::string &  description)
inlineprotectedinherited

Set algorithm description (in constructor)

Definition at line 321 of file CalibrationAlgorithm.h.

321{m_description = description;}

◆ setInputFileNames() [1/2]

void setInputFileNames ( PyObject *  inputFileNames)
inherited

Set the input file names used for this algorithm from a Python list.

Set the input file names used for this algorithm and resolve the wildcards.

Definition at line 166 of file CalibrationAlgorithm.cc.

167{
168 // The reasoning for this very 'manual' approach to extending the Python interface
169 // (instead of using boost::python) is down to my fear of putting off final users with
170 // complexity on their side.
171 //
172 // I didn't want users that inherit from this class to be forced to use boost and
173 // to have to define a new python module just to use the CAF. A derived class from
174 // from a boost exposed class would need to have its own boost python module definition
175 // to allow access from a steering file and to the base class functions (I think).
176 // I also couldn't be bothered to write a full framework to get around the issue in a similar
177 // way to Module()...maybe there's an easy way.
178 //
179 // But this way we can allow people to continue using their ROOT implemented classes and inherit
180 // easily from this one. But add in a few helper functions that work with Python objects
181 // created in their steering file i.e. instead of being forced to use STL objects as input
182 // to the algorithm.
183 if (PyList_Check(inputFileNames)) {
184 boost::python::handle<> handle(boost::python::borrowed(inputFileNames));
185 boost::python::list listInputFileNames(handle);
186 auto vecInputFileNames = PyObjConvUtils::convertPythonObject(listInputFileNames, vector<string>());
187 setInputFileNames(vecInputFileNames);
188 } else {
189 B2ERROR("Tried to set the input files but we didn't receive a Python list.");
190 }
191}
Belle2::CalibrationAlgorithm::setInputFileNames
void setInputFileNames(PyObject *inputFileNames)
Set the input file names used for this algorithm from a Python list.
Definition: CalibrationAlgorithm.cc:166
Belle2::PyObjConvUtils::convertPythonObject
Scalar convertPythonObject(const boost::python::object &pyObject, Scalar)
Convert from Python to given type.
Definition: PyObjConvUtils.h:500

◆ setInputFileNames() [2/2]

void setInputFileNames ( std::vector< std::string >  inputFileNames)
protectedinherited

Set the input file names used for this algorithm.

Set the input file names used for this algorithm and resolve the wildcards.

Definition at line 194 of file CalibrationAlgorithm.cc.

195{
196 // A lot of code below is tweaked from RootInputModule::initialize,
197 // since we're basically copying the functionality anyway.
198 if (inputFileNames.empty()) {
199 B2WARNING("You have called setInputFileNames() with an empty list. Did you mean to do that?");
200 return;
201 }
202 auto tmpInputFileNames = RootIOUtilities::expandWordExpansions(inputFileNames);
203
204 // We'll use a set to enforce sorted unique file paths as we check them
205 set<string> setInputFileNames;
206 // Check that files exist and convert to absolute paths
207 for (auto path : tmpInputFileNames) {
208 string fullPath = fs::absolute(path).string();
209 if (fs::exists(fullPath)) {
210 setInputFileNames.insert(fs::canonical(fullPath).string());
211 } else {
212 B2WARNING("Couldn't find the file " << path);
213 }
214 }
215
216 if (setInputFileNames.empty()) {
217 B2WARNING("No valid files specified!");
218 return;
219 } else {
220 // Reset the run -> files map as our files are likely different
221 m_runsToInputFiles.clear();
222 }
223
224 // Open TFile to check they can be accessed by ROOT
225 TDirectory* dir = gDirectory;
226 for (const string& fileName : setInputFileNames) {
227 unique_ptr<TFile> f;
228 try {
229 f.reset(TFile::Open(fileName.c_str(), "READ"));
230 } catch (logic_error&) {
231 //this might happen for ~invaliduser/foo.root
232 //actually undefined behaviour per standard, reported as ROOT-8490 in JIRA
233 }
234 if (!f || !f->IsOpen()) {
235 B2FATAL("Couldn't open input file " + fileName);
236 }
237 }
238 dir->cd();
239
240 // Copy the entries of the set to a vector
241 m_inputFileNames = vector<string>(setInputFileNames.begin(), setInputFileNames.end());
242 m_granularityOfData = getGranularityFromData();
243}
Belle2::CalibrationAlgorithm::getGranularityFromData
std::string getGranularityFromData() const
Get the granularity of collected data.
Definition: CalibrationAlgorithm.cc:383
Belle2::RootIOUtilities::expandWordExpansions
std::vector< std::string > expandWordExpansions(const std::vector< std::string > &filenames)
Performs wildcard expansion using wordexp(), returns matches.
Definition: RootIOUtilities.cc:114

◆ setOutputJsonValue()

void setOutputJsonValue ( const std::string &  key,
const T &  value 
)
inlineprotectedinherited

Set a key:value pair for the outputJson object, expected to used internally during calibrate()

Definition at line 337 of file CalibrationAlgorithm.h.

337{m_jsonExecutionOutput[key] = value;}

◆ setPrefix()

void setPrefix ( const std::string &  prefix)
inlineinherited

Set the prefix used to identify datastore objects.

Definition at line 167 of file CalibrationAlgorithm.h.

167{m_prefix = prefix;}

◆ updateDBObjPtrs()

void updateDBObjPtrs ( const unsigned int  event = 1,
const int  run = 0,
const int  experiment = 0 
)
protectedinherited

Updates any DBObjPtrs by calling update(event) for DBStore.

Definition at line 404 of file CalibrationAlgorithm.cc.

405{
406 // Construct an EventMetaData object but NOT in the Datastore
407 EventMetaData emd(event, run, experiment);
408 // Explicitly update while avoiding registering a Datastore object
409 DBStore::Instance().update(emd);
410 // Also update the intra-run objects to the event at the same time (maybe unnecessary...)
411 DBStore::Instance().updateEvent(event);
412}
Belle2::EventMetaData
Store event, run, and experiment numbers.
Definition: EventMetaData.h:33

Member Data Documentation

◆ algorithmReadPayloads

bool algorithmReadPayloads

Whether or not to have the algorithm code to loop over all the runs and read the payloads itself.


Definition at line 60 of file eclTimeShiftsAlgorithm.h.

◆ crysCrateShift_max

double crysCrateShift_max

Plotting time max for crystal+crate shift plots.

Definition at line 56 of file eclTimeShiftsAlgorithm.h.

◆ crysCrateShift_min

double crysCrateShift_min

Plotting time min for crystal+crate shift plots.

Definition at line 55 of file eclTimeShiftsAlgorithm.h.

◆ debugFilenameBase

std::string debugFilenameBase

Name of file with debug output, eclTimeShiftsAlgorithm.root by default.

Definition at line 49 of file eclTimeShiftsAlgorithm.h.

◆ m_allExpRun

const ExpRun m_allExpRun = make_pair(-1, -1)
staticprivateinherited

allExpRun

Definition at line 364 of file CalibrationAlgorithm.h.

◆ m_boundaries

std::vector<Calibration::ExpRun> m_boundaries
protectedinherited

When using the boundaries functionality from isBoundaryRequired, this is used to store the boundaries. It is cleared when.

Definition at line 261 of file CalibrationAlgorithm.h.

◆ m_crateID

Int_t m_crateID
private

Crate ID number.

Definition at line 92 of file eclTimeShiftsAlgorithm.h.

◆ m_crateTimeConst

Double_t m_crateTimeConst
private

Crate time calibration constant.

Definition at line 88 of file eclTimeShiftsAlgorithm.h.

◆ m_crateTimeUnc

Double_t m_crateTimeUnc
private

Uncertainty on the crate time calibration constant.

Definition at line 90 of file eclTimeShiftsAlgorithm.h.

◆ m_crystalID

Int_t m_crystalID
private

Crystal ID number.

Definition at line 87 of file eclTimeShiftsAlgorithm.h.

◆ m_crystalTimeConst

Double_t m_crystalTimeConst
private

Crystal time calibration constant.

Definition at line 89 of file eclTimeShiftsAlgorithm.h.

◆ m_crystalTimeUnc

Double_t m_crystalTimeUnc
private

Uncertainty on the crystal time calibration constant.

Definition at line 91 of file eclTimeShiftsAlgorithm.h.

◆ m_data

ExecutionData m_data
privateinherited

Data specific to a SINGLE execution of the algorithm. Gets reset at the beginning of execution.

Definition at line 382 of file CalibrationAlgorithm.h.

◆ m_description

std::string m_description {""}
privateinherited

Description of the algorithm.

Definition at line 385 of file CalibrationAlgorithm.h.

◆ m_ECLCrateTimeOffset

DBObjPtr<ECLCrystalCalib> m_ECLCrateTimeOffset
private

ECLCrateTimeOffset payload that we want to read from the DB.

Definition at line 73 of file eclTimeShiftsAlgorithm.h.

◆ m_ECLCrystalTimeOffset

DBObjPtr<ECLCrystalCalib> m_ECLCrystalTimeOffset
private

ECLCrystalTimeOffset payload that we want to read from the DB.

Definition at line 70 of file eclTimeShiftsAlgorithm.h.

◆ m_exp_perCrystal

Int_t m_exp_perCrystal
private

Experiment number

Definition at line 86 of file eclTimeShiftsAlgorithm.h.

◆ m_granularityOfData

std::string m_granularityOfData
privateinherited

Granularity of input data. This only changes when the input files change so it isn't specific to an execution.

Definition at line 379 of file CalibrationAlgorithm.h.

◆ m_inputFileNames

std::vector<std::string> m_inputFileNames
privateinherited

List of input files to the Algorithm, will initially be user defined but then gets the wildcards expanded during execute()

Definition at line 373 of file CalibrationAlgorithm.h.

◆ m_jsonExecutionInput

nlohmann::json m_jsonExecutionInput = nlohmann::json::object()
privateinherited

Optional input JSON object used to make decisions about how to execute the algorithm code.

Definition at line 397 of file CalibrationAlgorithm.h.

◆ m_jsonExecutionOutput

nlohmann::json m_jsonExecutionOutput = nlohmann::json::object()
privateinherited

Optional output JSON object that can be set during the execution by the underlying algorithm code.

Definition at line 403 of file CalibrationAlgorithm.h.

◆ m_numCrates

const int m_numCrates = 52
private

Number of Crates expected.

Definition at line 82 of file eclTimeShiftsAlgorithm.h.

◆ m_numCrystals

const int m_numCrystals = ECLElementNumbers::c_NCrystals
private

Number of Crystals expected.

Definition at line 79 of file eclTimeShiftsAlgorithm.h.

◆ m_prefix

std::string m_prefix {""}
privateinherited

The name of the TDirectory the collector objects are contained within.

Definition at line 388 of file CalibrationAlgorithm.h.

◆ m_refCrysIDzeroingCrate

DBObjPtr<ECLReferenceCrystalPerCrateCalib> m_refCrysIDzeroingCrate
private

payload that we want to read from the DB

Definition at line 76 of file eclTimeShiftsAlgorithm.h.

◆ m_refCrystalID

Int_t m_refCrystalID
private

Crystal ID number for the reference crystal.

Definition at line 97 of file eclTimeShiftsAlgorithm.h.

◆ m_run_perCrystal

Int_t m_run_perCrystal
private

Run number.

Definition at line 85 of file eclTimeShiftsAlgorithm.h.

◆ m_runsToInputFiles

std::map<Calibration::ExpRun, std::vector<std::string> > m_runsToInputFiles
privateinherited

Map of Runs to input files. Gets filled when you call getRunRangeFromAllData, gets cleared when setting input files again.

Definition at line 376 of file CalibrationAlgorithm.h.

◆ m_tcrate_max_cut

double m_tcrate_max_cut = 150
private

Maximum value cut for the crate time calibration constant for plotting

Definition at line 101 of file eclTimeShiftsAlgorithm.h.

◆ m_tcrate_min_cut

double m_tcrate_min_cut = -150
private

Minimum value cut for the crate time calibration constant for plotting.

Definition at line 100 of file eclTimeShiftsAlgorithm.h.

◆ m_tcrate_unc_max_cut

double m_tcrate_unc_max_cut = 0.4
private

Maximum value cut for the crate time calibration constant uncertainty for plotting.

Definition at line 103 of file eclTimeShiftsAlgorithm.h.

◆ m_tcrate_unc_min_cut

double m_tcrate_unc_min_cut = 0.0001
private

Minimum value cut for the crate time calibration constant uncertainty for plotting.

Definition at line 102 of file eclTimeShiftsAlgorithm.h.

◆ timeShiftForPlotStyle

double timeShiftForPlotStyle[52]

List of time offsets, one per crate, used just to centre the time constants around zero.

Definition at line 53 of file eclTimeShiftsAlgorithm.h.

The documentation for this class was generated from the following files: