Belle II Software development
CDCDedxInjectTimeAlgorithm Class Reference

A calibration algorithm for CDC dE/dx injection time (HER/LER) More...

#include <CDCDedxInjectTimeAlgorithm.h>

Inheritance diagram for CDCDedxInjectTimeAlgorithm:
CalibrationAlgorithm

Public Types

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

Public Member Functions

 CDCDedxInjectTimeAlgorithm ()
 Constructor: Sets the description, the properties and the parameters of the algorithm.
 
virtual ~CDCDedxInjectTimeAlgorithm ()
 Destructor.
 
void setMergePayload (bool value=true)
 function to decide merged vs relative calibration
 
void setMonitoringPlots (bool value=false)
 function to enable monitoring plots
 
void setFitWidth (double value)
 function to set fit range (sigma)
 
void setMinTracks (int value)
 function to set min # of tracks in time bins (0-40ms)
 
void setDedxPars (int value, double min, double max)
 function to set dedx hist parameters
 
void setChiPars (int value, double min, double max)
 function to set chi hist parameters
 
void fitGaussianWRange (TH1D *&temphist, fstatus &status)
 function to perform gauss fit for input histogram
 
void getExpRunInfo ()
 function to get exp/run information (payload object, plotting)
 
void defineTimeBins ()
 function to set/reset time bins
 
void defineHisto (std::array< std::vector< TH1D * >, numdedx::nrings > &htemp, std::string var)
 function to define histograms for dedx and time dist.
 
void defineTimeHisto (std::array< std::array< TH1D *, 3 >, numdedx::nrings > &htemp)
 function to define injection time bins histograms (monitoring only)
 
void checkStatistics (std::array< std::vector< TH1D * >, numdedx::nrings > &hvar)
 check statistics for obtaining calibration const.
 
void correctBinBias (std::map< int, std::vector< double > > &varcorr, std::map< int, std::vector< double > > &var, std::map< int, std::vector< double > > &time, TH1D *&htimes)
 function to correct dedx mean/reso and return corrected vector map
 
void createPayload (std::array< double, numdedx::nrings > &scale, std::map< int, std::vector< double > > &vmeans, std::map< int, std::vector< double > > &varscal, std::string svar)
 function to store payloads after full calibration
 
void getMeanReso (std::array< std::vector< TH1D * >, numdedx::nrings > &hvar, std::map< int, std::vector< double > > &vmeans, std::map< int, std::vector< double > > &vresos)
 function to get mean and reso of histogram
 
void plotEventStats ()
 function to draw event/track statistics plots
 
void plotBinLevelDist (std::array< std::vector< TH1D * >, numdedx::nrings > &hvar, std::string var)
 function to draw dedx, chi and time dist.
 
void plotRelConstants (std::map< int, std::vector< double > > &vmeans, std::map< int, std::vector< double > > &vresos, std::map< int, std::vector< double > > &corr, std::string svar)
 function to relative constant from dedx fit mean and chi fit reso
 
void plotTimeStat (std::array< std::vector< TH1D * >, numdedx::nrings > &htime)
 function to draw time stats
 
void plotFinalConstants (std::map< int, std::vector< double > > &vmeans, std::map< int, std::vector< double > > &vresos, std::array< double, numdedx::nrings > &scale, std::array< double, numdedx::nrings > &scale_reso)
 function to final constant from merging or abs fits
 
void plotInjectionTime (std::array< std::array< TH1D *, 3 >, numdedx::nrings > &hvar)
 function to injection time distributions (HER/LER in three bins)
 
void setHistStyle (TH1D *&htemp, const int ic, const int is, const double min, const double max)
 function to set histogram cosmetics
 
std::string getTimeBinLabel (const double &tedges, const int &it)
 function to return time label for histograms labeling
 
void deleteHisto (std::array< std::vector< TH1D * >, numdedx::nrings > &htemp)
 function to delete histograms for dedx and time dist.
 
void deleteTimeHisto (std::array< std::array< TH1D *, 3 >, numdedx::nrings > &htemp)
 function to define injection time bins histograms (monitoring only)
 
double getCorrection (unsigned int ring, unsigned int time, std::map< int, std::vector< double > > &vmeans)
 function to get the correction factor of mean
 
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::DBImportQuerygetPayloadValues ()
 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>.
 

Protected Member Functions

virtual EResult calibrate () override
 CDC dE/dx Injection time 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

std::array< std::string, numdedx::nrings > m_sring {"ler", "her"}
 injection ring name
 
std::vector< double > m_vtedges
 external time vector
 
std::vector< double > m_vtlocaledges
 internal time vector
 
double * m_tedges
 internal time array (copy of vtlocaledges)
 
unsigned int m_tbins
 internal time bins
 
double m_sigmaR
 fit dedx dist in sigma range
 
int m_dedxBins
 bins for dedx histogram
 
double m_dedxMin
 min range of dedx
 
double m_dedxMax
 max range of dedx
 
int m_chiBins
 bins for chi histogram
 
double m_chiMin
 min range of chi
 
double m_chiMax
 max range of chi
 
int m_countR
 a hack for running functions once
 
int m_thersE
 min tracks to start calibration
 
bool m_isminStat
 flag to merge runs for statistics thershold
 
bool m_ismakePlots
 produce plots for monitoring
 
bool m_isMerge
 merge payload when rel constant
 
std::string m_prefix
 string prefix for plot names
 
std::string m_suffix
 string suffix for object names
 
std::vector< std::vector< double > > m_vinjPayload
 vector to store payload values
 
DBObjPtr< CDCDedxInjectionTimem_DBInjectTime
 Injection time DB object.
 
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.
 
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 int c_rings = numdedx::nrings
 injection ring constants
 
static const Calibration::ExpRun m_allExpRun = make_pair(-1, -1)
 allExpRun
 

Detailed Description

A calibration algorithm for CDC dE/dx injection time (HER/LER)

Definition at line 36 of file CDCDedxInjectTimeAlgorithm.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 };

Constructor & Destructor Documentation

◆ CDCDedxInjectTimeAlgorithm()

Constructor: Sets the description, the properties and the parameters of the algorithm.

Definition at line 25 of file CDCDedxInjectTimeAlgorithm.cc.

25 :
26 CalibrationAlgorithm("CDCDedxElectronCollector"),
27 m_sigmaR(2.0),
28 m_dedxBins(250),
29 m_dedxMin(0.0),
30 m_dedxMax(2.5),
31 m_chiBins(250),
32 m_chiMin(-10.0),
33 m_chiMax(10.0),
34 m_countR(0),
35 m_thersE(1000),
36 m_isminStat(false),
37 m_ismakePlots(true),
38 m_isMerge(true),
39 m_prefix("cdcdedx_injcal"),
40 m_suffix("")
41{
42 // Set module properties
43 setDescription("A calibration algorithm for CDC dE/dx injection time gain and reso");
44}
bool m_isMerge
merge payload when rel constant
double m_sigmaR
fit dedx dist in sigma range
std::string m_prefix
string prefix for plot names
int m_countR
a hack for running functions once
bool m_ismakePlots
produce plots for monitoring
std::string m_suffix
string suffix for object names
bool m_isminStat
flag to merge runs for statistics thershold
int m_thersE
min tracks to start calibration
void setDescription(const std::string &description)
Set algorithm description (in constructor)
CalibrationAlgorithm(const std::string &collectorModuleName)
Constructor - sets the prefix for collected objects (won't be accesses until execute(....

◆ ~CDCDedxInjectTimeAlgorithm()

virtual ~CDCDedxInjectTimeAlgorithm ( )
inlinevirtual

Destructor.

Definition at line 48 of file CDCDedxInjectTimeAlgorithm.h.

48{}

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 PXDAnalyticGainCalibrationAlgorithm, PXDValidationAlgorithm, SVD3SampleCoGTimeCalibrationAlgorithm, SVD3SampleELSTimeCalibrationAlgorithm, SVDCoGTimeCalibrationAlgorithm, TestBoundarySettingAlgorithm, and TestCalibrationAlgorithm.

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

CDC dE/dx Injection time algorithm.

Implements CalibrationAlgorithm.

Definition at line 49 of file CDCDedxInjectTimeAlgorithm.cc.

50{
51
53
54 //existing inject time payload for merging
55 if (!m_DBInjectTime.isValid())
56 B2FATAL("There is no valid payload for Injection time");
57
58 // Get data objects
59 auto ttree = getObjectPtr<TTree>("tree");
60 if (!ttree) return c_NotEnoughData;
61
62 double dedx = 0.0, injtime = 0.0, injring = 1.0, costh, mom;
63 int nhits;
64 ttree->SetBranchAddress("dedx", &dedx);
65 ttree->SetBranchAddress("injtime", &injtime);
66 ttree->SetBranchAddress("injring", &injring);
67 ttree->SetBranchAddress("costh", &costh);
68 ttree->SetBranchAddress("p", &mom);
69 ttree->SetBranchAddress("nhits", &nhits);
70
71 //way to define time bins/edges only once
72 if (m_countR == 0) {
73 defineTimeBins(); //returns m_vtlocaledges
74 m_tbins = m_vtlocaledges.size() - 1;
76 m_countR++;
77 }
78
79 TH1D* htimes = new TH1D(Form("htimes_%s", m_suffix.data()), "", m_tbins, m_tedges);
80
81 //time bins are changeable from out so vector is used
82 std::array<std::vector<TH1D*>, numdedx::nrings> hdedx, htime, hchi, hdedx_corr;
83 defineHisto(hdedx, "dedx");
84 defineHisto(hdedx_corr, "dedx_corr");
85 defineHisto(htime, "timeinj");
86 defineHisto(hchi, "chi");
87
88 const double tzedges[4] = {0, 2.0e3, 0.1e6, 20e6};
89 std::array<std::array<TH1D*, 3>, numdedx::nrings> hztime;
90 defineTimeHisto(hztime);
91
92 //fill histograms
93 for (int i = 0; i < ttree->GetEntries(); ++i) {
94
95 ttree->GetEvent(i);
96 if (dedx <= 0 || injtime < 0 || injring < 0) continue;
97
98 //add larger times to the last bin
99 if (injtime > m_tedges[m_tbins]) injtime = m_tedges[m_tbins] - 10.0;
100
101 //injection ring
102 int wr = 0;
103 if (injring > 0.5) wr = 1;
104
105 //injection time bin
106 unsigned int tb = htimes->GetXaxis()->FindBin(injtime);
107 if (tb > m_tbins)tb = m_tbins; //overflow
108 tb = tb - 1;
109
110 htimes->Fill(injtime);
111 if (injtime < tzedges[1]) hztime[wr][0]->Fill(injtime);
112 else if (injtime < tzedges[2]) hztime[wr][1]->Fill(injtime);
113 else hztime[wr][2]->Fill(injtime);
114
115 hdedx[wr][tb]->Fill(dedx);
116 htime[wr][tb]->Fill(injtime);
117 }
118
119 //keep merging runs to achieve enough stats
120 m_isminStat = false;
121 checkStatistics(hdedx);
122 if (m_isminStat) {
123 deleteHisto(htime);
124 deleteHisto(hdedx);
125 deleteHisto(hdedx_corr);
126 deleteHisto(hchi);
127 deleteTimeHisto(hztime);
128 delete htimes;
129 return c_NotEnoughData;
130 }
131
132 //clear vector of existing constants
133 std::map<int, std::vector<double>> vmeans, vresos, vtimes;
134
135 // get time vector
136 for (unsigned int ir = 0; ir < c_rings; ir++) {
137 for (unsigned int it = 0; it < m_tbins; it++) {
138 double avgtime = htime[ir][it]->GetMean();
139 double avgtimeerr = htime[ir][it]->GetMeanError();
140 vtimes[ir * 2].push_back(avgtime);
141 vtimes[ir * 2 + 1].push_back(avgtimeerr);
142 }
143 }
144
145 //Fit dedx to get mean and resolution
146 getMeanReso(hdedx, vmeans, vresos);
147
148 //Bin-bias correction to mean
149 std::map<int, std::vector<double>> vmeanscorr;
150 correctBinBias(vmeanscorr, vmeans, vtimes, htimes);
151
152 //scale the mean and merge with old constants
153 std::array<double, numdedx::nrings> scale;
154 std::map<int, std::vector<double>> vmeanscal;
155 createPayload(scale, vmeanscorr, vmeanscal, "mean");
156
157 //................................................
158 // Do the calibration for resolution
159 //................................................
160 CDCDedxMeanPred mbg;
161 CDCDedxSigmaPred sbg;
162 mbg.setParameters();
163 sbg.setParameters();
164
165 //fill histograms for the resolution
166 for (int i = 0; i < ttree->GetEntries(); ++i) {
167
168 ttree->GetEvent(i);
169 if (dedx <= 0 || injtime < 0 || injring < 0) continue;
170
171 double corrcetion = getCorrection(injring, injtime, vmeanscal);
172 double old_cor = m_DBInjectTime->getCorrection("mean", injring, injtime);
173
174 dedx = (dedx * old_cor) / corrcetion;
175 //add larger times to the last bin
176 if (injtime > m_tedges[m_tbins]) injtime = m_tedges[m_tbins] - 10.0;
177
178 //injection ring
179 int wr = 0;
180 if (injring > 0.5) wr = 1;
181
182 //injection time bin
183 unsigned int tb = htimes->GetXaxis()->FindBin(injtime);
184 if (tb > m_tbins)tb = m_tbins; //overflow
185 tb = tb - 1;
186
187 double predmean = mbg.getMean(mom / Const::electron.getMass());
188 double predsigma = sbg.nhitPrediction(nhits) * sbg.ionzPrediction(dedx) * sbg.cosPrediction(costh);
189
190 double chi = (dedx - predmean) / predsigma;
191 hdedx_corr[wr][tb]->Fill(dedx);
192 hchi[wr][tb]->Fill(chi);
193 }
194
195 // fit chi to get mean and resolution
196 std::map<int, std::vector<double>> vmeans_chi, vresos_chi;
197 getMeanReso(hchi, vmeans_chi, vresos_chi);
198
199 //bin-bias correction to the resolution
200 std::map<int, std::vector<double>> vresoscorr;
201 correctBinBias(vresoscorr, vresos_chi, vtimes, htimes);
202
203 // scale the resolution
204 std::map<int, std::vector<double>> vresoscal;
205 std::array<double, numdedx::nrings> scale_reso;
206 createPayload(scale_reso, vresoscorr, vresoscal, "reso");
207
208 //Fit the corrected mean to check for consistency
209 std::map<int, std::vector<double>> vmeans_corr, vresos_corr;
210 getMeanReso(hdedx_corr, vmeans_corr, vresos_corr);
211
212 //................................................
213 //preparing final payload
214 //................................................
215 m_vinjPayload.clear();
216 m_vinjPayload.reserve(6);
217 for (int ir = 0; ir < 2; ir++) {
218 m_vinjPayload.push_back(m_vtlocaledges);
219 m_vinjPayload.push_back(vmeanscal[ir * 2]);
220 m_vinjPayload.push_back(vresoscal[ir * 2]);
221 }
222
223 if (m_ismakePlots) {
224
225 //0 plot event track statistics
227
228 //1 plot injection time
229 plotInjectionTime(hztime);
230
231 //2. Draw dedxfits
232 plotBinLevelDist(hdedx, "dedxfits");
233
234 //3. Draw chifits
235 plotBinLevelDist(hchi, "chifits");
236
237 //4. Draw timedist
238 plotBinLevelDist(htime, "timedist");
239
240 //5. plot relative const., bias-bias corrected for dedx
241 plotRelConstants(vmeans, vresos, vmeanscorr, "dedx");
242
243 //6. plot relative const., bias-bias corrected for chi
244 plotRelConstants(vmeans_chi, vresos_chi, vresoscorr, "chi");
245
246 //7. plot mean and resolution of corrected dedx to check for consistency
247 plotRelConstants(vmeans_corr, vresos_corr, vresoscorr, "dedx_corr");
248
249 //8. plot time statistics dist
250 plotTimeStat(htime);
251
252 //9. plot final merged const. and comparison to old
253 plotFinalConstants(vmeanscal, vresoscal, scale, scale_reso);
254 }
255
256 //saving payloads;
257 CDCDedxInjectionTime* gains = new CDCDedxInjectionTime(m_vinjPayload);
258 saveCalibration(gains, "CDCDedxInjectionTime");
259 B2INFO("dE/dx Injection time calibration done");
260
261 //delete all histograms
262 deleteHisto(htime);
263 deleteHisto(hdedx);
264 deleteHisto(hdedx_corr);
265 deleteHisto(hchi);
266 deleteTimeHisto(hztime);
267 delete htimes;
268
269 B2INFO("Saving calibration for: " << m_suffix << "");
270 return c_OK;
271}
void plotBinLevelDist(std::array< std::vector< TH1D * >, numdedx::nrings > &hvar, std::string var)
function to draw dedx, chi and time dist.
std::vector< double > m_vtlocaledges
internal time vector
void correctBinBias(std::map< int, std::vector< double > > &varcorr, std::map< int, std::vector< double > > &var, std::map< int, std::vector< double > > &time, TH1D *&htimes)
function to correct dedx mean/reso and return corrected vector map
void defineHisto(std::array< std::vector< TH1D * >, numdedx::nrings > &htemp, std::string var)
function to define histograms for dedx and time dist.
double getCorrection(unsigned int ring, unsigned int time, std::map< int, std::vector< double > > &vmeans)
function to get the correction factor of mean
void getExpRunInfo()
function to get exp/run information (payload object, plotting)
void plotFinalConstants(std::map< int, std::vector< double > > &vmeans, std::map< int, std::vector< double > > &vresos, std::array< double, numdedx::nrings > &scale, std::array< double, numdedx::nrings > &scale_reso)
function to final constant from merging or abs fits
double * m_tedges
internal time array (copy of vtlocaledges)
static const int c_rings
injection ring constants
void createPayload(std::array< double, numdedx::nrings > &scale, std::map< int, std::vector< double > > &vmeans, std::map< int, std::vector< double > > &varscal, std::string svar)
function to store payloads after full calibration
void plotInjectionTime(std::array< std::array< TH1D *, 3 >, numdedx::nrings > &hvar)
function to injection time distributions (HER/LER in three bins)
void plotTimeStat(std::array< std::vector< TH1D * >, numdedx::nrings > &htime)
function to draw time stats
void defineTimeBins()
function to set/reset time bins
void plotRelConstants(std::map< int, std::vector< double > > &vmeans, std::map< int, std::vector< double > > &vresos, std::map< int, std::vector< double > > &corr, std::string svar)
function to relative constant from dedx fit mean and chi fit reso
void defineTimeHisto(std::array< std::array< TH1D *, 3 >, numdedx::nrings > &htemp)
function to define injection time bins histograms (monitoring only)
void deleteHisto(std::array< std::vector< TH1D * >, numdedx::nrings > &htemp)
function to delete histograms for dedx and time dist.
void deleteTimeHisto(std::array< std::array< TH1D *, 3 >, numdedx::nrings > &htemp)
function to define injection time bins histograms (monitoring only)
void plotEventStats()
function to draw event/track statistics plots
void checkStatistics(std::array< std::vector< TH1D * >, numdedx::nrings > &hvar)
check statistics for obtaining calibration const.
std::vector< std::vector< double > > m_vinjPayload
vector to store payload values
DBObjPtr< CDCDedxInjectionTime > m_DBInjectTime
Injection time DB object.
void getMeanReso(std::array< std::vector< TH1D * >, numdedx::nrings > &hvar, std::map< int, std::vector< double > > &vmeans, std::map< int, std::vector< double > > &vresos)
function to get mean and reso of histogram
double getMean(double bg)
Return the predicted mean value as a function of beta-gamma (bg)
void setParameters(std::string infile)
set the parameters from file
double ionzPrediction(double dedx)
Return sigma from the ionization parameterization.
double cosPrediction(double cos)
Return sigma from the cos parameterization.
double nhitPrediction(double nhit)
Return sigma from the nhit parameterization.
void setParameters(std::string infile)
set the parameters from file
void saveCalibration(TClonesArray *data, const std::string &name)
Store DBArray payload with given name with default IOV.
@ c_OK
Finished successfully =0 in Python.
@ c_NotEnoughData
Needs more data =2 in Python.
static const ChargedStable electron
electron particle
Definition Const.h:659
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 t...

◆ 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}

◆ checkStatistics()

void checkStatistics ( std::array< std::vector< TH1D * >, numdedx::nrings > & hvar)

check statistics for obtaining calibration const.

Definition at line 421 of file CDCDedxInjectTimeAlgorithm.cc.

422{
423 for (unsigned int ir = 0; ir < c_rings; ir++) {
424 for (unsigned int it = 3; it < m_tbins; it++) {
425 //check statiscs from 1-40ms
426 if (m_tedges[it] < 4e4 && hvar[ir][it]->Integral() < m_thersE) {
427 m_isminStat = true;
428 break;
429 } else continue;
430 }
431 }
432}

◆ clearCalibrationData()

void clearCalibrationData ( )
inlineprotectedinherited

Clear calibration data.

Definition at line 324 of file CalibrationAlgorithm.h.

324{m_data.clearCalibrationData();}

◆ 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}
std::list< Database::DBImportQuery > & getPayloads()
Get constants (in TObjects) for database update from last execution.
static Database & Instance()
Instance of a singleton Database.
Definition Database.cc:41
bool storeData(const std::string &name, TObject *object, const IntervalOfValidity &iov)
Store an object in the database.
Definition Database.cc:140

◆ 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}

◆ correctBinBias()

void correctBinBias ( std::map< int, std::vector< double > > & varcorr,
std::map< int, std::vector< double > > & var,
std::map< int, std::vector< double > > & time,
TH1D *& htimes )

function to correct dedx mean/reso and return corrected vector map

Definition at line 435 of file CDCDedxInjectTimeAlgorithm.cc.

438{
439 //Deep copy OK
440 varcorr = var;
441
442 for (int ir = 0; ir < 2; ir++) {
443
444 for (int ix = varcorr[ir * 2].size(); ix -- > 0;) {
445
446 double var_thisbin = 1.0;
447 var_thisbin = var[ir * 2].at(ix);
448
449 double atime_thisbin = time[ir * 2].at(ix);
450 double ctime_thisbin = htimes->GetBinCenter(ix + 1);
451
452 if (atime_thisbin > 0 && atime_thisbin < 4e4 * 0.99) {
453
454 double var_nextbin = 1.0;
455 var_nextbin = var[ir * 2].at(ix + 1);
456 double var_diff = var_nextbin - var_thisbin;
457
458 double atime_nextbin = time[ir * 2].at(ix + 1);
459 double atime_diff = atime_nextbin - atime_thisbin;
460
461 double slope = (atime_diff > 0) ? var_diff / atime_diff : -1.0;
462
463 //extrapolation after veto only
464 if (var_diff > 0 && slope > 0)varcorr[ir * 2].at(ix) = var_thisbin + (ctime_thisbin - atime_thisbin) * (slope);
465 printf("\t %s ix = %d, center = %0.2f(%0.3f), var = %0.5f(%0.5f) \n", m_sring[ir].data(), ix, ctime_thisbin, atime_thisbin,
466 var_thisbin, varcorr[ir * 2].at(ix));
467 } else {
468 printf("\t %s --> ix = %d, center = %0.2f(%0.3f), var = %0.5f(%0.5f) \n", m_sring[ir].data(), ix, ctime_thisbin, atime_thisbin,
469 var_thisbin, varcorr[ir * 2].at(ix));
470 }
471 }
472 }
473}
std::array< std::string, numdedx::nrings > m_sring
injection ring name

◆ createPayload()

void createPayload ( std::array< double, numdedx::nrings > & scale,
std::map< int, std::vector< double > > & vmeans,
std::map< int, std::vector< double > > & varscal,
std::string svar )

function to store payloads after full calibration

Definition at line 476 of file CDCDedxInjectTimeAlgorithm.cc.

479{
480 varscal = var;
481
482 B2INFO("CDCDedxInjectTimeAlgorithm: normalising constants with plateau");
483 for (unsigned int ir = 0; ir < c_rings; ir++) {
484 //scaling means with time >40ms
485 unsigned int msize = varscal[ir * 2].size();
486 int countsum = 0;
487 scale[ir] = 0;
488 for (unsigned int im = 0; im < msize; im++) {
489 double time = m_vtlocaledges.at(im);
490 double mean = varscal[ir * 2].at(im);
491 if (time > 4e4 && mean > 0) {
492 scale[ir] += mean;
493 countsum++;
494 }
495 }
496 if (countsum > 0 && scale[ir] > 0) {
497 scale[ir] /= countsum;
498 for (unsigned int im = 0; im < msize; im++) {
499 varscal[ir * 2].at(im) /= scale[ir];
500 }
501 }
502 }
503 if (m_isMerge && svar == "mean") {
504 //merge only no change in payload structure
505 bool incomp_bin = false;
506 std::vector<std::vector<double>> oldvectors;
507 if (m_DBInjectTime) oldvectors = m_DBInjectTime->getConstVector();
508 int vsize = oldvectors.size();
509 if (vsize != 6) incomp_bin = true;
510 else {
511 for (int iv = 0; iv < 2; iv++) {
512 if (oldvectors[iv * 3 + 1].size() != varscal[iv * 2].size()) incomp_bin = true;
513 }
514 }
515 if (!incomp_bin) {
516 B2INFO("CDCDedxInjectTimeAlgorithm: started merging relative constants");
517 for (int ir = 0; ir < 2; ir++) {//merging only means
518 unsigned int msize = varscal[ir * 2].size();
519 for (unsigned int im = 0; im < msize; im++) {
520 double relvalue = varscal[ir * 2].at(im);
521 double oldvalue = oldvectors[ir * 3 + 1].at(im);
522 double merged = oldvalue * relvalue;
523 printf("%s: rel %0.03f, old %0.03f, merged %0.03f\n", m_suffix.data(), relvalue, oldvalue, merged);
524 varscal[ir * 2].at(im) *= oldvectors[ir * 3 + 1].at(im) ;
525 }
526 }
527 } else B2ERROR("CDCDedxInjectTimeAlgorithm: found incompatible bins for merging");
528 } else B2INFO("CDCDedxInjectTimeAlgorithm: saving final (abs) calibration");
529}

◆ defineHisto()

void defineHisto ( std::array< std::vector< TH1D * >, numdedx::nrings > & htemp,
std::string var )

function to define histograms for dedx and time dist.

(in time bins)

Definition at line 386 of file CDCDedxInjectTimeAlgorithm.cc.

387{
388 for (unsigned int ir = 0; ir < c_rings; ir++) {
389 htemp[ir].resize(m_tbins);
390 for (unsigned int it = 0; it < m_tbins; it++) {
391 std::string label = getTimeBinLabel(m_tedges[it], it);
392 std::string title = Form("%s(%s), time(%s)", m_suffix.data(), m_sring[ir].data(), label.data());
393 std::string hname = Form("h%s_%s_%s_t%d", var.data(), m_sring[ir].data(), m_suffix.data(), it);
394 if (var == "dedx" or var == "dedx_corr") htemp[ir][it] = new TH1D(hname.data(), "", m_dedxBins, m_dedxMin, m_dedxMax);
395 else if (var == "chi") htemp[ir][it] = new TH1D(hname.data(), "", m_chiBins, m_chiMin, m_chiMax);
396 else htemp[ir][it] = new TH1D(hname.data(), "", 50, m_tedges[it], m_tedges[it + 1]);
397 htemp[ir][it]->SetTitle(Form("%s;%s;entries", title.data(), var.data()));
398 }
399 }
400}
std::string getTimeBinLabel(const double &tedges, const int &it)
function to return time label for histograms labeling

◆ defineTimeBins()

void defineTimeBins ( )

function to set/reset time bins

Definition at line 363 of file CDCDedxInjectTimeAlgorithm.cc.

364{
365 //empty local vector or find a way to execulate this function
366 //only once
367 if (!m_vtlocaledges.empty()) m_vtlocaledges.clear();
368 if (m_vtedges.empty()) {
369 double fixedges[69];
370 for (int ib = 0; ib < 69; ib++) {
371 fixedges[ib] = ib * 0.5 * 1e3;
372 if (ib > 40 && ib <= 60) fixedges[ib] = fixedges[ib - 1] + 1.0 * 1e3;
373 else if (ib > 60 && ib <= 64) fixedges[ib] = fixedges[ib - 1] + 10.0 * 1e3;
374 else if (ib > 64 && ib <= 65) fixedges[ib] = fixedges[ib - 1] + 420.0 * 1e3;
375 else if (ib > 65 && ib <= 66) fixedges[ib] = fixedges[ib - 1] + 500.0 * 1e3;
376 else if (ib > 66) fixedges[ib] = fixedges[ib - 1] + 2e6;
377 m_vtlocaledges.push_back(fixedges[ib]);
378 }
379 } else {
380 for (unsigned int ib = 0; ib < m_vtedges.size(); ib++)
381 m_vtlocaledges.push_back(m_vtedges.at(ib));
382 }
383}
std::vector< double > m_vtedges
external time vector

◆ defineTimeHisto()

void defineTimeHisto ( std::array< std::array< TH1D *, 3 >, numdedx::nrings > & htemp)

function to define injection time bins histograms (monitoring only)

Definition at line 403 of file CDCDedxInjectTimeAlgorithm.cc.

404{
405 const int tzoom = 3;
406 const int nt[tzoom] = {50, 500, 1000};
407 double tzedges[tzoom + 1] = {0, 2.0e3, 0.1e6, 20e6};
408 std::string stname[tzoom] = {"early", "mid", "later"};
409 std::string stlabel[tzoom] = {"zoom <2ms", "early time <= 100ms", "later time >100ms"};
410 for (unsigned int ir = 0; ir < c_rings; ir++) {
411 for (int wt = 0; wt < tzoom; wt++) {
412 std::string title = Form("inject time (%s), %s (%s)", stlabel[wt].data(), m_sring[ir].data(), m_suffix.data());
413 std::string hname = Form("htimezoom_%s_%s_%s", m_sring[ir].data(), stname[wt].data(), m_suffix.data());
414 htemp[ir][wt] = new TH1D(Form("%s", hname.data()), "", nt[wt], tzedges[wt], tzedges[wt + 1]);
415 htemp[ir][wt]->SetTitle(Form("%s;injection time(#mu-sec);entries", title.data()));
416 }
417 }
418}

◆ deleteHisto()

void deleteHisto ( std::array< std::vector< TH1D * >, numdedx::nrings > & htemp)
inline

function to delete histograms for dedx and time dist.

(in time bins)

Definition at line 200 of file CDCDedxInjectTimeAlgorithm.h.

201 {
202 for (unsigned int ir = 0; ir < c_rings; ir++) {
203 for (unsigned int it = 0; it < m_tbins; it++) {
204 delete htemp[ir][it];
205 }
206 }
207 }

◆ deleteTimeHisto()

void deleteTimeHisto ( std::array< std::array< TH1D *, 3 >, numdedx::nrings > & htemp)
inline

function to define injection time bins histograms (monitoring only)

Definition at line 212 of file CDCDedxInjectTimeAlgorithm.h.

213 {
214 const int tzoom = 3;
215 for (unsigned int ir = 0; ir < c_rings; ir++) {
216 for (int wt = 0; wt < tzoom; wt++) {
217 delete htemp[ir][wt];
218 }
219 }
220 }

◆ 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();}

◆ 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}
bool checkPyExpRun(PyObject *pyObj)
Checks that a PyObject can be successfully converted to an ExpRun type.
EResult execute(std::vector< Calibration::ExpRun > runs={}, int iteration=0, IntervalOfValidity iov=IntervalOfValidity())
Runs calibration over vector of runs for a given iteration.
Calibration::ExpRun convertPyExpRun(PyObject *pyObj)
Performs the conversion of PyObject to ExpRun.
ExecutionData m_data
Data specific to a SINGLE execution of the algorithm. Gets reset at the beginning of execution.

◆ 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
161 m_data.setResult(result);
162 return result;
163}
std::vector< Calibration::ExpRun > getRunListFromAllData() const
Get the complete list of runs from inspection of collected data.
std::vector< std::string > m_inputFileNames
List of input files to the Algorithm, will initially be user defined but then gets the wildcards expa...
EResult
The result of calibration.
@ c_Undefined
Not yet known (before execution) =4 in Python.
virtual EResult calibrate()=0
Run algo on data - pure virtual: needs to be implemented.
std::string getGranularity() const
Get the granularity of collected data.

◆ 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}
std::string getPrefix() const
Get the prefix used for getting calibration data.
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...
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();
562 return m_boundaries;
563}
std::vector< Calibration::ExpRun > m_boundaries
When using the boundaries functionality from isBoundaryRequired, this is used to store the boundaries...
virtual void boundaryFindingTearDown()
Put your algorithm back into a state ready for normal execution if you need to.
virtual void boundaryFindingSetup(std::vector< Calibration::ExpRun >, int)
If you need to make some changes to your algorithm class before 'findPayloadBoundaries' is run,...
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...

◆ fitGaussianWRange()

void fitGaussianWRange ( TH1D *& temphist,
fstatus & status )

function to perform gauss fit for input histogram

Definition at line 307 of file CDCDedxInjectTimeAlgorithm.cc.

308{
309 double histmean = temphist->GetMean();
310 double histrms = temphist->GetRMS();
311 temphist->GetXaxis()->SetRangeUser(histmean - 5.0 * histrms, histmean + 5.0 * histrms);
312
313 int fs = temphist->Fit("gaus", "Q0");
314 if (fs != 0) {
315 B2INFO(Form("\tFit (round 1) for hist (%s) failed (status = %d)", temphist->GetName(), fs));
316 status = fitFailed;
317 return;
318 } else {
319 double mean = temphist->GetFunction("gaus")->GetParameter(1);
320 double width = temphist->GetFunction("gaus")->GetParameter(2);
321 temphist->GetXaxis()->SetRangeUser(mean - 5.0 * width, mean + 5.0 * width);
322 fs = temphist->Fit("gaus", "QR", "", mean - m_sigmaR * width, mean + m_sigmaR * width);
323 if (fs != 0) {
324 B2INFO(Form("\tFit (round 2) for hist (%s) failed (status = %d)", temphist->GetName(), fs));
325 status = fitFailed;
326 return;
327 } else {
328 temphist->GetXaxis()->SetRangeUser(mean - 5.0 * width, mean + 5.0 * width);
329 B2INFO(Form("\tFit for hist (%s) successful (status = %d)", temphist->GetName(), fs));
330 status = fitOK;
331 }
332 }
333}

◆ 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;}

◆ 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();}

◆ getCorrection()

double getCorrection ( unsigned int ring,
unsigned int time,
std::map< int, std::vector< double > > & vmeans )

function to get the correction factor of mean

Definition at line 847 of file CDCDedxInjectTimeAlgorithm.cc.

849{
850
851 unsigned int iv = ring * 2;
852
853 unsigned int sizet = m_vtlocaledges.size(); //time
854
855 std::vector<unsigned int> tedges(sizet); //time edges array
856 std::copy(m_vtlocaledges.begin(), m_vtlocaledges.end(), tedges.begin());
857
858 if (time >= 5e6) time = 5e6 - 10;
859 unsigned int it = m_DBInjectTime->getTimeBin(tedges, time);
860
861 double center = 0.5 * (m_vtlocaledges.at(it) + m_vtlocaledges.at(it + 1));
862
863 //no corr before veto bin (usually one or two starting bin)
864 //intrapolation for entire range except
865 //--extrapolation (for first half and last half of intended bin)
866 int thisbin = it, nextbin = it;
867 if (center != time && it > 0) {
868
869 if (time < center) {
870 thisbin = it - 1;
871 } else {
872 if (it < sizet - 2)nextbin = it + 1;
873 else thisbin = it - 1;
874 }
875
876 if (it <= 2) {
877 double diff = vmeans[iv].at(2) - vmeans[iv].at(1) ;
878 if (diff < -0.015) { //difference above 1.0%
879 thisbin = it;
880 if (it == 1) nextbin = it;
881 else nextbin = it + 1;
882 } else {
883 if (it == 1) {
884 thisbin = it;
885 nextbin = it + 1;
886 }
887 }
888 }
889 }
890
891 double thisdedx = vmeans[iv].at(thisbin);
892 double nextdedx = vmeans[iv].at(nextbin);
893
894 double thistime = 0.5 * (m_vtlocaledges.at(thisbin) + m_vtlocaledges.at(thisbin + 1));
895 double nexttime = 0.5 * (m_vtlocaledges.at(nextbin) + m_vtlocaledges.at(nextbin + 1));
896
897 double newdedx = vmeans[iv].at(it);
898 if (thisbin != nextbin)
899 newdedx = thisdedx + ((nextdedx - thisdedx) / (nexttime - thistime)) * (time - thistime);
900
901 return newdedx;
902}

◆ 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;}

◆ getExpRunInfo()

void getExpRunInfo ( )

function to get exp/run information (payload object, plotting)

Definition at line 336 of file CDCDedxInjectTimeAlgorithm.cc.

337{
338 int cruns = 0;
339 for (auto expRun : getRunList()) {
340 if (cruns == 0)B2INFO("CDCDedxInjectTimeAlgorithm: start exp " << expRun.first << " and run " << expRun.second << "");
341 cruns++;
342 }
343
344 const auto erStart = getRunList()[0];
345 int estart = erStart.first;
346 int rstart = erStart.second;
347
348 const auto erEnd = getRunList()[cruns - 1];
349 int rend = erEnd.second;
350
351 updateDBObjPtrs(1, erStart.second, erStart.first);
352
353 if (m_isminStat) {
354 m_suffix = Form("e%dr%dto%d_nruns%d", estart, rstart, rend, cruns);
355 B2INFO("\t+ run = " << rend << ", m_suffix = " << m_suffix << "");
356 } else {
357 m_suffix = Form("e%dr%d", estart, rstart);
358 B2INFO("tool run = " << estart << ", exp = " << estart << ", m_suffix = " << m_suffix << "");
359 }
360}
void updateDBObjPtrs(const unsigned int event, const int run, const int experiment)
Updates any DBObjPtrs by calling update(event) for DBStore.
const std::vector< Calibration::ExpRun > & getRunList() const
Get the list of runs for which calibration is called.

◆ 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}
std::string getExpRunString(Calibration::ExpRun &expRun) const
Gets the "exp.run" string repr. of (exp,run)

◆ getGranularity()

std::string getGranularity ( ) const
inlineinherited

Get the granularity of collected data.

Definition at line 188 of file CalibrationAlgorithm.h.

188{return m_granularityOfData;};

◆ 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}
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;}

◆ getInputJsonValue()

template<class T>
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{
328}
RunRange getRunRangeFromAllData() const
Get the complete RunRange from inspection of collected data.
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(); }

◆ getMeanReso()

void getMeanReso ( std::array< std::vector< TH1D * >, numdedx::nrings > & hvar,
std::map< int, std::vector< double > > & vmeans,
std::map< int, std::vector< double > > & vresos )

function to get mean and reso of histogram

Definition at line 274 of file CDCDedxInjectTimeAlgorithm.cc.

276{
277 for (unsigned int ir = 0; ir < c_rings; ir++) {
278
279 for (unsigned int it = 0; it < m_tbins; it++) {
280 double mean = 1.00, meanerr = 0.0;
281 double reso = 1.00, resoerr = 0.0;
282 if (hvar[ir][it]->Integral() > 250) {
283 fstatus status;
284 fitGaussianWRange(hvar[ir][it], status);
285 if (status != fitOK) {
286 mean = hvar[ir][it]->GetMean();
287 hvar[ir][it]->SetTitle(Form("%s, (%d)", hvar[ir][it]->GetTitle(), status));
288 } else {
289 mean = hvar[ir][it]->GetFunction("gaus")->GetParameter(1);
290 meanerr = hvar[ir][it]->GetFunction("gaus")->GetParError(1);
291 reso = hvar[ir][it]->GetFunction("gaus")->GetParameter(2);
292 resoerr = hvar[ir][it]->GetFunction("gaus")->GetParError(2);
293 std::string title = Form("#mu_{fit}: %0.03f, #sigma_{fit}: %0.03f", mean, reso);
294 hvar[ir][it]->SetTitle(Form("%s, %s", hvar[ir][it]->GetTitle(), title.data()));
295 }
296 }
297
298 vmeans[ir * 2].push_back(mean);
299 vresos[ir * 2].push_back(reso);
300 vmeans[ir * 2 + 1].push_back(meanerr);
301 vresos[ir * 2 + 1].push_back(resoerr);
302 }
303 }
304}
void fitGaussianWRange(TH1D *&temphist, fstatus &status)
function to perform gauss fit for input histogram

◆ getObjectPtr()

template<class T>
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 }

◆ getOutputJsonValue()

template<class T>
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();}

◆ 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();}

◆ 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;}

◆ 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}
virtual void merge(const RunRange *other)
Implementation of merging - other is added to the set (union)
Definition RunRange.h:52

◆ getTimeBinLabel()

std::string getTimeBinLabel ( const double & tedges,
const int & it )
inline

function to return time label for histograms labeling

Definition at line 188 of file CDCDedxInjectTimeAlgorithm.h.

189 {
190 std::string label = "";
191 if (tedges < 2e4)label = Form("%0.01f-%0.01fK", m_tedges[it] / 1e3, m_tedges[it + 1] / 1e3);
192 else if (tedges < 1e5)label = Form("%0.0f-%0.0fK", m_tedges[it] / 1e3, m_tedges[it + 1] / 1e3);
193 else label = Form("%0.01f-%0.01fM", m_tedges[it] / 1e6, m_tedges[it + 1] / 1e6);
194 return label;
195 }

◆ 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 PXDAnalyticGainCalibrationAlgorithm, PXDValidationAlgorithm, SVD3SampleCoGTimeCalibrationAlgorithm, SVD3SampleELSTimeCalibrationAlgorithm, SVDCoGTimeCalibrationAlgorithm, TestBoundarySettingAlgorithm, and TestCalibrationAlgorithm.

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}
nlohmann::json m_jsonExecutionInput
Optional input JSON object used to make decisions about how to execute the algorithm code.

◆ plotBinLevelDist()

void plotBinLevelDist ( std::array< std::vector< TH1D * >, numdedx::nrings > & hvar,
std::string var )

function to draw dedx, chi and time dist.

Definition at line 532 of file CDCDedxInjectTimeAlgorithm.cc.

533{
534 TCanvas cfit("cfit", "cfit", 1000, 500);
535 cfit.Divide(2, 1);
536 std::stringstream psname_fit;
537 psname_fit << Form("%s_%s_%s.pdf[", m_prefix.data(), var.data(), m_suffix.data());
538 cfit.Print(psname_fit.str().c_str());
539 psname_fit.str("");
540 psname_fit << Form("%s_%s_%s.pdf", m_prefix.data(), var.data(), m_suffix.data());
541 for (unsigned int it = 0; it < m_tbins; it++) {
542 for (unsigned int ir = 0; ir < c_rings; ir++) {
543 cfit.cd(ir + 1);
544 hvar[ir][it]->SetFillColorAlpha(ir + 5, 0.25);
545 hvar[ir][it]->Draw();
546 }
547 cfit.Print(psname_fit.str().c_str());
548 }
549 psname_fit.str("");
550 psname_fit << Form("%s_%s_%s.pdf]", m_prefix.data(), var.data(), m_suffix.data());
551 cfit.Print(psname_fit.str().c_str());
552}

◆ plotEventStats()

void plotEventStats ( )

function to draw event/track statistics plots

Definition at line 555 of file CDCDedxInjectTimeAlgorithm.cc.

556{
557 // draw event and track statistics
558 TCanvas cestat("cestat", "cestat", 1000, 500);
559 cestat.SetBatch(kTRUE);
560 cestat.Divide(2, 1);
561
562 cestat.cd(1);
563 auto hestats = getObjectPtr<TH1I>("hestats");
564 if (hestats) {
565 hestats->SetName(Form("hestats_%s", m_suffix.data()));
566 hestats->SetStats(0);
567 hestats->Draw("hist text");
568 }
569 cestat.cd(2);
570 auto htstats = getObjectPtr<TH1I>("htstats");
571 if (htstats) {
572 htstats->SetName(Form("htstats_%s", m_suffix.data()));
573 htstats->SetStats(0);
574 htstats->Draw("hist text");
575 }
576 cestat.Print(Form("%s_eventstat_%s.pdf", m_prefix.data(), m_suffix.data()));
577}

◆ plotFinalConstants()

void plotFinalConstants ( std::map< int, std::vector< double > > & vmeans,
std::map< int, std::vector< double > > & vresos,
std::array< double, numdedx::nrings > & scale,
std::array< double, numdedx::nrings > & scale_reso )

function to final constant from merging or abs fits

Definition at line 745 of file CDCDedxInjectTimeAlgorithm.cc.

748{
749
750 std::vector<std::vector<double>> oldvectors;
751 if (m_DBInjectTime)oldvectors = m_DBInjectTime->getConstVector();
752
753 const int c_type = 2; //old and new
754 std::string sname[c_rings] = {"mean", "reso"};
755 std::string stype[c_type] = {"new", "old"};
756 const int lcolors[c_rings] = {2, 4};
757 const int lmarker[c_type] = {20, 24}; //+2 for different rings
758
759 TH1D* hmean[c_rings][c_type], *hreso[c_rings][c_type];
760
761 TCanvas* cconst[c_rings];
762 for (int ic = 0; ic < 2; ic++) {
763 cconst[ic] = new TCanvas(Form("c%sconst", sname[ic].data()), "", 900, 500);
764 cconst[ic]->SetGridy(1);
765 }
766
767 TLegend* mleg = new TLegend(0.50, 0.54, 0.80, 0.75, NULL, "brNDC");
768 mleg->SetBorderSize(0);
769 mleg->SetFillStyle(0);
770
771 TLegend* rleg = new TLegend(0.50, 0.54, 0.80, 0.75, NULL, "brNDC");
772 rleg->SetBorderSize(0);
773 rleg->SetFillStyle(0);
774
775 for (unsigned int ip = 0; ip < c_type; ip++) {
776
777 for (unsigned int ir = 0; ir < c_rings; ir++) {
778
779 std::string hname = Form("hfmean_%s_%s_%s", m_sring[ir].data(), stype[ip].data(), m_suffix.data());
780 hmean[ir][ip] = new TH1D(hname.data(), "", m_tbins, 0, m_tbins);
781 std::string title = Form("#mu(dedx), final-mean-compare (%s)", m_suffix.data());
782 hmean[ir][ip]->SetTitle(Form("%s;injection time(#mu-second);#mu (dedx-fit)", title.data()));
783
784 hname = Form("hfreso_%s_%s_%s", m_sring[ir].data(), stype[ip].data(), m_suffix.data());
785 hreso[ir][ip] = new TH1D(hname.data(), "", m_tbins, 0, m_tbins);
786 title = Form("#sigma(#chi), final-reso-compare (%s)", m_suffix.data());
787 hreso[ir][ip]->SetTitle(Form("%s;injection time(#mu-second);#sigma (#chi-fit)", title.data()));
788
789 for (unsigned int it = 0; it < m_tbins; it++) {
790
791 std::string label = getTimeBinLabel(m_tedges[it], it);
792 double mean = 0.0, reso = 0.0;
793 if (ip == 0) {
794 mean = m_vinjPayload[ir * 3 + 1].at(it);
795 //reso is reso/mu (reso is relative so mean needs to be relative)
796 reso = m_vinjPayload[ir * 3 + 2].at(it);
797
798 } else {
799 mean = oldvectors[ir * 3 + 1].at(it);
800 reso = oldvectors[ir * 3 + 2].at(it);
801
802 }
803
804 //old payloads
805 hmean[ir][ip]->SetBinContent(it + 1, mean);
806 hmean[ir][ip]->SetBinError(it + 1, vmeans[ir * 2 + 1].at(it));
807 hmean[ir][ip]->GetXaxis()->SetBinLabel(it + 1, label.data());
808
809 hreso[ir][ip]->SetBinContent(it + 1, reso);
810 hreso[ir][ip]->SetBinError(it + 1, vresos[ir * 2 + 1].at(it));
811 hreso[ir][ip]->GetXaxis()->SetBinLabel(it + 1, label.data());
812 }
813
814 cconst[0]->cd();
815 if (ip == 1)mleg->AddEntry(hmean[ir][ip], Form("%s, %s", m_sring[ir].data(), stype[ip].data()), "lep");
816 else mleg->AddEntry(hmean[ir][ip], Form("%s, %s (scaled by %0.03f)", m_sring[ir].data(), stype[ip].data(), scale[ir]), "lep");
817 setHistStyle(hmean[ir][ip], lcolors[ir], lmarker[ip] + ir * 2, 0.60, 1.05);
818 if (ir == 0 && ip == 0)hmean[ir][ip]->Draw("");
819 else hmean[ir][ip]->Draw("same");
820 if (ir == 1 && ip == 1)mleg->Draw("same");
821
822 cconst[1]->cd();
823 if (ip == 1)rleg->AddEntry(hreso[ir][ip], Form("%s, %s", m_sring[ir].data(), stype[ip].data()), "lep");
824 else rleg->AddEntry(hreso[ir][ip], Form("%s, %s (scaled by %0.03f)", m_sring[ir].data(), stype[ip].data(), scale_reso[ir]), "lep");
825 setHistStyle(hreso[ir][ip], lcolors[ir], lmarker[ip] + ir * 2, 0.6, 1.9);
826 if (ir == 0 && ip == 0)hreso[ir][ip]->Draw("");
827 else hreso[ir][ip]->Draw("same");
828 if (ir == 1 && ip == 1)rleg->Draw("same");
829 }
830 }
831
832 for (int ic = 0; ic < 2; ic++) {
833 cconst[ic]->SaveAs(Form("%s_finalconst_%s_%s.pdf", m_prefix.data(), sname[ic].data(), m_suffix.data()));
834 cconst[ic]->SaveAs(Form("%s_finalconst_%s_%s.root", m_prefix.data(), sname[ic].data(), m_suffix.data()));
835 delete cconst[ic];
836 }
837
838 for (unsigned int ir = 0; ir < c_rings; ir++) {
839 for (unsigned int ip = 0; ip < c_type; ip++) {
840 delete hmean[ir][ip];
841 delete hreso[ir][ip];
842 }
843 }
844}
void setHistStyle(TH1D *&htemp, const int ic, const int is, const double min, const double max)
function to set histogram cosmetics

◆ plotInjectionTime()

void plotInjectionTime ( std::array< std::array< TH1D *, 3 >, numdedx::nrings > & hvar)

function to injection time distributions (HER/LER in three bins)

Definition at line 580 of file CDCDedxInjectTimeAlgorithm.cc.

581{
582 TCanvas ctzoom("ctzoom", "ctzoom", 1500, 450);
583 ctzoom.SetBatch(kTRUE);
584 ctzoom.Divide(3, 1);
585 for (int wt = 0; wt < 3; wt++) {
586 ctzoom.cd(wt + 1);
587 if (wt == 2) gPad->SetLogy();
588 for (unsigned int ir = 0; ir < c_rings; ir++) {
589 hvar[ir][wt]->SetStats(0);
590 hvar[ir][wt]->SetFillColorAlpha(5 + ir, 0.20);
591 if (ir == 0) {
592 double max1 = hvar[ir][wt]->GetMaximum();
593 double max2 = hvar[c_rings - 1][wt]->GetMaximum();
594 if (max2 > max1) hvar[ir][wt]->SetMaximum(max2 * 1.05);
595 hvar[ir][wt]->Draw("");
596 } else hvar[ir][wt]->Draw("same");
597 }
598 }
599 ctzoom.Print(Form("%s_timezoom_%s.pdf]", m_prefix.data(), m_suffix.data()));
600}

◆ plotRelConstants()

void plotRelConstants ( std::map< int, std::vector< double > > & vmeans,
std::map< int, std::vector< double > > & vresos,
std::map< int, std::vector< double > > & corr,
std::string svar )

function to relative constant from dedx fit mean and chi fit reso

Definition at line 603 of file CDCDedxInjectTimeAlgorithm.cc.

605{
606 std::string sname[3] = {"mean", "reso"};
607 const int lcolors[c_rings] = {2, 4};
608
609 TH1D* hmean[c_rings], *hcorr[c_rings];
610 TH1D* hreso[c_rings];
611
612 TCanvas* cconst[2];
613 for (int ic = 0; ic < 2; ic++) {
614 cconst[ic] = new TCanvas(Form("c%sconst", sname[ic].data()), "", 900, 500);
615 cconst[ic]->SetGridy(1);
616 }
617
618 TLegend* mleg = new TLegend(0.50, 0.54, 0.80, 0.75, NULL, "brNDC");
619 mleg->SetBorderSize(0);
620 mleg->SetFillStyle(0);
621
622 for (unsigned int ir = 0; ir < c_rings; ir++) {
623
624 std::string mtitle = Form("#mu(dedx), relative const. compare, (%s)", m_suffix.data());
625 hmean[ir] = new TH1D(Form("hmean_%s_%s", m_suffix.data(), m_sring[ir].data()), "", m_tbins, 0, m_tbins);
626
627 std::string rtitle = Form("#sigma(#chi), relative const. compare, (%s)", m_suffix.data());
628 hreso[ir] = new TH1D(Form("hreso_%s_%s", m_suffix.data(), m_sring[ir].data()), "", m_tbins, 0, m_tbins);
629
630 hcorr[ir] = new TH1D(Form("hcorr_%s_%s", m_suffix.data(), m_sring[ir].data()), "", m_tbins, 0, m_tbins);
631 if (svar == "chi") {
632 hmean[ir]->SetTitle(Form("%s;injection time(#mu-second);#mu (#chi-fit)", rtitle.data()));
633 hreso[ir]->SetTitle(Form("%s;injection time(#mu-second);#sigma (#chi-fit)", rtitle.data()));
634 hcorr[ir]->SetTitle(Form("%s;injection time(#mu-second);#sigma (#chi-fit bin-bais-corr)", rtitle.data()));
635
636 } else {
637 hmean[ir]->SetTitle(Form("%s;injection time(#mu-second);#mu (dedx-fit)", mtitle.data()));
638 hreso[ir]->SetTitle(Form("%s;injection time(#mu-second);#sigma (dedx-fit)", mtitle.data()));
639 hcorr[ir]->SetTitle(Form("%s;injection time(#mu-second);#mu (dedx-fit, bin-bais-corr)", mtitle.data()));
640 }
641
642
643 for (unsigned int it = 0; it < m_tbins; it++) {
644
645 std::string label = getTimeBinLabel(m_tedges[it], it);
646
647 hmean[ir]->SetBinContent(it + 1, vmeans[ir * 2].at(it));
648 hmean[ir]->SetBinError(it + 1, vmeans[ir * 2 + 1].at(it));
649 hmean[ir]->GetXaxis()->SetBinLabel(it + 1, label.data());
650
651 hreso[ir]->SetBinContent(it + 1, vresos[ir * 2].at(it));
652 hreso[ir]->SetBinError(it + 1, vresos[ir * 2 + 1].at(it));
653 hreso[ir]->GetXaxis()->SetBinLabel(it + 1, label.data());
654
655 hcorr[ir]->SetBinContent(it + 1, corr[ir * 2].at(it));
656 hcorr[ir]->SetBinError(it + 1, corr[ir * 2 + 1].at(it));
657 hcorr[ir]->GetXaxis()->SetBinLabel(it + 1, label.data());
658 }
659
660 mleg->AddEntry(hmean[ir], Form("%s", m_sring[ir].data()), "lep");
661 cconst[0]->cd();
662 if (svar == "chi") setHistStyle(hmean[ir], lcolors[ir], ir + 24, -0.60, 0.60);
663 else if (svar == "dedx") setHistStyle(hmean[ir], lcolors[ir], ir + 24, 0.60, 1.10);
664 else setHistStyle(hmean[ir], lcolors[ir], ir + 24, 0.9, 1.10);
665
666 if (ir == 0)hmean[ir]->Draw("");
667 else hmean[ir]->Draw("same");
668 if (svar == "dedx") {
669 mleg->AddEntry(hcorr[ir], Form("%s (bin-bias-corr)", m_sring[ir].data()), "lep");
670 setHistStyle(hcorr[ir], lcolors[ir], ir + 20, 0.60, 1.10);
671 hcorr[ir]->Draw("same");
672 }
673 if (ir == 1)mleg->Draw("same");
674
675 cconst[1]->cd();
676 if (svar == "chi") setHistStyle(hreso[ir], lcolors[ir], ir + 24, 0.5, 1.50);
677 else setHistStyle(hreso[ir], lcolors[ir], ir + 24, 0.0, 0.15);
678 if (ir == 0)hreso[ir]->Draw("");
679 else hreso[ir]->Draw("same");
680 if (svar == "chi") {
681 mleg->AddEntry(hcorr[ir], Form("%s (bin-bias-corr)", m_sring[ir].data()), "lep");
682 setHistStyle(hcorr[ir], lcolors[ir], ir + 20, 0.5, 1.50);
683 hcorr[ir]->Draw("same");
684 }
685 if (ir == 1)mleg->Draw("same");
686 }
687
688 for (int ic = 0; ic < 2; ic++) {
689 cconst[ic]->SaveAs(Form("%s_relconst_%s_%s_%s.pdf", m_prefix.data(), sname[ic].data(), svar.data(), m_suffix.data()));
690 cconst[ic]->SaveAs(Form("%s_relconst_%s_%s_%s.root", m_prefix.data(), sname[ic].data(), svar.data(), m_suffix.data()));
691 delete cconst[ic];
692 }
693 for (int ic = 0; ic < 2; ic++) {
694
695 delete hmean[ic];
696 delete hreso[ic];
697 delete hcorr[ic];
698 }
699}

◆ plotTimeStat()

void plotTimeStat ( std::array< std::vector< TH1D * >, numdedx::nrings > & htime)

function to draw time stats

Definition at line 702 of file CDCDedxInjectTimeAlgorithm.cc.

703{
704 const int lcolors[c_rings] = {2, 4};
705
706 TH1D* htimestat[c_rings];
707
708 TCanvas* cconst = new TCanvas("ctimestatconst", "", 900, 500);
709 cconst->SetGridy(1);
710
711 TLegend* rleg = new TLegend(0.40, 0.60, 0.80, 0.72, NULL, "brNDC");
712 rleg->SetBorderSize(0);
713 rleg->SetFillStyle(0);
714
715 for (unsigned int ir = 0; ir < c_rings; ir++) {
716
717 std::string title = Form("injection time, her-ler comparison, (%s)", m_suffix.data());
718 htimestat[ir] = new TH1D(Form("htimestat_%s_%s", m_suffix.data(), m_sring[ir].data()), "", m_tbins, 0, m_tbins);
719 htimestat[ir]->SetTitle(Form("%s;injection time(#mu-second);norm. entries", title.data()));
720
721 for (unsigned int it = 0; it < m_tbins; it++) {
722 std::string label = getTimeBinLabel(m_tedges[it], it);
723 htimestat[ir]->SetBinContent(it + 1, htime[ir][it]->Integral());
724 htimestat[ir]->SetBinError(it + 1, 0);
725 htimestat[ir]->GetXaxis()->SetBinLabel(it + 1, label.data());
726 }
727
728 cconst->cd();
729 double norm = htimestat[ir]->GetMaximum();
730 rleg->AddEntry(htimestat[ir], Form("%s (scaled with %0.02f)", m_sring[ir].data(), norm), "lep");
731 htimestat[ir]->Scale(1.0 / norm);
732 setHistStyle(htimestat[ir], lcolors[ir], ir + 20, 0.0, 1.10);
733 htimestat[ir]->SetFillColorAlpha(lcolors[ir], 0.30);
734 if (ir == 0) htimestat[ir]->Draw("hist");
735 else htimestat[ir]->Draw("hist same");
736 if (ir == 1)rleg->Draw("same");
737 }
738
739 cconst->SaveAs(Form("%s_relconst_timestat_%s.pdf", m_prefix.data(), m_suffix.data()));
740 cconst->SaveAs(Form("%s_relconst_timestat_%s.root", m_prefix.data(), m_suffix.data()));
741 delete cconst;
742}

◆ 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}

◆ 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}
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:150

◆ 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}

◆ setChiPars()

void setChiPars ( int value,
double min,
double max )
inline

function to set chi hist parameters

Definition at line 83 of file CDCDedxInjectTimeAlgorithm.h.

84 {
85 m_chiBins = value;
86 m_chiMin = min;
87 m_chiMax = max;
88 }

◆ setDedxPars()

void setDedxPars ( int value,
double min,
double max )
inline

function to set dedx hist parameters

Definition at line 73 of file CDCDedxInjectTimeAlgorithm.h.

74 {
75 m_dedxBins = value;
76 m_dedxMin = min;
77 m_dedxMax = max;
78 }

◆ 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;}

◆ setFitWidth()

void setFitWidth ( double value)
inline

function to set fit range (sigma)

Definition at line 63 of file CDCDedxInjectTimeAlgorithm.h.

63{m_sigmaR = value;}

◆ setHistStyle()

void setHistStyle ( TH1D *& htemp,
const int ic,
const int is,
const double min,
const double max )
inline

function to set histogram cosmetics

Definition at line 173 of file CDCDedxInjectTimeAlgorithm.h.

174 {
175 htemp->SetStats(0);
176 htemp->LabelsDeflate();
177 htemp->SetMarkerColor(ic);
178 htemp->SetMarkerStyle(is);
179 htemp->GetXaxis()->SetLabelOffset(-0.055);
180 htemp->GetYaxis()->SetTitleOffset(0.75);
181 htemp->SetMinimum(min);
182 htemp->SetMaximum(max);
183 }

◆ 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}
void setInputFileNames(PyObject *inputFileNames)
Set the input file names used for this algorithm from a Python list.
Scalar convertPythonObject(const boost::python::object &pyObject, Scalar)
Convert from Python to given type.

◆ 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());
243}
std::string m_granularityOfData
Granularity of input data. This only changes when the input files change so it isn't specific to an e...
std::string getGranularityFromData() const
Get the granularity of collected data.
std::vector< std::string > expandWordExpansions(const std::vector< std::string > &filenames)
Performs wildcard expansion using wordexp(), returns matches.

◆ setMergePayload()

void setMergePayload ( bool value = true)
inline

function to decide merged vs relative calibration

Definition at line 53 of file CDCDedxInjectTimeAlgorithm.h.

53{m_isMerge = value;}

◆ setMinTracks()

void setMinTracks ( int value)
inline

function to set min # of tracks in time bins (0-40ms)

Definition at line 68 of file CDCDedxInjectTimeAlgorithm.h.

68{m_thersE = value;}

◆ setMonitoringPlots()

void setMonitoringPlots ( bool value = false)
inline

function to enable monitoring plots

Definition at line 58 of file CDCDedxInjectTimeAlgorithm.h.

58{m_ismakePlots = value;}

◆ setOutputJsonValue()

template<class T>
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
410 // Also update the intra-run objects to the event at the same time (maybe unnecessary...)
412}
static DBStore & Instance()
Instance of a singleton DBStore.
Definition DBStore.cc:26
void updateEvent()
Updates all intra-run dependent objects.
Definition DBStore.cc:140
void update()
Updates all objects that are outside their interval of validity.
Definition DBStore.cc:77

Member Data Documentation

◆ c_rings

const int c_rings = numdedx::nrings
staticprivate

injection ring constants

Definition at line 237 of file CDCDedxInjectTimeAlgorithm.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_chiBins

int m_chiBins
private

bins for chi histogram

Definition at line 251 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_chiMax

double m_chiMax
private

max range of chi

Definition at line 253 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_chiMin

double m_chiMin
private

min range of chi

Definition at line 252 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_countR

int m_countR
private

a hack for running functions once

Definition at line 255 of file CDCDedxInjectTimeAlgorithm.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_DBInjectTime

DBObjPtr<CDCDedxInjectionTime> m_DBInjectTime
private

Injection time DB object.

Definition at line 267 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_dedxBins

int m_dedxBins
private

bins for dedx histogram

Definition at line 247 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_dedxMax

double m_dedxMax
private

max range of dedx

Definition at line 249 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_dedxMin

double m_dedxMin
private

min range of dedx

Definition at line 248 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_description

std::string m_description {""}
privateinherited

Description of the algorithm.

Definition at line 385 of file CalibrationAlgorithm.h.

385{""};

◆ 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_ismakePlots

bool m_ismakePlots
private

produce plots for monitoring

Definition at line 259 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_isMerge

bool m_isMerge
private

merge payload when rel constant

Definition at line 260 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_isminStat

bool m_isminStat
private

flag to merge runs for statistics thershold

Definition at line 258 of file CDCDedxInjectTimeAlgorithm.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_prefix

std::string m_prefix
private

string prefix for plot names

Definition at line 262 of file CDCDedxInjectTimeAlgorithm.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_sigmaR

double m_sigmaR
private

fit dedx dist in sigma range

Definition at line 245 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_sring

std::array<std::string, numdedx::nrings> m_sring {"ler", "her"}
private

injection ring name

Definition at line 238 of file CDCDedxInjectTimeAlgorithm.h.

238{"ler", "her"};

◆ m_suffix

std::string m_suffix
private

string suffix for object names

Definition at line 263 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_tbins

unsigned int m_tbins
private

internal time bins

Definition at line 244 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_tedges

double* m_tedges
private

internal time array (copy of vtlocaledges)

Definition at line 243 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_thersE

int m_thersE
private

min tracks to start calibration

Definition at line 256 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_vinjPayload

std::vector<std::vector<double> > m_vinjPayload
private

vector to store payload values

Definition at line 265 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_vtedges

std::vector<double> m_vtedges
private

external time vector

Definition at line 240 of file CDCDedxInjectTimeAlgorithm.h.

◆ m_vtlocaledges

std::vector<double> m_vtlocaledges
private

internal time vector

Definition at line 241 of file CDCDedxInjectTimeAlgorithm.h.


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