KLMTimeAlgorithm Class Reference

KLM time calibration algorithm. More...

#include <KLMTimeAlgorithm.h>

Inheritance diagram for KLMTimeAlgorithm:

Classes
struct	Event
	Event data. More...

Public Types
enum	ChannelCalibrationStatus {   c_NotEnoughData = 0 ,   c_FailedFit = 1 ,   c_SuccessfulCalibration = 2 }
	Channel calibration status. More...
enum	EResult {   c_OK ,   c_Iterate ,   c_NotEnoughData ,   c_Failure ,   c_Undefined }
	The result of calibration. More...

Public Member Functions
	KLMTimeAlgorithm ()
	Constructor.
	~KLMTimeAlgorithm ()
	Destructor.
void	setDebug ()
	Turn on debug mode (prints histograms and output running log).
void	setMC (bool mc)
	Set flag indicating whether the input is MC sample.
void	useEvtT0 ()
	Use event T0 as the initial time point or not.
void	setMinimalDigitNumber (int minimalDigitNumber)
	Set minimal digit number (total).
void	setLowerLimit (int counts)
	Set the lower number of hits collected on one single strip.
void	setApplyChargeRestriction (bool apply)
	Enable or disable ADC/charge restriction cuts for scintillators.
void	setSaveAllPlots (bool on)
	Save every preallocated debug histogram family (sectors/layers/planes/2D maps).
void	setSaveChannelHists (bool on)
	When running in minimal mode, also write the per-channel temporary histograms (the vital tc, raw, hc 1D’s created on-the-fly) before deleting them.
void	saveHist ()
	Save histograms to file.
double	esti_timeShift (const KLMChannelIndex &klmChannel)
	Estimate value of calibration constant for uncalibrated channels.
std::pair< int, double >	tS_upperStrip (const KLMChannelIndex &klmChannel)
	Tracing available channels with increasing strip number.
std::pair< int, double >	tS_lowerStrip (const KLMChannelIndex &klmChannel)
	Tracing available channels with decreasing strip number.
double	esti_timeRes (const KLMChannelIndex &klmChannel)
	Estimate value of calibration constant for calibrated channels.
std::pair< int, double >	tR_upperStrip (const KLMChannelIndex &klmChannel)
	Tracing available channels with increasing strip number.
std::pair< int, double >	tR_lowerStrip (const KLMChannelIndex &klmChannel)
	Tracing available channels with decreasing strip number.
std::string	getPrefix () const
	Get the prefix used for getting calibration data.
bool	checkPyExpRun (PyObject *pyObj)
	Checks that a PyObject can be successfully converted to an ExpRun type.
Calibration::ExpRun	convertPyExpRun (PyObject *pyObj)
	Performs the conversion of PyObject to ExpRun.
std::string	getCollectorName () const
	Alias for prefix.
void	setPrefix (const std::string &prefix)
	Set the prefix used to identify datastore objects.
void	setInputFileNames (PyObject *inputFileNames)
	Set the input file names used for this algorithm from a Python list.
PyObject *	getInputFileNames ()
	Get the input file names used for this algorithm and pass them out as a Python list of unicode strings.
std::vector< Calibration::ExpRun >	getRunListFromAllData () const
	Get the complete list of runs from inspection of collected data.
RunRange	getRunRangeFromAllData () const
	Get the complete RunRange from inspection of collected data.
IntervalOfValidity	getIovFromAllData () const
	Get the complete IoV from inspection of collected data.
void	fillRunToInputFilesMap ()
	Fill the mapping of ExpRun -> Files.
std::string	getGranularity () const
	Get the granularity of collected data.
EResult	execute (std::vector< Calibration::ExpRun > runs={}, int iteration=0, IntervalOfValidity iov=IntervalOfValidity())
	Runs calibration over vector of runs for a given iteration.
EResult	execute (PyObject *runs, int iteration=0, IntervalOfValidity iov=IntervalOfValidity())
	Runs calibration over Python list of runs. Converts to C++ and then calls the other execute() function.
std::list< Database::DBImportQuery > &	getPayloads ()
	Get constants (in TObjects) for database update from last execution.
std::list< Database::DBImportQuery >	getPayloadValues ()
	Get constants (in TObjects) for database update from last execution but passed by VALUE.
bool	commit ()
	Submit constants from last calibration into database.
bool	commit (std::list< Database::DBImportQuery > payloads)
	Submit constants from a (potentially previous) set of payloads.
const std::string &	getDescription () const
	Get the description of the algorithm (set by developers in constructor)
bool	loadInputJson (const std::string &jsonString)
	Load the m_inputJson variable from a string (useful from Python interface). The return bool indicates success or failure.
const std::string	dumpOutputJson () const
	Dump the JSON string of the output JSON object.
const std::vector< Calibration::ExpRun >	findPayloadBoundaries (std::vector< Calibration::ExpRun > runs, int iteration=0)
	Used to discover the ExpRun boundaries that you want the Python CAF to execute on. This is optional and only used in some.
template<>
std::shared_ptr< TTree >	getObjectPtr (const std::string &name, const std::vector< Calibration::ExpRun > &requestedRuns)
	Specialization of getObjectPtr<TTree>.

Protected Member Functions
virtual EResult	calibrate () override
	Run algorithm on data.
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
void	setupDatabase ()
	Setup the database.
CalibrationAlgorithm::EResult	readCalibrationData ()
	Read calibration data.
void	readCalibrationDataCounts (std::map< KLMChannelNumber, unsigned int > &eventCounts)
	Count events per channel (lightweight scan without loading full data).
void	readCalibrationDataFor2DFit (const std::vector< std::pair< KLMChannelNumber, unsigned int > > &channelsBKLM, const std::vector< std::pair< KLMChannelNumber, unsigned int > > &channelsEKLM)
	Load calibration data only for channels needed for 2D fit.
void	readCalibrationDataBatch (std::function< bool(const KLMChannelIndex &)> channelFilter)
	Load calibration data for a specific batch of channels.
void	createHistograms ()
	Create histograms.
void	writeThenDelete_ (TH1 *h, bool write, TDirectory *dir=nullptr)
	Optionally write a histogram, then delete it to free memory.
void	writeThenDelete_ (TH2 *h, bool write, TDirectory *dir=nullptr)
	Same as above, but for 2D histograms.
bool	passesADCCut (const Event &event, int subdetector, int layer) const
	Check if event passes ADC count cuts for quality selection.
void	fillTimeDistanceProfiles (TProfile *profileRpcPhi, TProfile *profileRpcZ, TProfile *profileBKLMScintillatorPhi, TProfile *profileBKLMScintillatorZ, TProfile *profileEKLMScintillatorPlane1, TProfile *profileEKLMScintillatorPlane2, bool fill2dHistograms)
	Fill profiles of time versus distance.
void	timeDistance2dFit (const std::vector< std::pair< KLMChannelNumber, unsigned int > > &channels, double &delay, double &delayError)
	Two-dimensional fit for individual channels.
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::map< KLMChannelNumber, std::vector< struct Event > >	m_evts
	Container of hit information.
std::map< KLMChannelNumber, int >	m_cFlag
	Calibration flag if the channel has enough hits collected and fitted OK.
std::map< KLMChannelNumber, double >	m_timeShift
	Shift values of each channel.
std::map< KLMChannelNumber, double >	m_timeRes
	Resolution values of each channel.
std::map< KLMChannelNumber, double >	m_time_channel
	Time distribution central value of each channel.
std::map< KLMChannelNumber, double >	m_etime_channel
	Time distribution central value Error of each channel.
std::map< KLMChannelNumber, double >	m_ctime_channel
	Calibrated time distribution central value of each channel.
std::map< KLMChannelNumber, double >	mc_etime_channel
	Calibrated time distribution central value Error of each channel.
double	m_LowerTimeBoundaryRPC = -10.0
	Lower time boundary for RPC.
double	m_UpperTimeBoundaryRPC = 10.0
	Upper time boundary for RPC.
double	m_LowerTimeBoundaryScintillatorsBKLM = 20.0
	Lower time boundary for BKLM scintillators.
double	m_UpperTimeBoundaryScintillatorsBKLM = 70.0
	Upper time boundary for BKLM scintillators.
double	m_LowerTimeBoundaryScintillatorsEKLM = 20.0
	Lower time boundary for EKLM scintillators.
double	m_UpperTimeBoundaryScintillatorsEKLM = 70.0
	Upper time boundary for BKLM scintillators.
double	m_LowerTimeBoundaryCalibratedRPC = -40.0
	Lower time boundary for RPC (calibrated data).
double	m_UpperTimeBoundaryCalibratedRPC = 40.0
	Upper time boundary for RPC (calibrated data).
bool	m_useFixedRPCDelay = false
	Whether to use fixed propagation delay for RPCs.
double	m_fixedRPCDelay = 0.0667
	Fixed propagation delay for RPCs (ns/cm).
double	m_LowerTimeBoundaryCalibratedScintillatorsBKLM = -40.0
	Lower time boundary for BKLM scintillators (calibrated data).
double	m_UpperTimeBoundaryCalibratedScintillatorsBKLM = 40.0
	Upper time boundary for BKLM scintillators (calibrated data).
double	m_LowerTimeBoundaryCalibratedScintillatorsEKLM = -40.0
	Lower time boundary for EKLM scintillators (calibrated data).
double	m_UpperTimeBoundaryCalibratedScintillatorsEKLM = 40.0
	Upper time boundary for BKLM scintillators (calibrated data).
double	m_time_channelAvg_rpc = 0.0
	Central value of the global time distribution (BKLM RPC part).
double	m_etime_channelAvg_rpc = 0.0
	Central value error of the global time distribution (BKLM RPC part).
double	m_time_channelAvg_scint = 0.0
	Central value of the global time distribution (BKLM scintillator part).
double	m_etime_channelAvg_scint = 0.0
	Central value error of the global time distribution (BKLM scintillator part).
double	m_time_channelAvg_scint_end = 0.0
	Central value of the global time distribution (EKLM scintillator part).
double	m_etime_channelAvg_scint_end = 0.0
	Central value error of the global time distribution (EKLM scintillator part).
double	m_ctime_channelAvg_rpc = 0.0
	Calibrated central value of the global time distribution (BKLM RPC part).
double	mc_etime_channelAvg_rpc = 0.0
	Calibrated central value error of the global time distribution (BKLM RPC part).
double	m_ctime_channelAvg_scint = 0.0
	Calibrated central value of the global time distribution (BKLM scintillator part).
double	mc_etime_channelAvg_scint = 0.0
	Calibrated central value error of the global time distribution (BKLM scintillator part).
double	m_ctime_channelAvg_scint_end = 0.0
	Calibrated central value of the global time distribution (EKLM scintillator part).
double	mc_etime_channelAvg_scint_end = 0.0
	Calibrated central value error of the global time distribution (EKLM scintillator part).
int	m_MinimalDigitNumber = 100000000
	Minimal digit number (total).
int	m_lower_limit_counts = 50
	Lower limit of hits collected for on single channel.
const KLMElementNumbers *	m_ElementNumbers
	Element numbers.
const bklm::GeometryPar *	m_BKLMGeometry = nullptr
	BKLM geometry data.
const EKLM::GeometryData *	m_EKLMGeometry = nullptr
	EKLM geometry data.
KLMChannelIndex	m_klmChannels
	KLM ChannelIndex object.
ROOT::Math::MinimizerOptions	m_minimizerOptions
	Minimization options.
KLMTimeConstants *	m_timeConstants = nullptr
	DBObject of time cost on some parts of the detector.
KLMTimeCableDelay *	m_timeCableDelay = nullptr
	DBObject of the calibration constant of each channel due to cable decay.
KLMTimeResolution *	m_timeResolution = nullptr
	DBObject of time resolution.
KLMEventT0HitResolution *	m_eventT0HitResolution = nullptr
	DBObject of per-hit time resolution for EventT0.
bool	m_debug = false
	Debug mode.
bool	m_mc = false
	MC or data.
bool	m_useEventT0 = true
	Whether to use event T0 from CDC.
bool	m_applyChargeRestriction = false
	Whether to apply ADC/charge restriction cuts for scintillators.
TH1I *	h_calibrated = nullptr
	Calibration statistics for each channel.
TH1I *	hc_calibrated = nullptr
	Calibration statistics for each channel.
TH1F *	h_diff = nullptr
	Distance between global and local position.
TGraphErrors *	gre_time_channel_rpc = nullptr
	BKLM RPC.
TGraphErrors *	gre_time_channel_scint = nullptr
	BKLM Scintillator.
TGraphErrors *	gre_time_channel_scint_end = nullptr
	EKLM.
TGraphErrors *	gre_ctime_channel_rpc = nullptr
	BKLM RPC.
TGraphErrors *	gre_ctime_channel_scint = nullptr
	BKLM Scintillator.
TGraphErrors *	gre_ctime_channel_scint_end = nullptr
	EKLM.
TGraph *	gr_timeShift_channel_rpc = nullptr
	BKLM RPC.
TGraph *	gr_timeShift_channel_scint = nullptr
	BKLM scintillator.
TGraph *	gr_timeShift_channel_scint_end = nullptr
	EKLM.
TGraph *	gr_timeRes_channel_rpc = nullptr
	BKLM RPC.
TGraph *	gr_timeRes_channel_scint = nullptr
	BKLM scintillator.
TGraph *	gr_timeRes_channel_scint_end = nullptr
	EKLM.
TProfile *	m_ProfileRpcPhi = nullptr
	For BKLM RPC phi plane.
TProfile *	m_ProfileRpcZ = nullptr
	For BKLM RPC z plane.
TProfile *	m_ProfileBKLMScintillatorPhi = nullptr
	For BKLM scintillator phi plane.
TProfile *	m_ProfileBKLMScintillatorZ = nullptr
	For BKLM scintillator z plane.
TProfile *	m_ProfileEKLMScintillatorPlane1 = nullptr
	For EKLM scintillator plane1.
TProfile *	m_ProfileEKLMScintillatorPlane2 = nullptr
	For EKLM scintillator plane2.
TProfile *	m_Profile2RpcPhi = nullptr
	For BKLM RPC phi plane.
TProfile *	m_Profile2RpcZ = nullptr
	For BKLM RPC z plane.
TProfile *	m_Profile2BKLMScintillatorPhi = nullptr
	For BKLM scintillator phi plane.
TProfile *	m_Profile2BKLMScintillatorZ = nullptr
	For BKLM scintillator z plane.
TProfile *	m_Profile2EKLMScintillatorPlane1 = nullptr
	For EKLM scintillator plane1.
TProfile *	m_Profile2EKLMScintillatorPlane2 = nullptr
	For EKLM scintillator plane2.
TH1F *	h_time_rpc_tc = nullptr
	BKLM RPC part.
TH1F *	h_time_scint_tc = nullptr
	BKLM scintillator part.
TH1F *	h_time_scint_tc_end = nullptr
	EKLM part.
TH1F *	h_time_rpc = nullptr
	BKLM RPC part.
TH1F *	h_time_scint = nullptr
	BKLM scintillator part.
TH1F *	h_time_scint_end = nullptr
	EKLM part.
TH1F *	hc_time_rpc = nullptr
	BKLM RPC part.
TH1F *	hc_time_scint = nullptr
	BKLM scintillator part.
TH1F *	hc_time_scint_end = nullptr
	EKLM part.
TH1F *	h_timeF_rpc [2] = {nullptr}
	BKLM RPC part.
TH1F *	h_timeF_scint [2] = {nullptr}
	BKLM scintillator part.
TH1F *	h_timeF_scint_end [2] = {nullptr}
	EKLM part.
TH1F *	hc_timeF_rpc [2] = {nullptr}
	BKLM RPC part.
TH1F *	hc_timeF_scint [2] = {nullptr}
	BKLM scintillator part.
TH1F *	hc_timeF_scint_end [2] = {nullptr}
	EKLM part.
TH2F *	h2_timeF_rpc [2] = {nullptr}
	BKLM RPC part.
TH2F *	h2_timeF_scint [2] = {nullptr}
	BKLM scintillator part.
TH2F *	h2_timeF_scint_end [2] = {nullptr}
	EKLM part.
TH2F *	h2c_timeF_rpc [2] = {nullptr}
	BKLM RPC part.
TH2F *	h2c_timeF_scint [2] = {nullptr}
	BKLM scintillator part.
TH2F *	h2c_timeF_scint_end [2] = {nullptr}
	EKLM part.
TH1F *	h_timeFS_rpc [2][8] = {{nullptr}}
	BKLM RPC part.
TH1F *	h_timeFS_scint [2][8] = {{nullptr}}
	BKLM scintillator part.
TH1F *	h_timeFS_scint_end [2][4] = {{nullptr}}
	EKLM part.
TH1F *	hc_timeFS_rpc [2][8] = {{nullptr}}
	BKLM RPC part.
TH1F *	hc_timeFS_scint [2][8] = {{nullptr}}
	BKLM scintillator part.
TH1F *	hc_timeFS_scint_end [2][4] = {{nullptr}}
	EKLM part.
TH2F *	h2_timeFS [2][8] = {{nullptr}}
	BKLM part.
TH2F *	h2_timeFS_end [2][4] = {{nullptr}}
	EKLM part.
TH2F *	h2c_timeFS [2][8] = {{nullptr}}
	BKLM part.
TH2F *	h2c_timeFS_end [2][4] = {{nullptr}}
	EKLM part.
TH1F *	h_timeFSL [2][8][15] = {{{nullptr}}}
	BKLM part.
TH1F *	h_timeFSL_end [2][4][14] = {{{nullptr}}}
	EKLM part.
TH1F *	hc_timeFSL [2][8][15] = {{{nullptr}}}
	BKLM part.
TH1F *	hc_timeFSL_end [2][4][14] = {{{nullptr}}}
	EKLM part.
TH1F *	h_timeFSLP [2][8][15][2] = {{{{nullptr}}}}
	BKLM part.
TH1F *	h_timeFSLP_end [2][4][14][2] = {{{{nullptr}}}}
	EKLM part.
TH1F *	hc_timeFSLP [2][8][15][2] = {{{{nullptr}}}}
	BKLM part.
TH1F *	hc_timeFSLP_end [2][4][14][2] = {{{{nullptr}}}}
	EKLM part.
TH2F *	h2_timeFSLP [2][8][15][2] = {{{{nullptr}}}}
	BKLM part.
TH2F *	h2_timeFSLP_end [2][4][14][2] = {{{{nullptr}}}}
	EKLM part.
TH2F *	h2c_timeFSLP [2][8][15][2] = {{{{nullptr}}}}
	BKLM part.
TH2F *	h2c_timeFSLP_end [2][4][14][2] = {{{{nullptr}}}}
	EKLM part.
TH1F *	h_timeFSLPC_tc [2][8][15][2][54] = {{{{{nullptr}}}}}
	BKLM part, used for effective light speed estimation.
TH1F *	h_timeFSLPC [2][8][15][2][54] = {{{{{nullptr}}}}}
	BKLM part.
TH2F *	m_HistTimeLengthBKLM [2][8][15][2][54] = {{{{{nullptr}}}}}
	Two-dimensional distributions of time versus propagation length.
TH1F *	h_timeFSLPC_tc_end [2][4][14][2][75] = {{{{{nullptr}}}}}
	EKLM part, used for effective light speed estimation.
TH1F *	h_timeFSLPC_end [2][4][14][2][75] = {{{{{nullptr}}}}}
	EKLM part.
TH2F *	m_HistTimeLengthEKLM [2][4][14][2][75] = {{{{{nullptr}}}}}
	Two-dimensional distributions of time versus propagation length.
TH1F *	hc_timeFSLPC [2][8][15][2][54] = {{{{{nullptr}}}}}
	BKLM part.
TH1F *	hc_timeFSLPC_end [2][4][14][2][75] = {{{{{nullptr}}}}}
	EKLM part.
TH1F *	h_eventT0_rpc = nullptr
	EventT0 seen by RPC hits.
TH1F *	h_eventT0_scint = nullptr
	EventT0 seen by BKLM scintillator hits.
TH1F *	h_eventT0_scint_end = nullptr
	EventT0 seen by EKLM scintillator hits.
TH1F *	hc_eventT0_rpc = nullptr
	Corrected EventT0 for RPC hits.
TH1F *	hc_eventT0_scint = nullptr
	Corrected EventT0 for BKLM scintillator hits.
TH1F *	hc_eventT0_scint_end = nullptr
	Corrected EventT0 for EKLM scintillator hits.
TH1F *	h_nHits_plus_rpc
	Number of RPC hits per mu+ track.
TH1F *	h_nHits_minus_rpc
	Number of RPC hits per mu- track.
TH1F *	h_nHits_plus_scint
	Number of BKLM scintillator hits per mu+ track.
TH1F *	h_nHits_minus_scint
	Number of BKLM scintillator hits per mu- track.
TH1F *	h_nHits_plus_scint_end
	Number of EKLM scintillator hits per mu+ track.
TH1F *	h_nHits_minus_scint_end
	Number of EKLM scintillator hits per mu- track.
TH2F *	h2_deltaT0_vs_v_rpc
	DeltaT0 vs inverse hit count for RPC.
TH2F *	h2_deltaT0_vs_v_scint
	DeltaT0 vs inverse hit count for BKLM scintillator.
TH2F *	h2_deltaT0_vs_v_scint_end
	DeltaT0 vs inverse hit count for EKLM scintillator.
TProfile *	prof_deltaT0_rms_vs_v_rpc
	DeltaT0 RMS vs inverse hit count profile for RPC.
TProfile *	prof_deltaT0_rms_vs_v_scint
	DeltaT0 RMS vs inverse hit count profile for BKLM scintillator.
TProfile *	prof_deltaT0_rms_vs_v_scint_end
	DeltaT0 RMS vs inverse hit count profile for EKLM scintillator.
TH2F *	h2_deltaT0_vs_nhits_rpc
	DeltaT0 vs total hit count for RPC.
TH2F *	h2_deltaT0_vs_nhits_scint
	DeltaT0 vs total hit count for BKLM scintillator.
TH2F *	h2_deltaT0_vs_nhits_scint_end
	DeltaT0 vs total hit count for EKLM scintillator.
TH1F *	hc_eventT0_rpc_lowN
	Corrected EventT0 for RPC with low hit count.
TH1F *	hc_eventT0_rpc_midN
	Corrected EventT0 for RPC with medium hit count.
TH1F *	hc_eventT0_rpc_highN
	Corrected EventT0 for RPC with high hit count.
TH1F *	hc_eventT0_scint_lowN
	Corrected EventT0 for BKLM scintillator with low hit count.
TH1F *	hc_eventT0_scint_midN
	Corrected EventT0 for BKLM scintillator with medium hit count.
TH1F *	hc_eventT0_scint_highN
	Corrected EventT0 for BKLM scintillator with high hit count.
TH1F *	hc_eventT0_scint_end_lowN
	Corrected EventT0 for EKLM scintillator with low hit count.
TH1F *	hc_eventT0_scint_end_midN
	Corrected EventT0 for EKLM scintillator with medium hit count.
TH1F *	hc_eventT0_scint_end_highN
	Corrected EventT0 for EKLM scintillator with high hit count.
TF1 *	fcn_pol1 = nullptr
	Pol1 function.
TF1 *	fcn_const = nullptr
	Const function.
TF1 *	fcn_gaus = nullptr
	Gaussian function.
TF1 *	fcn_land = nullptr
	Landau function.
TFile *	m_outFile = nullptr
	Output file.
bool	m_saveAllPlots = false
	Default minimal unless you set true in your header script.
bool	m_saveChannelHists = false
	Write per-channel temporary histograms (tc/raw/hc) in minimal mode.
TDirectory *	m_channelHistDir_BKLM [2][8][15][2] = {}
	Directory structure for per-channel histograms (BKLM).
TDirectory *	m_channelHistDir_EKLM [2][4][14][2] = {}
	Directory structure for per-channel histograms (EKLM).
std::vector< std::string >	m_inputFileNames
	List of input files to the Algorithm, will initially be user defined but then gets the wildcards expanded during execute()
std::map< Calibration::ExpRun, std::vector< std::string > >	m_runsToInputFiles
	Map of Runs to input files. Gets filled when you call getRunRangeFromAllData, gets cleared when setting input files again.
std::string	m_granularityOfData
	Granularity of input data. This only changes when the input files change so it isn't specific to an execution.
ExecutionData	m_data
	Data specific to a SINGLE execution of the algorithm. Gets reset at the beginning of execution.
std::string	m_description {""}
	Description of the algorithm.
std::string	m_prefix {""}
	The name of the TDirectory the collector objects are contained within.
nlohmann::json	m_jsonExecutionInput = nlohmann::json::object()
	Optional input JSON object used to make decisions about how to execute the algorithm code.
nlohmann::json	m_jsonExecutionOutput = nlohmann::json::object()
	Optional output JSON object that can be set during the execution by the underlying algorithm code.

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

Detailed Description

KLM time calibration algorithm.

Definition at line 50 of file KLMTimeAlgorithm.h.

Member Enumeration Documentation

ChannelCalibrationStatus

enum ChannelCalibrationStatus

Channel calibration status.

Definition at line 129 of file KLMTimeAlgorithm.h.

                                  {
 
      /* Not enough data. */
      c_NotEnoughData = 0,
 
      /* Failed fit. */
      c_FailedFit = 1,
 
      /* Successful calibration. */
      c_SuccessfulCalibration = 2,
 
    };

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.

                 {
      c_OK,           
      c_Iterate,      
      c_NotEnoughData,
      c_Failure,      
      c_Undefined     
    };

Constructor & Destructor Documentation

KLMTimeAlgorithm()

KLMTimeAlgorithm

(

)

Constructor.

Definition at line 97 of file KLMTimeAlgorithm.cc.

                                   :
  CalibrationAlgorithm("KLMTimeCollector")
{
  m_ElementNumbers = &(KLMElementNumbers::Instance());
  m_minimizerOptions = ROOT::Math::MinimizerOptions();
}

~KLMTimeAlgorithm()

~KLMTimeAlgorithm

(

)

Destructor.

Definition at line 104 of file KLMTimeAlgorithm.cc.

{
}

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.

{};

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.

{};

calibrate()

CalibrationAlgorithm::EResult calibrate ( )

overrideprotectedvirtual

Run algorithm on data.

Implements CalibrationAlgorithm.

Definition at line 1118 of file KLMTimeAlgorithm.cc.

{
  int channelId;
  gROOT->SetBatch(kTRUE);
  setupDatabase();
  m_timeCableDelay = new KLMTimeCableDelay();
  m_timeConstants = new KLMTimeConstants();
  m_timeResolution = new KLMTimeResolution();
  m_eventT0HitResolution = new KLMEventT0HitResolution();
 
  fcn_gaus = new TF1("fcn_gaus", "gaus");
  fcn_land = new TF1("fcn_land", "landau");
  fcn_pol1 = new TF1("fcn_pol1", "pol1");
  fcn_const = new TF1("fcn_const", "pol0");
 
  // Initial validation only - DON'T load all data yet
  CalibrationAlgorithm::EResult result = readCalibrationData();
  if (result != CalibrationAlgorithm::c_OK)
    return result;
 
  /* Choose non-existing file name. */
  std::string name = "time_calibration.root";
  int i = 1;
  while (1) {
    struct stat buffer;
    if (stat(name.c_str(), &buffer) != 0)
      break;
    name = "time_calibration_" + std::to_string(i) + ".root";
    i = i + 1;
    if (i < 0)
      break;
  }
  m_outFile = new TFile(name.c_str(), "recreate");
  createHistograms();
 
  std::vector<struct Event> eventsChannel;
  eventsChannel.clear();
  m_cFlag.clear();
  m_minimizerOptions.SetDefaultStrategy(2);
 
  B2INFO("Counting events per channel...");
  std::map<KLMChannelNumber, unsigned int> eventCounts;
  readCalibrationDataCounts(eventCounts);
 
  /* Sort channels by number of events and initialize flags. */
  std::vector< std::pair<KLMChannelNumber, unsigned int> > channelsBKLM;
  std::vector< std::pair<KLMChannelNumber, unsigned int> > channelsEKLM;
  KLMChannelIndex klmChannels;
 
  for (KLMChannelIndex& klmChannel : klmChannels) {
    KLMChannelNumber channel = klmChannel.getKLMChannelNumber();
    m_cFlag[channel] = ChannelCalibrationStatus::c_NotEnoughData;
 
    if (eventCounts.find(channel) == eventCounts.end())
      continue;
 
    int nEvents = eventCounts[channel];
    if (nEvents < m_lower_limit_counts) {
      B2WARNING("Not enough calibration data collected."
                << LogVar("channel", channel)
                << LogVar("number of digit", nEvents));
      continue;
    }
 
    m_cFlag[channel] = ChannelCalibrationStatus::c_FailedFit;
 
    if (klmChannel.getSubdetector() == KLMElementNumbers::c_BKLM &&
        klmChannel.getLayer() < BKLMElementNumbers::c_FirstRPCLayer) {
      channelsBKLM.push_back(std::pair<KLMChannelNumber, unsigned int>(channel, nEvents));
    }
    if (klmChannel.getSubdetector() == KLMElementNumbers::c_EKLM) {
      channelsEKLM.push_back(std::pair<KLMChannelNumber, unsigned int>(channel, nEvents));
    }
  }
 
  std::sort(channelsBKLM.begin(), channelsBKLM.end(), compareEventNumber);
  std::sort(channelsEKLM.begin(), channelsEKLM.end(), compareEventNumber);
 
  /* Two-dimensional fit using top channels only. */
  double delayBKLM, delayBKLMError;
  double delayEKLM, delayEKLMError;
 
  /* Load data for 2D fit channels only. */
  readCalibrationDataFor2DFit(channelsBKLM, channelsEKLM);
  timeDistance2dFit(channelsBKLM, delayBKLM, delayBKLMError);
  timeDistance2dFit(channelsEKLM, delayEKLM, delayEKLMError);
  m_evts.clear();
 
  B2INFO("2D fits complete, data cleared.");
 
  /* Define processing batches for channel calibration. */
  auto isRPCBackward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_BKLM &&
           ch.getLayer() >= BKLMElementNumbers::c_FirstRPCLayer &&
           ch.getSection() == BKLMElementNumbers::c_BackwardSection;
  };
 
  auto isRPCForward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_BKLM &&
           ch.getLayer() >= BKLMElementNumbers::c_FirstRPCLayer &&
           ch.getSection() == BKLMElementNumbers::c_ForwardSection;
  };
 
  auto isBKLMScintillatorBackward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_BKLM &&
           ch.getLayer() < BKLMElementNumbers::c_FirstRPCLayer &&
           ch.getSection() == BKLMElementNumbers::c_BackwardSection;
  };
 
  auto isBKLMScintillatorForward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_BKLM &&
           ch.getLayer() < BKLMElementNumbers::c_FirstRPCLayer &&
           ch.getSection() == BKLMElementNumbers::c_ForwardSection;
  };
 
  auto isEKLMScintillatorBackward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_EKLM &&
           ch.getSection() == EKLMElementNumbers::c_BackwardSection;
  };
 
  auto isEKLMScintillatorForward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_EKLM &&
           ch.getSection() == EKLMElementNumbers::c_ForwardSection;
  };
 
  std::vector<std::pair<std::string, std::function<bool(const KLMChannelIndex&)>>> batches = {
    {"RPC Backward", isRPCBackward},
    {"RPC Forward", isRPCForward},
    {"BKLM Scintillator Backward", isBKLMScintillatorBackward},
    {"BKLM Scintillator Forward", isBKLMScintillatorForward},
    {"EKLM Scintillator Backward", isEKLMScintillatorBackward},
    {"EKLM Scintillator Forward", isEKLMScintillatorForward}
  };
 
  /**********************************
   * FIRST LOOP (BATCHED)
   * Fill global histograms to compute global means
   **********************************/
  B2INFO("First loop: Computing global statistics (batched processing)...");
 
  TString iFstring[2] = {"Backward", "Forward"};
  TString iPstring[2] = {"ZReadout", "PhiReadout"};
  int nBin = 80;
  int nBin_scint = 80;
 
  for (const auto& batch : batches) {
    B2INFO("Processing batch for global stats: " << batch.first);
    readCalibrationDataBatch(batch.second);
 
    for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
      channelId = klmChannel.getKLMChannelNumber();
 
      if (!batch.second(klmChannel))
        continue;
 
      if (m_cFlag[channelId] == ChannelCalibrationStatus::c_NotEnoughData)
        continue;
 
      if (m_evts.find(channelId) == m_evts.end())
        continue;
 
      eventsChannel = m_evts[channelId];
      int iSub = klmChannel.getSubdetector();
      int iL = (iSub == KLMElementNumbers::c_BKLM) ? klmChannel.getLayer() - 1 : -1;
 
      // Fill global histograms only
      for (const Event& event : eventsChannel) {
        // Apply ADC cut early
        if (!passesADCCut(event, iSub, iL))
          continue;
 
        XYZVector diffD = XYZVector(event.diffDistX, event.diffDistY, event.diffDistZ);
        h_diff->Fill(diffD.R());
 
        double timeHit = event.time();
        if (m_useEventT0)
          timeHit = timeHit - event.t0;
 
        if (timeHit <= -400e3)
          continue;
 
        if (iSub == KLMElementNumbers::c_BKLM) {
          // FIXED: Use constant instead of hardcoded value
          if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
            h_time_rpc_tc->Fill(timeHit);
          } else {
            h_time_scint_tc->Fill(timeHit);
          }
        } else {
          h_time_scint_tc_end->Fill(timeHit);
        }
      }
    }
 
    m_evts.clear();
    B2INFO("Batch processed and cleared: " << batch.first);
  }
 
  // Compute global means
  m_timeShift.clear();
  double tmpMean_rpc_global = h_time_rpc_tc->GetMean();
  double tmpMean_scint_global = h_time_scint_tc->GetMean();
  double tmpMean_scint_global_end = h_time_scint_tc_end->GetMean();
 
  B2INFO("Global Mean for Raw." << LogVar("RPC", tmpMean_rpc_global)
         << LogVar("Scint BKLM", tmpMean_scint_global)
         << LogVar("Scint EKLM", tmpMean_scint_global_end));
 
  /**********************************
   * SECOND PASS (BATCHED)
   * Compute per-channel time shifts
   **********************************/
  B2INFO("Second pass: Computing per-channel time shifts (batched processing)...");
 
  for (const auto& batch : batches) {
    B2INFO("Processing batch for time shifts: " << batch.first);
    readCalibrationDataBatch(batch.second);
 
    for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
      channelId = klmChannel.getKLMChannelNumber();
 
      if (!batch.second(klmChannel))
        continue;
 
      if (m_cFlag[channelId] == ChannelCalibrationStatus::c_NotEnoughData)
        continue;
 
      if (m_evts.find(channelId) == m_evts.end())
        continue;
 
      eventsChannel = m_evts[channelId];
      int iSub = klmChannel.getSubdetector();
      int iF, iS, iL, iP, iC;
 
      if (iSub == KLMElementNumbers::c_BKLM) {
        iF = klmChannel.getSection();
        iS = klmChannel.getSector() - 1;
        iL = klmChannel.getLayer() - 1;
        iP = klmChannel.getPlane();
        iC = klmChannel.getStrip() - 1;
      } else {
        iF = klmChannel.getSection() - 1;
        iS = klmChannel.getSector() - 1;
        iL = klmChannel.getLayer() - 1;
        iP = klmChannel.getPlane() - 1;
        iC = klmChannel.getStrip() - 1;
      }
 
      // Create and fill temp histogram
      TString hn, ht;
      TH1F* h_temp_tc = nullptr;
 
      if (iSub == KLMElementNumbers::c_BKLM) {
        // FIXED: Use constant instead of hardcoded value
        if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
          hn = Form("h_timeF%d_S%d_L%d_P%d_C%d_tc", iF, iS, iL, iP, iC);
          ht = Form("Time distribution for RPC of Channel%d, %s, Layer%d, Sector%d, %s",
                    iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h_temp_tc = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryRPC, m_UpperTimeBoundaryRPC);
        } else {
          hn = Form("h_timeF%d_S%d_L%d_P%d_C%d_tc", iF, iS, iL, iP, iC);
          ht = Form("time distribution for Scintillator of Channel%d, %s, Layer%d, Sector%d, %s",
                    iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h_temp_tc = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsBKLM,
                               m_UpperTimeBoundaryScintillatorsBKLM);
        }
      } else {
        hn = Form("h_timeF%d_S%d_L%d_P%d_C%d_tc_end", iF, iS, iL, iP, iC);
        ht = Form("Time distribution for Scintillator of Channel%d, %s, Layer%d, Sector%d, %s (Endcap)",
                  iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
        h_temp_tc = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM,
                             m_UpperTimeBoundaryScintillatorsEKLM);
      }
 
      for (const Event& event : eventsChannel) {
        // Add ADC cut
        if (!passesADCCut(event, iSub, iL))
          continue;
 
        double timeHit = event.time();
        if (m_useEventT0)
          timeHit = timeHit - event.t0;
        if (timeHit <= -400e3)
          continue;
        h_temp_tc->Fill(timeHit);
      }
 
      h_temp_tc->Fit(fcn_gaus, "LESQ");
      double tmpMean_channel = fcn_gaus->GetParameter(1);
 
      if (iSub == KLMElementNumbers::c_BKLM) {
        // FIXED: Use constant instead of hardcoded value
        if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
          m_timeShift[channelId] = tmpMean_channel - tmpMean_rpc_global;
        } else {
          m_timeShift[channelId] = tmpMean_channel - tmpMean_scint_global;
        }
      } else {
        m_timeShift[channelId] = tmpMean_channel - tmpMean_scint_global_end;
      }
 
      delete h_temp_tc;
    }
 
    m_evts.clear();
    B2INFO("Batch processed and cleared: " << batch.first);
  }
 
  delete h_time_scint_tc;
  delete h_time_scint_tc_end;
  delete h_time_rpc_tc;
  B2INFO("Effective Light m_timeShift obtained.");
 
  // NOTE: fillTimeDistanceProfiles also needs batching - user will handle separately
  fillTimeDistanceProfiles(
    m_ProfileRpcPhi, m_ProfileRpcZ,
    m_ProfileBKLMScintillatorPhi, m_ProfileBKLMScintillatorZ,
    m_ProfileEKLMScintillatorPlane1, m_ProfileEKLMScintillatorPlane2, false);
 
  B2INFO("Effective light speed fitting.");
 
  // Fit the RPC profiles (for diagnostics), but use fixed values if configured
  m_ProfileRpcPhi->Fit("fcn_pol1", "EMQ");
  double fittedDelayRPCPhi = fcn_pol1->GetParameter(1);
  double e_slope_rpc_phi = fcn_pol1->GetParError(1);
 
  m_ProfileRpcZ->Fit("fcn_pol1", "EMQ");
  double fittedDelayRPCZ = fcn_pol1->GetParameter(1);
  double e_slope_rpc_z = fcn_pol1->GetParError(1);
 
  // Use fixed RPC delay if configured (per BELLE2-NOTE-TE-2021-015: c_eff = 0.5c)
  double delayRPCPhi, delayRPCZ;
  if (m_useFixedRPCDelay) {
    delayRPCPhi = m_fixedRPCDelay;
    delayRPCZ = m_fixedRPCDelay;
    B2INFO("Using fixed RPC propagation delay: " << m_fixedRPCDelay << " ns/cm (c_eff = 0.5c)"
           << LogVar("Fitted phi (not used)", fittedDelayRPCPhi)
           << LogVar("Fitted Z (not used)", fittedDelayRPCZ));
  } else {
    delayRPCPhi = fittedDelayRPCPhi;
    delayRPCZ = fittedDelayRPCZ;
  }
 
  m_ProfileBKLMScintillatorPhi->Fit("fcn_pol1", "EMQ");
  double slope_scint_phi = fcn_pol1->GetParameter(1);
  double e_slope_scint_phi = fcn_pol1->GetParError(1);
 
  m_ProfileBKLMScintillatorZ->Fit("fcn_pol1", "EMQ");
  double slope_scint_z = fcn_pol1->GetParameter(1);
  double e_slope_scint_z = fcn_pol1->GetParError(1);
 
  m_ProfileEKLMScintillatorPlane1->Fit("fcn_pol1", "EMQ");
  double slope_scint_plane1_end = fcn_pol1->GetParameter(1);
  double e_slope_scint_plane1_end = fcn_pol1->GetParError(1);
 
  m_ProfileEKLMScintillatorPlane2->Fit("fcn_pol1", "EMQ");
  double slope_scint_plane2_end = fcn_pol1->GetParameter(1);
  double e_slope_scint_plane2_end = fcn_pol1->GetParError(1);
 
  TString logStr_phi, logStr_z;
  if (m_useFixedRPCDelay) {
    logStr_phi = Form("%.4f ns/cm (fixed)", delayRPCPhi);
    logStr_z = Form("%.4f ns/cm (fixed)", delayRPCZ);
    B2INFO("Delay in RPCs (using fixed value):"
           << LogVar("Used Value (phi readout)", logStr_phi.Data())
           << LogVar("Used Value (z readout)", logStr_z.Data()));
  } else {
    logStr_phi = Form("%.4f +/- %.4f ns/cm", delayRPCPhi, e_slope_rpc_phi);
    logStr_z = Form("%.4f +/- %.4f ns/cm", delayRPCZ, e_slope_rpc_z);
    B2INFO("Delay in RPCs:"
           << LogVar("Fitted Value (phi readout)", logStr_phi.Data())
           << LogVar("Fitted Value (z readout)", logStr_z.Data()));
  }
  logStr_phi = Form("%.4f +/- %.4f ns/cm", slope_scint_phi, e_slope_scint_phi);
  logStr_z = Form("%.4f +/- %.4f ns/cm", slope_scint_z, e_slope_scint_z);
  B2INFO("Delay in BKLM scintillators:"
         << LogVar("Fitted Value (phi readout) ", logStr_phi.Data())
         << LogVar("Fitted Value (z readout) ", logStr_z.Data()));
  logStr_phi = Form("%.4f +/- %.4f ns/cm", slope_scint_plane1_end,
                    e_slope_scint_plane1_end);
  logStr_z = Form("%.4f +/- %.4f ns/cm", slope_scint_plane2_end,
                  e_slope_scint_plane2_end);
  B2INFO("Delay in EKLM scintillators:"
         << LogVar("Fitted Value (plane1 readout) ", logStr_phi.Data())
         << LogVar("Fitted Value (plane2 readout) ", logStr_z.Data()));
 
  logStr_z = Form("%.4f +/- %.4f ns/cm", delayBKLM, delayBKLMError);
  B2INFO("Delay in BKLM scintillators:"
         << LogVar("Fitted Value (2d fit) ", logStr_z.Data()));
  logStr_z = Form("%.4f +/- %.4f ns/cm", delayEKLM, delayEKLMError);
  B2INFO("Delay in EKLM scintillators:"
         << LogVar("Fitted Value (2d fit) ", logStr_z.Data()));
 
  m_timeConstants->setDelay(delayEKLM, KLMTimeConstants::c_EKLM);
  m_timeConstants->setDelay(delayBKLM, KLMTimeConstants::c_BKLM);
  m_timeConstants->setDelay(delayRPCPhi, KLMTimeConstants::c_RPCPhi);
  m_timeConstants->setDelay(delayRPCZ, KLMTimeConstants::c_RPCZ);
 
  /**********************************
   * THIRD LOOP (BATCHED)
   * Fill per-channel distributions and fit
   **********************************/
  B2INFO("Third loop: Time distribution filling (batched processing)...");
 
  for (const auto& batch : batches) {
    B2INFO("Processing batch: " << batch.first);
    readCalibrationDataBatch(batch.second);
 
    for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
      channelId = klmChannel.getKLMChannelNumber();
 
      if (!batch.second(klmChannel))
        continue;
 
      if (m_cFlag[channelId] == ChannelCalibrationStatus::c_NotEnoughData)
        continue;
 
      if (m_evts.find(channelId) == m_evts.end())
        continue;
 
      eventsChannel = m_evts[channelId];
      int iSub = klmChannel.getSubdetector();
      int iF, iS, iL, iP, iC;
 
      if (iSub == KLMElementNumbers::c_BKLM) {
        iF = klmChannel.getSection();
        iS = klmChannel.getSector() - 1;
        iL = klmChannel.getLayer() - 1;
        iP = klmChannel.getPlane();
        iC = klmChannel.getStrip() - 1;
      } else {
        iF = klmChannel.getSection() - 1;
        iS = klmChannel.getSector() - 1;
        iL = klmChannel.getLayer() - 1;
        iP = klmChannel.getPlane() - 1;
        iC = klmChannel.getStrip() - 1;
      }
 
      // Create per-channel histogram
      TString hn, ht;
      TH1F* h_temp = nullptr;
 
      if (iSub == KLMElementNumbers::c_BKLM) {
        // FIXED: Use constant instead of hardcoded value
        if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
          hn = Form("h_timeF%d_S%d_L%d_P%d_C%d", iF, iS, iL, iP, iC);
          ht = Form("Time distribution for RPC of Channel%d, %s, Layer%d, Sector%d, %s",
                    iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h_temp = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryRPC, m_UpperTimeBoundaryRPC);
        } else {
          hn = Form("h_timeF%d_S%d_L%d_P%d_C%d", iF, iS, iL, iP, iC);
          ht = Form("time distribution for Scintillator of Channel%d, %s, Layer%d, Sector%d, %s",
                    iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h_temp = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsBKLM,
                            m_UpperTimeBoundaryScintillatorsBKLM);
        }
      } else {
        hn = Form("h_timeF%d_S%d_L%d_P%d_C%d_end", iF, iS, iL, iP, iC);
        ht = Form("Time distribution for Scintillator of Channel%d, %s, Layer%d, Sector%d, %s (Endcap)",
                  iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
        h_temp = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM,
                          m_UpperTimeBoundaryScintillatorsEKLM);
      }
 
      // Fill histogram
      for (const Event& event : eventsChannel) {
        // Add ADC cut
        if (!passesADCCut(event, iSub, iL))
          continue;
 
        double timeHit = event.time();
        if (m_useEventT0)
          timeHit = timeHit - event.t0;
        if (timeHit <= -400e3)
          continue;
 
        if (iSub == KLMElementNumbers::c_BKLM) {
          // FIXED: Use constant instead of hardcoded value
          if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
            double propgationT;
            if (iP == BKLMElementNumbers::c_ZPlane)
              propgationT = event.dist * delayRPCZ;
            else
              propgationT = event.dist * delayRPCPhi;
            double time = timeHit - propgationT;
 
            h_time_rpc->Fill(time);
            h_temp->Fill(time);
 
            if (m_saveAllPlots) {
              h_timeF_rpc[iF]->Fill(time);
              h_timeFS_rpc[iF][iS]->Fill(time);
              h_timeFSL[iF][iS][iL]->Fill(time);
              h_timeFSLP[iF][iS][iL][iP]->Fill(time);
              h2_timeF_rpc[iF]->Fill(iS, time);
              h2_timeFS[iF][iS]->Fill(iL, time);
              h2_timeFSLP[iF][iS][iL][iP]->Fill(iC, time);
            }
          } else {
            double propgationT = event.dist * delayBKLM;
            double time = timeHit - propgationT;
 
            h_time_scint->Fill(time);
            h_temp->Fill(time);
 
            if (m_saveAllPlots) {
              h_timeF_scint[iF]->Fill(time);
              h_timeFS_scint[iF][iS]->Fill(time);
              h_timeFSL[iF][iS][iL]->Fill(time);
              h_timeFSLP[iF][iS][iL][iP]->Fill(time);
              h2_timeF_scint[iF]->Fill(iS, time);
              h2_timeFS[iF][iS]->Fill(iL, time);
              h2_timeFSLP[iF][iS][iL][iP]->Fill(iC, time);
            }
          }
        } else {
          double propgationT = event.dist * delayEKLM;
          double time = timeHit - propgationT;
 
          h_time_scint_end->Fill(time);
          h_temp->Fill(time);
 
          if (m_saveAllPlots) {
            h_timeF_scint_end[iF]->Fill(time);
            h_timeFS_scint_end[iF][iS]->Fill(time);
            h_timeFSL_end[iF][iS][iL]->Fill(time);
            h_timeFSLP_end[iF][iS][iL][iP]->Fill(time);
            h2_timeF_scint_end[iF]->Fill(iS, time);
            h2_timeFS_end[iF][iS]->Fill(iL, time);
            h2_timeFSLP_end[iF][iS][iL][iP]->Fill(iC, time);
          }
        }
      }
 
      TFitResultPtr r = h_temp->Fit(fcn_gaus, "LESQ");
      if (int(r) == 0) {
        m_cFlag[channelId] = ChannelCalibrationStatus::c_SuccessfulCalibration;
        m_time_channel[channelId] = fcn_gaus->GetParameter(1);
        m_etime_channel[channelId] = fcn_gaus->GetParError(1);
      }
 
      // Get the appropriate directory for this channel
      TDirectory* dir = (iSub == KLMElementNumbers::c_BKLM) ?
                        m_channelHistDir_BKLM[iF][iS][iL][iP] :
                        m_channelHistDir_EKLM[iF][iS][iL][iP];
      writeThenDelete_(h_temp, m_saveChannelHists, dir);
    }
 
    m_evts.clear();
    B2INFO("Batch processed and cleared: " << batch.first);
  }
 
  B2INFO("Original filling done.");
 
  // Fill TGraphs with extracted parameters
  int iChannel_rpc = 0;
  int iChannel = 0;
  int iChannel_end = 0;
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    if (m_cFlag[channelId] != ChannelCalibrationStatus::c_SuccessfulCalibration)
      continue;
 
    int iSub = klmChannel.getSubdetector();
    if (iSub == KLMElementNumbers::c_BKLM) {
      int iL = klmChannel.getLayer() - 1;
      // FIXED: Use constant instead of hardcoded value
      if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
        gre_time_channel_rpc->SetPoint(iChannel_rpc, channelId, m_time_channel[channelId]);
        gre_time_channel_rpc->SetPointError(iChannel_rpc, 0., m_etime_channel[channelId]);
        iChannel_rpc++;
      } else {
        gre_time_channel_scint->SetPoint(iChannel, channelId, m_time_channel[channelId]);
        gre_time_channel_scint->SetPointError(iChannel, 0., m_etime_channel[channelId]);
        iChannel++;
      }
    } else {
      gre_time_channel_scint_end->SetPoint(iChannel_end, channelId, m_time_channel[channelId]);
      gre_time_channel_scint_end->SetPointError(iChannel_end, 0., m_etime_channel[channelId]);
      iChannel_end++;
    }
  }
 
  gre_time_channel_scint->Fit("fcn_const", "EMQ");
  m_time_channelAvg_scint = fcn_const->GetParameter(0);
  m_etime_channelAvg_scint = fcn_const->GetParError(0);
 
  gre_time_channel_scint_end->Fit("fcn_const", "EMQ");
  m_time_channelAvg_scint_end = fcn_const->GetParameter(0);
  m_etime_channelAvg_scint_end = fcn_const->GetParError(0);
 
  gre_time_channel_rpc->Fit("fcn_const", "EMQ");
  m_time_channelAvg_rpc = fcn_const->GetParameter(0);
  m_etime_channelAvg_rpc = fcn_const->GetParError(0);
 
  B2INFO("Channel's time distribution fitting done.");
  B2DEBUG(20, LogVar("Average time (RPC)", m_time_channelAvg_rpc)
          << LogVar("Average time (BKLM scintillators)", m_time_channelAvg_scint)
          << LogVar("Average time (EKLM scintillators)", m_time_channelAvg_scint_end));
 
  B2INFO("Calibrated channel's time distribution filling begins.");
 
  m_timeShift.clear();
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    h_calibrated->Fill(m_cFlag[channelId]);
    if (m_time_channel.find(channelId) == m_time_channel.end())
      continue;
    double timeShift = m_time_channel[channelId];
    m_timeShift[channelId] = timeShift;
    m_timeCableDelay->setTimeDelay(channelId, m_timeShift[channelId]);
  }
 
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    if (m_timeShift.find(channelId) != m_timeShift.end())
      continue;
    m_timeShift[channelId] = esti_timeShift(klmChannel);
    m_timeCableDelay->setTimeDelay(channelId, m_timeShift[channelId]);
    B2DEBUG(20, "Uncalibrated Estimation " << LogVar("Channel", channelId) << LogVar("Estimated value", m_timeShift[channelId]));
  }
 
  iChannel_rpc = 0;
  iChannel = 0;
  iChannel_end = 0;
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    if (m_timeShift.find(channelId) == m_timeShift.end()) {
      B2ERROR("!!! Not All Channels Calibration Constant Set. Error Happened on " << LogVar("Channel", channelId));
      continue;
    }
    int iSub = klmChannel.getSubdetector();
    if (iSub == KLMElementNumbers::c_BKLM) {
      // FIXED: Use 0-indexed layer and constant
      int iL = klmChannel.getLayer() - 1;
      if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
        gr_timeShift_channel_rpc->SetPoint(iChannel_rpc, channelId, m_timeShift[channelId]);
        iChannel_rpc++;
      } else {
        gr_timeShift_channel_scint->SetPoint(iChannel, channelId, m_timeShift[channelId]);
        iChannel++;
      }
    } else {
      gr_timeShift_channel_scint_end->SetPoint(iChannel_end, channelId, m_timeShift[channelId]);
      iChannel_end++;
    }
  }
 
  // NOTE: This also needs batching
  fillTimeDistanceProfiles(
    m_Profile2RpcPhi, m_Profile2RpcZ,
    m_Profile2BKLMScintillatorPhi, m_Profile2BKLMScintillatorZ,
    m_Profile2EKLMScintillatorPlane1,  m_Profile2EKLMScintillatorPlane2, true);
 
  /**********************************
   * FOURTH LOOP (BATCHED)
   * Fill calibrated per-channel histograms
   **********************************/
  B2INFO("Fourth loop: Calibrated time distribution filling (batched processing)...");
 
  for (const auto& batch : batches) {
    B2INFO("Processing batch: " << batch.first);
    readCalibrationDataBatch(batch.second);
 
    for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
      channelId = klmChannel.getKLMChannelNumber();
 
      if (!batch.second(klmChannel))
        continue;
 
      if (m_evts.find(channelId) == m_evts.end())
        continue;
 
      eventsChannel = m_evts[channelId];
      int iSub = klmChannel.getSubdetector();
      int iF, iS, iL, iP, iC;
 
      if (iSub == KLMElementNumbers::c_BKLM) {
        iF = klmChannel.getSection();
        iS = klmChannel.getSector() - 1;
        iL = klmChannel.getLayer() - 1;
        iP = klmChannel.getPlane();
        iC = klmChannel.getStrip() - 1;
      } else {
        iF = klmChannel.getSection() - 1;
        iS = klmChannel.getSector() - 1;
        iL = klmChannel.getLayer() - 1;
        iP = klmChannel.getPlane() - 1;
        iC = klmChannel.getStrip() - 1;
      }
 
      TString hn, ht;
      TH1F* hc_temp = nullptr;
 
      if (iSub == KLMElementNumbers::c_BKLM) {
        // FIXED: Use constant instead of hardcoded value
        if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
          hn = Form("hc_timeF%d_S%d_L%d_P%d_C%d", iF, iS, iL, iP, iC);
          ht = Form("Calibrated time distribution for RPC of Channel%d, %s, Layer%d, Sector%d, %s",
                    iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          hc_temp = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryCalibratedRPC,
                             m_UpperTimeBoundaryCalibratedRPC);
        } else {
          hn = Form("hc_timeF%d_S%d_L%d_P%d_C%d", iF, iS, iL, iP, iC);
          ht = Form("Calibrated time distribution for Scintillator of Channel%d, %s, Layer%d, Sector%d, %s",
                    iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          hc_temp = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsBKLM,
                             m_UpperTimeBoundaryCalibratedScintillatorsBKLM);
        }
      } else {
        hn = Form("hc_timeF%d_S%d_L%d_P%d_C%d_end", iF, iS, iL, iP, iC);
        ht = Form("Calibrated time distribution for Scintillator of Channel%d, %s, Layer%d, Sector%d, %s (Endcap)",
                  iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
        hc_temp = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsEKLM,
                           m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
      }
 
      for (const Event& event : eventsChannel) {
        // Add ADC cut
        if (!passesADCCut(event, iSub, iL))
          continue;
 
        double timeHit = event.time();
        if (m_useEventT0)
          timeHit = timeHit - event.t0;
        if (timeHit <= -400e3)
          continue;
 
        if (iSub == KLMElementNumbers::c_BKLM) {
          // FIXED: Use constant instead of hardcoded value
          if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
            double propgationT;
            if (iP == BKLMElementNumbers::c_ZPlane)
              propgationT = event.dist * delayRPCZ;
            else
              propgationT = event.dist * delayRPCPhi;
            double time = timeHit - propgationT - m_timeShift[channelId];
 
            hc_time_rpc->Fill(time);
            hc_temp->Fill(time);
 
            if (m_saveAllPlots) {
              hc_timeF_rpc[iF]->Fill(time);
              hc_timeFS_rpc[iF][iS]->Fill(time);
              hc_timeFSL[iF][iS][iL]->Fill(time);
              hc_timeFSLP[iF][iS][iL][iP]->Fill(time);
              h2c_timeF_rpc[iF]->Fill(iS, time);
              h2c_timeFS[iF][iS]->Fill(iL, time);
              h2c_timeFSLP[iF][iS][iL][iP]->Fill(iC, time);
            }
          } else {
            double propgationT = event.dist * delayBKLM;
            double time = timeHit - propgationT - m_timeShift[channelId];
 
            hc_time_scint->Fill(time);
            hc_temp->Fill(time);
 
            if (m_saveAllPlots) {
              hc_timeF_scint[iF]->Fill(time);
              hc_timeFS_scint[iF][iS]->Fill(time);
              hc_timeFSL[iF][iS][iL]->Fill(time);
              hc_timeFSLP[iF][iS][iL][iP]->Fill(time);
              h2c_timeF_scint[iF]->Fill(iS, time);
              h2c_timeFS[iF][iS]->Fill(iL, time);
              h2c_timeFSLP[iF][iS][iL][iP]->Fill(iC, time);
            }
          }
        } else {
          double propgationT = event.dist * delayEKLM;
          double time = timeHit - propgationT - m_timeShift[channelId];
 
          hc_time_scint_end->Fill(time);
          hc_temp->Fill(time);
 
          if (m_saveAllPlots) {
            hc_timeF_scint_end[iF]->Fill(time);
            hc_timeFS_scint_end[iF][iS]->Fill(time);
            hc_timeFSL_end[iF][iS][iL]->Fill(time);
            hc_timeFSLP_end[iF][iS][iL][iP]->Fill(time);
            h2c_timeF_scint_end[iF]->Fill(iS, time);
            h2c_timeFS_end[iF][iS]->Fill(iL, time);
            h2c_timeFSLP_end[iF][iS][iL][iP]->Fill(iC, time);
          }
        }
      }
 
      if (m_cFlag[channelId] == ChannelCalibrationStatus::c_NotEnoughData) {
        delete hc_temp;
        continue;
      }
 
      TFitResultPtr rc = hc_temp->Fit(fcn_gaus, "LESQ");
      if (int(rc) == 0) {
        m_cFlag[channelId] = ChannelCalibrationStatus::c_SuccessfulCalibration;
        m_ctime_channel[channelId] = fcn_gaus->GetParameter(1);
        mc_etime_channel[channelId] = fcn_gaus->GetParError(1);
      }
 
      // Get the appropriate directory for this channel
      TDirectory* dir = (iSub == KLMElementNumbers::c_BKLM) ?
                        m_channelHistDir_BKLM[iF][iS][iL][iP] :
                        m_channelHistDir_EKLM[iF][iS][iL][iP];
      writeThenDelete_(hc_temp, m_saveChannelHists, dir);
    }
 
    m_evts.clear();
    B2INFO("Batch processed and cleared: " << batch.first);
  }
 
  // Fill TGraphs with calibrated parameters
  int icChannel_rpc = 0;
  int icChannel = 0;
  int icChannel_end = 0;
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    if (m_cFlag[channelId] != ChannelCalibrationStatus::c_SuccessfulCalibration)
      continue;
 
    int iSub = klmChannel.getSubdetector();
    if (iSub == KLMElementNumbers::c_BKLM) {
      int iL = klmChannel.getLayer() - 1;
      // FIXED: Use constant instead of hardcoded value
      if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
        gre_ctime_channel_rpc->SetPoint(icChannel_rpc, channelId, m_ctime_channel[channelId]);
        gre_ctime_channel_rpc->SetPointError(icChannel_rpc, 0., mc_etime_channel[channelId]);
        icChannel_rpc++;
      } else {
        gre_ctime_channel_scint->SetPoint(icChannel, channelId, m_ctime_channel[channelId]);
        gre_ctime_channel_scint->SetPointError(icChannel, 0., mc_etime_channel[channelId]);
        icChannel++;
      }
    } else {
      gre_ctime_channel_scint_end->SetPoint(icChannel_end, channelId, m_ctime_channel[channelId]);
      gre_ctime_channel_scint_end->SetPointError(icChannel_end, 0., mc_etime_channel[channelId]);
      icChannel_end++;
    }
  }
 
  gre_ctime_channel_scint->Fit("fcn_const", "EMQ");
  m_ctime_channelAvg_scint = fcn_const->GetParameter(0);
  mc_etime_channelAvg_scint = fcn_const->GetParError(0);
 
  gre_ctime_channel_scint_end->Fit("fcn_const", "EMQ");
  m_ctime_channelAvg_scint_end = fcn_const->GetParameter(0);
  mc_etime_channelAvg_scint_end = fcn_const->GetParError(0);
 
  gre_ctime_channel_rpc->Fit("fcn_const", "EMQ");
  m_ctime_channelAvg_rpc = fcn_const->GetParameter(0);
  mc_etime_channelAvg_rpc = fcn_const->GetParError(0);
 
  B2INFO("Channel's time distribution fitting done.");
  B2DEBUG(20, LogVar("Average calibrated time (RPC)", m_ctime_channelAvg_rpc)
          << LogVar("Average calibrated time (BKLM scintillators)", m_ctime_channelAvg_scint)
          << LogVar("Average calibrated time (EKLM scintillators)", m_ctime_channelAvg_scint_end));
 
  B2INFO("Calibrated channel's time distribution filling begins.");
 
  m_timeRes.clear();
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    hc_calibrated->Fill(m_cFlag[channelId]);
    if (m_ctime_channel.find(channelId) == m_ctime_channel.end())
      continue;
    double timeRes = m_ctime_channel[channelId];
    m_timeRes[channelId] = timeRes;
    m_timeResolution->setTimeResolution(channelId, m_timeRes[channelId]);
  }
 
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    if (m_timeRes.find(channelId) != m_timeRes.end())
      continue;
    m_timeRes[channelId] = esti_timeRes(klmChannel);
    m_timeResolution->setTimeResolution(channelId, m_timeRes[channelId]);
    B2DEBUG(20, "Calibrated Estimation " << LogVar("Channel", channelId) << LogVar("Estimated value", m_timeRes[channelId]));
  }
 
  icChannel_rpc = 0;
  icChannel = 0;
  icChannel_end = 0;
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    if (m_timeRes.find(channelId) == m_timeRes.end()) {
      B2ERROR("!!! Not All Channels Calibration Constant Set. Error Happened on " << LogVar("Channel", channelId));
      continue;
    }
    int iSub = klmChannel.getSubdetector();
    if (iSub == KLMElementNumbers::c_BKLM) {
      // FIXED: Use 0-indexed layer and constant
      int iL = klmChannel.getLayer() - 1;
      if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
        gr_timeRes_channel_rpc->SetPoint(icChannel_rpc, channelId, m_timeRes[channelId]);
        icChannel_rpc++;
      } else {
        gr_timeRes_channel_scint->SetPoint(icChannel, channelId, m_timeRes[channelId]);
        icChannel++;
      }
    } else {
      gr_timeRes_channel_scint_end->SetPoint(icChannel_end, channelId, m_timeRes[channelId]);
      icChannel_end++;
    }
  }
 
  // ===================================================================
  // FIFTH PASS: Di-muon EventT0 analysis for hit resolution calibration
  // ===================================================================
  B2INFO("Fifth pass: Computing di-muon ΔT0 for EventT0 hit resolution calibration...");
 
  // Data structure for per-track T0 accumulation
  struct TrackT0Info {
    int charge;
    int nHits_BKLM_Scint;
    int nHits_BKLM_RPC_Phi;  // Split RPC by readout direction
    int nHits_BKLM_RPC_Z;
    int nHits_EKLM_Scint;
    double sumT0_BKLM_Scint;
    double sumT0_BKLM_RPC_Phi;
    double sumT0_BKLM_RPC_Z;
    double sumT0_EKLM_Scint;
 
    TrackT0Info() : charge(0),
      nHits_BKLM_Scint(0),
      nHits_BKLM_RPC_Phi(0),
      nHits_BKLM_RPC_Z(0),
      nHits_EKLM_Scint(0),
      sumT0_BKLM_Scint(0.0),
      sumT0_BKLM_RPC_Phi(0.0),
      sumT0_BKLM_RPC_Z(0.0),
      sumT0_EKLM_Scint(0.0) {}
  };
 
  // Map: (Run, Event) -> (nTrack -> TrackT0Info)
  std::map<std::pair<int, int>, std::map<int, TrackT0Info>> eventTrackMap;
 
  // Process all data in batches to build event-track map
  for (const auto& batch : batches) {
    B2INFO("Processing batch for di-muon analysis: " << batch.first);
    readCalibrationDataBatch(batch.second);
 
    for (const auto& channelPair : m_evts) {
      KLMChannelNumber chId = channelPair.first;
      const std::vector<Event>& chEvents = channelPair.second;
 
      // Get channel geometry
      int subdetector, section, sector, layer, plane, strip;
      m_ElementNumbers->channelNumberToElementNumbers(
        chId, &subdetector, &section, &sector, &layer, &plane, &strip);
 
      // Convert to 0-indexed immediately (consistent with loops 1-4)
      int iSub = subdetector;
      int iL = layer - 1;
 
      for (const Event& event : chEvents) {
        // Apply ADC cut with 0-indexed layer
        if (!passesADCCut(event, iSub, iL))
          continue;
 
        // Event and track identification
        std::pair<int, int> eventKey(event.Run, event.Events);
        int trackIdx = event.nTrack;
        int charge = event.Track_Charge;
 
        // Compute calibrated time for this hit
        double timeHit = event.time() - m_timeShift[chId];
 
        if (timeHit <= -400e3)
          continue;
 
        // Apply propagation correction (using 0-indexed layer)
        double propT = 0.0;
        if (iSub == KLMElementNumbers::c_BKLM) {
          if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
            // RPC
            if (plane == BKLMElementNumbers::c_ZPlane)
              propT = event.dist * delayRPCZ;
            else
              propT = event.dist * delayRPCPhi;
          } else {
            // Scintillator
            propT = event.dist * delayBKLM;
          }
        } else {
          // EKLM
          propT = event.dist * delayEKLM;
        }
 
        double t0_estimate = timeHit - propT;
 
        // Accumulate per-track T0
        TrackT0Info& trackInfo = eventTrackMap[eventKey][trackIdx];
        trackInfo.charge = charge;
 
        if (iSub == KLMElementNumbers::c_BKLM) {
          if (iL >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
            // RPC - split by readout direction
            if (plane == BKLMElementNumbers::c_ZPlane) {
              trackInfo.nHits_BKLM_RPC_Z++;
              trackInfo.sumT0_BKLM_RPC_Z += t0_estimate;
            } else {
              trackInfo.nHits_BKLM_RPC_Phi++;
              trackInfo.sumT0_BKLM_RPC_Phi += t0_estimate;
            }
          } else {
            // Scintillator
            trackInfo.nHits_BKLM_Scint++;
            trackInfo.sumT0_BKLM_Scint += t0_estimate;
          }
        } else {
          trackInfo.nHits_EKLM_Scint++;
          trackInfo.sumT0_EKLM_Scint += t0_estimate;
        }
      }
    }
 
    m_evts.clear();
  }
 
  B2INFO("Event-track map built. Processing events for EventT0 histograms...");
 
  // Accumulators for variance calculation using the Gaussian MLE
  // Model: ΔT0_i ~ N(0, σ_hit^2 * v_i),  v_i = 1/N⁺_i + 1/N⁻_i
  double sum_delta2_over_v_BKLM_Scint   = 0.0;
  double sum_delta2_over_v_BKLM_RPC_Phi = 0.0;
  double sum_delta2_over_v_BKLM_RPC_Z   = 0.0;
  double sum_delta2_over_v_EKLM_Scint   = 0.0;
 
  int nDimuon_BKLM_Scint   = 0;
  int nDimuon_BKLM_RPC_Phi = 0;
  int nDimuon_BKLM_RPC_Z   = 0;
  int nDimuon_EKLM_Scint   = 0;
 
  for (const auto& eventPair : eventTrackMap) {
    const auto& trackMap = eventPair.second;
 
    // Check if exactly 2 tracks (di-muon candidate)
    if (trackMap.size() != 2)
      continue;
 
    auto it1 = trackMap.begin();
    auto it2 = trackMap.begin();
    ++it2;
    const TrackT0Info& track1 = it1->second;
    const TrackT0Info& track2 = it2->second;
 
    // Check opposite charges
    if (track1.charge * track2.charge >= 0)
      continue;
 
    // Identify mu+ and mu-
    const TrackT0Info& muPlus  = (track1.charge > 0) ? track1 : track2;
    const TrackT0Info& muMinus = (track1.charge > 0) ? track2 : track1;
 
    // === BKLM Scintillator ===
    if (muPlus.nHits_BKLM_Scint > 0 && muMinus.nHits_BKLM_Scint > 0) {
      double t0_plus  = muPlus.sumT0_BKLM_Scint  / muPlus.nHits_BKLM_Scint;
      double t0_minus = muMinus.sumT0_BKLM_Scint / muMinus.nHits_BKLM_Scint;
      double deltaT0  = t0_plus - t0_minus;
 
      // v = 1/N⁺ + 1/N⁻ for this event
      double v = 1.0 / muPlus.nHits_BKLM_Scint + 1.0 / muMinus.nHits_BKLM_Scint;
      int nTotal = muPlus.nHits_BKLM_Scint + muMinus.nHits_BKLM_Scint;
 
      if (v <= 0.0)
        continue;
 
      // Accumulate for σ_hit^2 = (1/N_evt) Σ [ ΔT0^2 / v ]
      sum_delta2_over_v_BKLM_Scint += (deltaT0 * deltaT0) / v;
      nDimuon_BKLM_Scint++;
 
      // Histograms for monitoring
      h_eventT0_scint->Fill(t0_plus);
      h_eventT0_scint->Fill(t0_minus);
      hc_eventT0_scint->Fill(deltaT0);
 
      // ==== NEW DIAGNOSTIC FILLS ====
      h_nHits_plus_scint->Fill(muPlus.nHits_BKLM_Scint);
      h_nHits_minus_scint->Fill(muMinus.nHits_BKLM_Scint);
      h2_deltaT0_vs_v_scint->Fill(v, deltaT0);
      prof_deltaT0_rms_vs_v_scint->Fill(v, deltaT0);
      h2_deltaT0_vs_nhits_scint->Fill(nTotal, deltaT0);
 
      // Fill multiplicity-binned histograms
      if (nTotal < 5) {
        hc_eventT0_scint_lowN->Fill(deltaT0);
      } else if (nTotal < 15) {
        hc_eventT0_scint_midN->Fill(deltaT0);
      } else {
        hc_eventT0_scint_highN->Fill(deltaT0);
      }
    }
 
    // === BKLM RPC Phi ===
    if (muPlus.nHits_BKLM_RPC_Phi > 0 && muMinus.nHits_BKLM_RPC_Phi > 0) {
      double t0_plus  = muPlus.sumT0_BKLM_RPC_Phi  / muPlus.nHits_BKLM_RPC_Phi;
      double t0_minus = muMinus.sumT0_BKLM_RPC_Phi / muMinus.nHits_BKLM_RPC_Phi;
      double deltaT0  = t0_plus - t0_minus;
 
      double v = 1.0 / muPlus.nHits_BKLM_RPC_Phi + 1.0 / muMinus.nHits_BKLM_RPC_Phi;
      int nTotal = muPlus.nHits_BKLM_RPC_Phi + muMinus.nHits_BKLM_RPC_Phi;
 
      if (v <= 0.0)
        continue;
 
      sum_delta2_over_v_BKLM_RPC_Phi += (deltaT0 * deltaT0) / v;
      nDimuon_BKLM_RPC_Phi++;
 
      h_eventT0_rpc->Fill(t0_plus);
      h_eventT0_rpc->Fill(t0_minus);
      hc_eventT0_rpc->Fill(deltaT0);
 
      // Diagnostic fills
      h_nHits_plus_rpc->Fill(muPlus.nHits_BKLM_RPC_Phi);
      h_nHits_minus_rpc->Fill(muMinus.nHits_BKLM_RPC_Phi);
      h2_deltaT0_vs_v_rpc->Fill(v, deltaT0);
      prof_deltaT0_rms_vs_v_rpc->Fill(v, deltaT0);
      h2_deltaT0_vs_nhits_rpc->Fill(nTotal, deltaT0);
 
      if (nTotal < 10) {
        hc_eventT0_rpc_lowN->Fill(deltaT0);
      } else if (nTotal < 30) {
        hc_eventT0_rpc_midN->Fill(deltaT0);
      } else {
        hc_eventT0_rpc_highN->Fill(deltaT0);
      }
    }
 
    // === BKLM RPC Z ===
    if (muPlus.nHits_BKLM_RPC_Z > 0 && muMinus.nHits_BKLM_RPC_Z > 0) {
      double t0_plus  = muPlus.sumT0_BKLM_RPC_Z  / muPlus.nHits_BKLM_RPC_Z;
      double t0_minus = muMinus.sumT0_BKLM_RPC_Z / muMinus.nHits_BKLM_RPC_Z;
      double deltaT0  = t0_plus - t0_minus;
 
      double v = 1.0 / muPlus.nHits_BKLM_RPC_Z + 1.0 / muMinus.nHits_BKLM_RPC_Z;
      int nTotal = muPlus.nHits_BKLM_RPC_Z + muMinus.nHits_BKLM_RPC_Z;
 
      if (v <= 0.0)
        continue;
 
      sum_delta2_over_v_BKLM_RPC_Z += (deltaT0 * deltaT0) / v;
      nDimuon_BKLM_RPC_Z++;
 
      h_eventT0_rpc->Fill(t0_plus);
      h_eventT0_rpc->Fill(t0_minus);
      hc_eventT0_rpc->Fill(deltaT0);
 
      // Diagnostic fills
      h_nHits_plus_rpc->Fill(muPlus.nHits_BKLM_RPC_Z);
      h_nHits_minus_rpc->Fill(muMinus.nHits_BKLM_RPC_Z);
      h2_deltaT0_vs_v_rpc->Fill(v, deltaT0);
      prof_deltaT0_rms_vs_v_rpc->Fill(v, deltaT0);
      h2_deltaT0_vs_nhits_rpc->Fill(nTotal, deltaT0);
 
      if (nTotal < 10) {
        hc_eventT0_rpc_lowN->Fill(deltaT0);
      } else if (nTotal < 30) {
        hc_eventT0_rpc_midN->Fill(deltaT0);
      } else {
        hc_eventT0_rpc_highN->Fill(deltaT0);
      }
    }
 
    // === EKLM Scintillator ===
    if (muPlus.nHits_EKLM_Scint > 0 && muMinus.nHits_EKLM_Scint > 0) {
      double t0_plus  = muPlus.sumT0_EKLM_Scint  / muPlus.nHits_EKLM_Scint;
      double t0_minus = muMinus.sumT0_EKLM_Scint / muMinus.nHits_EKLM_Scint;
      double deltaT0  = t0_plus - t0_minus;
 
      double v = 1.0 / muPlus.nHits_EKLM_Scint + 1.0 / muMinus.nHits_EKLM_Scint;
      int nTotal = muPlus.nHits_EKLM_Scint + muMinus.nHits_EKLM_Scint;
 
      if (v <= 0.0)
        continue;
 
      sum_delta2_over_v_EKLM_Scint += (deltaT0 * deltaT0) / v;
      nDimuon_EKLM_Scint++;
 
      h_eventT0_scint_end->Fill(t0_plus);
      h_eventT0_scint_end->Fill(t0_minus);
      hc_eventT0_scint_end->Fill(deltaT0);
 
      // ==== NEW DIAGNOSTIC FILLS ====
      h_nHits_plus_scint_end->Fill(muPlus.nHits_EKLM_Scint);
      h_nHits_minus_scint_end->Fill(muMinus.nHits_EKLM_Scint);
      h2_deltaT0_vs_v_scint_end->Fill(v, deltaT0);
      prof_deltaT0_rms_vs_v_scint_end->Fill(v, deltaT0);
      h2_deltaT0_vs_nhits_scint_end->Fill(nTotal, deltaT0);
 
      // Fill multiplicity-binned histograms
      if (nTotal < 5) {
        hc_eventT0_scint_end_lowN->Fill(deltaT0);
      } else if (nTotal < 15) {
        hc_eventT0_scint_end_midN->Fill(deltaT0);
      } else {
        hc_eventT0_scint_end_highN->Fill(deltaT0);
      }
    }
  }
 
  B2INFO("Di-muon ΔT0 data collected."
         << LogVar("BKLM Scint di-muon events", nDimuon_BKLM_Scint)
         << LogVar("BKLM RPC Phi di-muon events", nDimuon_BKLM_RPC_Phi)
         << LogVar("BKLM RPC Z di-muon events", nDimuon_BKLM_RPC_Z)
         << LogVar("EKLM Scint di-muon events", nDimuon_EKLM_Scint));
 
  // === Extract σ_hit using the Gaussian MLE ===
  // σ_hit^2 = (1 / N_evt) Σ_i [ ΔT0_i^2 / (1/N⁺_i + 1/N⁻_i) ]
 
  float sigma_BKLM_Scint     = 10.0f;  // Default fallback
  float sigma_BKLM_Scint_err = 1.0f;
  if (nDimuon_BKLM_Scint > 0) {
    double sigma2 = sum_delta2_over_v_BKLM_Scint / static_cast<double>(nDimuon_BKLM_Scint);
    sigma_BKLM_Scint = static_cast<float>(std::sqrt(sigma2));
    // Uncertainty approximation (Gaussian statistics)
    sigma_BKLM_Scint_err = sigma_BKLM_Scint / std::sqrt(2.0 * nDimuon_BKLM_Scint);
  }
 
  float sigma_RPC_Phi     = 10.0f;
  float sigma_RPC_Phi_err = 1.0f;
  if (nDimuon_BKLM_RPC_Phi > 0) {
    double sigma2 = sum_delta2_over_v_BKLM_RPC_Phi / static_cast<double>(nDimuon_BKLM_RPC_Phi);
    sigma_RPC_Phi = static_cast<float>(std::sqrt(sigma2));
    sigma_RPC_Phi_err = sigma_RPC_Phi / std::sqrt(2.0 * nDimuon_BKLM_RPC_Phi);
  }
 
  float sigma_RPC_Z     = 10.0f;
  float sigma_RPC_Z_err = 1.0f;
  if (nDimuon_BKLM_RPC_Z > 0) {
    double sigma2 = sum_delta2_over_v_BKLM_RPC_Z / static_cast<double>(nDimuon_BKLM_RPC_Z);
    sigma_RPC_Z = static_cast<float>(std::sqrt(sigma2));
    sigma_RPC_Z_err = sigma_RPC_Z / std::sqrt(2.0 * nDimuon_BKLM_RPC_Z);
  }
 
  // Compute combined RPC sigma (weighted average by number of events)
  float sigma_RPC     = 10.0f;
  float sigma_RPC_err = 1.0f;
  int nDimuon_RPC_total = nDimuon_BKLM_RPC_Phi + nDimuon_BKLM_RPC_Z;
  if (nDimuon_RPC_total > 0) {
    // Weighted average by statistics
    double w_phi = static_cast<double>(nDimuon_BKLM_RPC_Phi) / nDimuon_RPC_total;
    double w_z   = static_cast<double>(nDimuon_BKLM_RPC_Z) / nDimuon_RPC_total;
    sigma_RPC = w_phi * sigma_RPC_Phi + w_z * sigma_RPC_Z;
    // Propagate uncertainties
    sigma_RPC_err = std::sqrt(w_phi * w_phi * sigma_RPC_Phi_err * sigma_RPC_Phi_err +
                              w_z * w_z * sigma_RPC_Z_err * sigma_RPC_Z_err);
  }
 
  float sigma_EKLM_Scint     = 10.0f;
  float sigma_EKLM_Scint_err = 1.0f;
  if (nDimuon_EKLM_Scint > 0) {
    double sigma2 = sum_delta2_over_v_EKLM_Scint / static_cast<double>(nDimuon_EKLM_Scint);
    sigma_EKLM_Scint = static_cast<float>(std::sqrt(sigma2));
    sigma_EKLM_Scint_err = sigma_EKLM_Scint / std::sqrt(2.0 * nDimuon_EKLM_Scint);
  }
 
  B2INFO("Extracted per-hit resolutions using event-by-event weighting:"
         << LogVar("σ_BKLM_Scint [ns]", sigma_BKLM_Scint) << LogVar("±", sigma_BKLM_Scint_err)
         << LogVar("σ_RPC_Phi [ns]", sigma_RPC_Phi) << LogVar("±", sigma_RPC_Phi_err)
         << LogVar("σ_RPC_Z [ns]", sigma_RPC_Z) << LogVar("±", sigma_RPC_Z_err)
         << LogVar("σ_RPC_combined [ns]", sigma_RPC) << LogVar("±", sigma_RPC_err)
         << LogVar("σ_EKLM_Scint [ns]", sigma_EKLM_Scint) << LogVar("±", sigma_EKLM_Scint_err));
 
  // === Store in payload ===
  m_eventT0HitResolution->setSigmaBKLMScint(sigma_BKLM_Scint, sigma_BKLM_Scint_err);
  m_eventT0HitResolution->setSigmaRPC(sigma_RPC, sigma_RPC_err);              // Combined for backward compatibility
  m_eventT0HitResolution->setSigmaRPCPhi(sigma_RPC_Phi, sigma_RPC_Phi_err);  // Direction-specific
  m_eventT0HitResolution->setSigmaRPCZ(sigma_RPC_Z, sigma_RPC_Z_err);        // Direction-specific
  m_eventT0HitResolution->setSigmaEKLMScint(sigma_EKLM_Scint, sigma_EKLM_Scint_err);
 
  B2INFO("EventT0 hit resolution calibration complete and stored in payload.");
 
  // Clear temporary data
  eventTrackMap.clear();
 
  delete fcn_const;
  m_evts.clear();
  m_timeShift.clear();
  m_timeRes.clear();
  m_cFlag.clear();
 
  saveHist();
 
  saveCalibration(m_timeCableDelay, "KLMTimeCableDelay");
  saveCalibration(m_timeConstants, "KLMTimeConstants");
  saveCalibration(m_timeResolution, "KLMTimeResolution");
  saveCalibration(m_eventT0HitResolution, "KLMEventT0HitResolution");
 
  return CalibrationAlgorithm::c_OK;
}

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.

{
  // Is it a sequence?
  if (PySequence_Check(pyObj)) {
    Py_ssize_t nObj = PySequence_Length(pyObj);
    // Does it have 2 objects in it?
    if (nObj != 2) {
      B2DEBUG(29, "ExpRun was a Python sequence which didn't have exactly 2 entries!");
      return false;
    }
    PyObject* item1, *item2;
    item1 = PySequence_GetItem(pyObj, 0);
    item2 = PySequence_GetItem(pyObj, 1);
    // Did the GetItem work?
    if ((item1 == NULL) || (item2 == NULL)) {
      B2DEBUG(29, "A PyObject pointer was NULL in the sequence");
      return false;
    }
    // Are they longs?
    if (PyLong_Check(item1) && PyLong_Check(item2)) {
      long value1, value2;
      value1 = PyLong_AsLong(item1);
      value2 = PyLong_AsLong(item2);
      if (((value1 == -1) || (value2 == -1)) && PyErr_Occurred()) {
        B2DEBUG(29, "An error occurred while converting the PyLong to long");
        return false;
      }
    } else {
      B2DEBUG(29, "One or more of the PyObjects in the ExpRun wasn't a long");
      return false;
    }
    // Make sure to kill off the reference GetItem gave us responsibility for
    Py_DECREF(item1);
    Py_DECREF(item2);
  } else {
    B2DEBUG(29, "ExpRun was not a Python sequence.");
    return false;
  }
  return true;
}

clearCalibrationData()

void clearCalibrationData ( )

inlineprotectedinherited

Clear calibration data.

Definition at line 324 of file CalibrationAlgorithm.h.

{m_data.clearCalibrationData();}

commit() [1/2]

bool commit ( )

inherited

Submit constants from last calibration into database.

Definition at line 302 of file CalibrationAlgorithm.cc.

{
  if (getPayloads().empty())
    return false;
  list<Database::DBImportQuery> payloads = getPayloads();
  B2INFO("Committing " << payloads.size()  << " payloads to database.");
  return Database::Instance().storeData(payloads);
}

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.

{
  if (payloads.empty())
    return false;
  return Database::Instance().storeData(payloads);
}

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.

{
  ExpRun expRun;
  PyObject* itemExp, *itemRun;
  itemExp = PySequence_GetItem(pyObj, 0);
  itemRun = PySequence_GetItem(pyObj, 1);
  expRun.first = PyLong_AsLong(itemExp);
  Py_DECREF(itemExp);
  expRun.second = PyLong_AsLong(itemRun);
  Py_DECREF(itemRun);
  return expRun;
}

createHistograms()

void createHistograms ( )

private

Create histograms.

Hist declaration Global time distribution

Definition at line 287 of file KLMTimeAlgorithm.cc.

{
  if (m_mc) {
    m_LowerTimeBoundaryRPC = -10.0;
    m_UpperTimeBoundaryRPC = 10.0;
    m_LowerTimeBoundaryScintillatorsBKLM = 20.0;
    m_UpperTimeBoundaryScintillatorsBKLM = 70.0;
    m_LowerTimeBoundaryScintillatorsEKLM = 20.0;
    m_UpperTimeBoundaryScintillatorsEKLM = 70.0;
  } else {
    m_LowerTimeBoundaryRPC = -800.0;
    m_UpperTimeBoundaryRPC = -600.0;
    m_LowerTimeBoundaryScintillatorsBKLM = -4800.0;
    m_UpperTimeBoundaryScintillatorsBKLM = -4400.0;
    m_LowerTimeBoundaryScintillatorsEKLM = -4950.0;
    m_UpperTimeBoundaryScintillatorsEKLM = -4650.0;
  }
 
  // Create directory structure for per-channel histograms
  // This must be done here (not in setupDatabase) because m_outFile is created just before this function is called
  if (m_outFile && m_saveChannelHists) {
    TDirectory* dir_channels = m_outFile->mkdir("channels", "Per-channel histograms", true);
 
    // BKLM directories
    TDirectory* dir_bklm = dir_channels->mkdir("BKLM", "", true);
    TString sectionName[2] = {"Backward", "Forward"};
    TString planeName[2] = {"Z", "Phi"};
 
    for (int iF = 0; iF < 2; ++iF) {
      TDirectory* dir_section = dir_bklm->mkdir(sectionName[iF].Data(), "", true);
      for (int iS = 0; iS < 8; ++iS) {
        TDirectory* dir_sector = dir_section->mkdir(Form("Sector_%d", iS + 1), "", true);
        for (int iL = 0; iL < 15; ++iL) {
          TDirectory* dir_layer = dir_sector->mkdir(Form("Layer_%d", iL + 1), "", true);
          for (int iP = 0; iP < 2; ++iP) {
            m_channelHistDir_BKLM[iF][iS][iL][iP] = dir_layer->mkdir(Form("Plane_%s", planeName[iP].Data()), "", true);
          }
        }
      }
    }
 
    // EKLM directories
    TDirectory* dir_eklm = dir_channels->mkdir("EKLM", "", true);
    for (int iF = 0; iF < 2; ++iF) {
      TDirectory* dir_section = dir_eklm->mkdir(sectionName[iF].Data(), "", true);
      for (int iS = 0; iS < 4; ++iS) {
        TDirectory* dir_sector = dir_section->mkdir(Form("Sector_%d", iS + 1), "", true);
        int maxLayer = 12 + 2 * iF;  // 12 for backward, 14 for forward
        for (int iL = 0; iL < maxLayer; ++iL) {
          TDirectory* dir_layer = dir_sector->mkdir(Form("Layer_%d", iL + 1), "", true);
          for (int iP = 0; iP < 2; ++iP) {
            m_channelHistDir_EKLM[iF][iS][iL][iP] = dir_layer->mkdir(Form("Plane_%d", iP + 1), "", true);
          }
        }
      }
    }
 
    m_outFile->cd();  // Return to root directory
    B2INFO("Created directory structure for per-channel histograms.");
  }
 
  int nBin = 80;
  int nBin_scint = 80;
 
  TString iFstring[2] = {"Backward", "Forward"};
  TString iPstring[2] = {"ZReadout", "PhiReadout"};
  TString hn, ht;
 
  h_diff = new TH1F("h_diff", "Position difference between bklmHit2d and extHit;position difference", 100, 0, 10);
  h_calibrated = new TH1I("h_calibrated_summary", "h_calibrated_summary;calibrated or not", 3, 0, 3);
  hc_calibrated = new TH1I("hc_calibrated_summary", "hc_calibrated_summary;calibrated or not", 3, 0, 3);
 
  gre_time_channel_scint = new TGraphErrors();
  gre_time_channel_rpc = new TGraphErrors();
  gre_time_channel_scint_end = new TGraphErrors();
 
  gr_timeShift_channel_scint = new TGraph();
  gr_timeShift_channel_rpc = new TGraph();
  gr_timeShift_channel_scint_end = new TGraph();
 
  gre_ctime_channel_scint = new TGraphErrors();
  gre_ctime_channel_rpc = new TGraphErrors();
  gre_ctime_channel_scint_end = new TGraphErrors();
 
  gr_timeRes_channel_scint = new TGraph();
  gr_timeRes_channel_rpc = new TGraph();
  gr_timeRes_channel_scint_end = new TGraph();
 
  double maximalPhiStripLengthBKLM =
    m_BKLMGeometry->getMaximalPhiStripLength();
  double maximalZStripLengthBKLM =
    m_BKLMGeometry->getMaximalZStripLength();
  double maximalStripLengthEKLM =
    m_EKLMGeometry->getMaximalStripLength() / CLHEP::cm * Unit::cm;
 
  m_ProfileRpcPhi = new TProfile("hprf_rpc_phi_effC",
                                 "Time over propagation length for RPCs (Phi_Readout); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]", 50, 0.0,
                                 400.0);
  m_ProfileRpcZ = new TProfile("hprf_rpc_z_effC",
                               "Time over propagation length for RPCs (Z_Readout); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]", 50, 0.0,
                               400.0);
  m_ProfileBKLMScintillatorPhi = new TProfile("hprf_scint_phi_effC",
                                              "Time over propagation length for scintillators (Phi_Readout); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]",
                                              50, 0.0, maximalPhiStripLengthBKLM);
  m_ProfileBKLMScintillatorZ = new TProfile("hprf_scint_z_effC",
                                            "Time over propagation length for scintillators (Z_Readout); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]",
                                            50, 0.0, maximalZStripLengthBKLM);
  m_ProfileEKLMScintillatorPlane1 = new TProfile("hprf_scint_plane1_effC_end",
                                                 "Time over propagation length for scintillators (plane1, Endcap); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]",
                                                 50, 0.0, maximalStripLengthEKLM);
  m_ProfileEKLMScintillatorPlane2 = new TProfile("hprf_scint_plane2_effC_end",
                                                 "Time over propagation length for scintillators (plane2, Endcap); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]",
                                                 50, 0.0, maximalStripLengthEKLM);
 
  m_Profile2RpcPhi = new TProfile("hprf2_rpc_phi_effC",
                                  "Time over propagation length for RPCs (Phi_Readout); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]", 50, 0.0,
                                  400.0);
  m_Profile2RpcZ = new TProfile("hprf2_rpc_z_effC",
                                "Time over propagation length for RPCs (Z_Readout); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]", 50, 0.0,
                                400.0);
  m_Profile2BKLMScintillatorPhi = new TProfile("hprf2_scint_phi_effC",
                                               "Time over propagation length for scintillators (Phi_Readout); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]",
                                               50, 0.0, maximalPhiStripLengthBKLM);
  m_Profile2BKLMScintillatorZ = new TProfile("hprf2_scint_z_effC",
                                             "Time over propagation length for scintillators (Z_Readout); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]",
                                             50, 0.0, maximalZStripLengthBKLM);
  m_Profile2EKLMScintillatorPlane1 = new TProfile("hprf2_scint_plane1_effC_end",
                                                  "Time over propagation length for scintillators (plane1, Endcap); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]",
                                                  50, 0.0, maximalStripLengthEKLM);
  m_Profile2EKLMScintillatorPlane2 = new TProfile("hprf2_scint_plane2_effC_end",
                                                  "Time over propagation length for scintillators (plane2, Endcap); propagation distance[cm]; T_rec-T_0-T_fly-'T_calibration'[ns]",
                                                  50, 0.0, maximalStripLengthEKLM);
 
  h_time_rpc_tc = new TH1F("h_time_rpc_tc", "time distribution for RPC", nBin, m_LowerTimeBoundaryRPC, m_UpperTimeBoundaryRPC);
  h_time_scint_tc = new TH1F("h_time_scint_tc", "time distribution for Scintillator", nBin_scint,
                             m_LowerTimeBoundaryScintillatorsBKLM, m_UpperTimeBoundaryScintillatorsBKLM);
  h_time_scint_tc_end = new TH1F("h_time_scint_tc_end", "time distribution for Scintillator (Endcap)", nBin_scint,
                                 m_LowerTimeBoundaryScintillatorsEKLM,
                                 m_UpperTimeBoundaryScintillatorsEKLM);

  h_time_rpc = new TH1F("h_time_rpc", "time distribution for RPC; T_rec-T_0-T_fly-T_propagation[ns]", nBin, m_LowerTimeBoundaryRPC,
                        m_UpperTimeBoundaryRPC);
  h_time_scint = new TH1F("h_time_scint", "time distribution for Scintillator; T_rec-T_0-T_fly-T_propagation[ns]", nBin_scint,
                          m_LowerTimeBoundaryScintillatorsBKLM, m_UpperTimeBoundaryScintillatorsBKLM);
  h_time_scint_end = new TH1F("h_time_scint_end", "time distribution for Scintillator (Endcap); T_rec-T_0-T_fly-T_propagation[ns]",
                              nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM, m_UpperTimeBoundaryScintillatorsEKLM);
 
  hc_time_rpc = new TH1F("hc_time_rpc", "Calibrated time distribution for RPC; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                         nBin, m_LowerTimeBoundaryCalibratedRPC, m_UpperTimeBoundaryCalibratedRPC);
  hc_time_scint = new TH1F("hc_time_scint",
                           "Calibrated time distribution for Scintillator; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]", nBin_scint,
                           m_LowerTimeBoundaryCalibratedScintillatorsBKLM,
                           m_UpperTimeBoundaryCalibratedScintillatorsBKLM);
  hc_time_scint_end = new TH1F("hc_time_scint_end",
                               "Calibrated time distribution for Scintillator (Endcap); T_rec-T_0-T_fly-T_propagation-T_calibration[ns]", nBin_scint,
                               m_LowerTimeBoundaryCalibratedScintillatorsEKLM, m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
 
  int nBin_t0 = 100;
  h_eventT0_rpc = new TH1F("h_eventT0_rpc",
                           "RPC: Event T0; T_{0}[ns]", nBin_t0, -100.0, 100.0);
  h_eventT0_scint = new TH1F("h_eventT0_scint",
                             "BKLM scintillator: Event T0; T_{0}[ns]", nBin_t0, -100.0, 100.0);
  h_eventT0_scint_end = new TH1F("h_eventT0_scint_end",
                                 "EKLM scintillator: Event T0; T_{0}[ns]", nBin_t0, -100.0, 100.0);
 
  // Corrected EventT0 distributions between 2 muon tracks in an event.
  hc_eventT0_rpc = new TH1F("hc_eventT0_rpc",
                            "RPC: corrected Event T0; T_{0}^{+} - T_{0}^{-} [ns]", nBin_t0, -40.0, 40.0);
  hc_eventT0_scint = new TH1F("hc_eventT0_scint",
                              "BKLM scintillator: corrected Event T0; T_{0}^{+} - T_{0}^{-} [ns]", nBin_t0, -40.0, 40.0);
  hc_eventT0_scint_end = new TH1F("hc_eventT0_scint_end",
                                  "EKLM scintillator: corrected Event T0; T_{0}^{+} - T_{0}^{-} [ns]", nBin_t0, -20.0, 20.0);
 
  // ==== NEW DIAGNOSTIC PLOTS ====
 
  // Hit multiplicity distributions
  h_nHits_plus_rpc = new TH1F("h_nHits_plus_rpc",
                              "RPC: #mu^{+} hit multiplicity;N_{hits};Events", 100, 0, 100);
  h_nHits_minus_rpc = new TH1F("h_nHits_minus_rpc",
                               "RPC: #mu^{-} hit multiplicity;N_{hits};Events", 100, 0, 100);
  h_nHits_plus_scint = new TH1F("h_nHits_plus_scint",
                                "BKLM Scint: #mu^{+} hit multiplicity;N_{hits};Events", 30, 0, 30);
  h_nHits_minus_scint = new TH1F("h_nHits_minus_scint",
                                 "BKLM Scint: #mu^{-} hit multiplicity;N_{hits};Events", 30, 0, 30);
  h_nHits_plus_scint_end = new TH1F("h_nHits_plus_scint_end",
                                    "EKLM Scint: #mu^{+} hit multiplicity;N_{hits};Events", 30, 0, 30);
  h_nHits_minus_scint_end = new TH1F("h_nHits_minus_scint_end",
                                     "EKLM Scint: #mu^{-} hit multiplicity;N_{hits};Events", 30, 0, 30);
 
  // ΔT0 vs variance weight v = 1/N+ + 1/N-
  h2_deltaT0_vs_v_rpc = new TH2F("h2_deltaT0_vs_v_rpc",
                                 "RPC: #DeltaT_{0} vs variance weight;v = 1/N^{+} + 1/N^{-};#DeltaT_{0} [ns]",
                                 50, 0, 2.0, 100, -40, 40);
  h2_deltaT0_vs_v_scint = new TH2F("h2_deltaT0_vs_v_scint",
                                   "BKLM Scint: #DeltaT_{0} vs variance weight;v = 1/N^{+} + 1/N^{-};#DeltaT_{0} [ns]",
                                   50, 0, 1.0, 100, -40, 40);
  h2_deltaT0_vs_v_scint_end = new TH2F("h2_deltaT0_vs_v_scint_end",
                                       "EKLM Scint: #DeltaT_{0} vs variance weight;v = 1/N^{+} + 1/N^{-};#DeltaT_{0} [ns]",
                                       50, 0, 1.0, 100, -20, 20);
 
  // Profile: RMS(ΔT0) vs v (should scale as √v if model is correct)
  prof_deltaT0_rms_vs_v_rpc = new TProfile("prof_deltaT0_rms_vs_v_rpc",
                                           "RPC: RMS(#DeltaT_{0}) vs v;v = 1/N^{+} + 1/N^{-};RMS(#DeltaT_{0}) [ns]",
                                           20, 0, 2.0, "s");  // "s" option for RMS
  prof_deltaT0_rms_vs_v_scint = new TProfile("prof_deltaT0_rms_vs_v_scint",
                                             "BKLM Scint: RMS(#DeltaT_{0}) vs v;v = 1/N^{+} + 1/N^{-};RMS(#DeltaT_{0}) [ns]",
                                             20, 0, 1.0, "s");
  prof_deltaT0_rms_vs_v_scint_end = new TProfile("prof_deltaT0_rms_vs_v_scint_end",
                                                 "EKLM Scint: RMS(#DeltaT_{0}) vs v;v = 1/N^{+} + 1/N^{-};RMS(#DeltaT_{0}) [ns]",
                                                 20, 0, 1.0, "s");
 
  // ΔT0 vs total hits
  h2_deltaT0_vs_nhits_rpc = new TH2F("h2_deltaT0_vs_nhits_rpc",
                                     "RPC: #DeltaT_{0} vs total hits;N^{+} + N^{-};#DeltaT_{0} [ns]",
                                     50, 0, 200, 100, -40, 40);
  h2_deltaT0_vs_nhits_scint = new TH2F("h2_deltaT0_vs_nhits_scint",
                                       "BKLM Scint: #DeltaT_{0} vs total hits;N^{+} + N^{-};#DeltaT_{0} [ns]",
                                       40, 0, 40, 100, -40, 40);
  h2_deltaT0_vs_nhits_scint_end = new TH2F("h2_deltaT0_vs_nhits_scint_end",
                                           "EKLM Scint: #DeltaT_{0} vs total hits;N^{+} + N^{-};#DeltaT_{0} [ns]",
                                           40, 0, 40, 100, -20, 20);
 
  // ΔT0 separated by hit multiplicity bins
  hc_eventT0_rpc_lowN = new TH1F("hc_eventT0_rpc_lowN",
                                 "RPC: #DeltaT_{0} (N^{+}+N^{-} < 10);#DeltaT_{0} [ns]", nBin_t0, -40.0, 40.0);
  hc_eventT0_rpc_midN = new TH1F("hc_eventT0_rpc_midN",
                                 "RPC: #DeltaT_{0} (10 #leq N^{+}+N^{-} < 30);#DeltaT_{0} [ns]", nBin_t0, -40.0, 40.0);
  hc_eventT0_rpc_highN = new TH1F("hc_eventT0_rpc_highN",
                                  "RPC: #DeltaT_{0} (N^{+}+N^{-} #geq 30);#DeltaT_{0} [ns]", nBin_t0, -40.0, 40.0);
 
  hc_eventT0_scint_lowN = new TH1F("hc_eventT0_scint_lowN",
                                   "BKLM Scint: #DeltaT_{0} (N^{+}+N^{-} < 5);#DeltaT_{0} [ns]", nBin_t0, -40.0, 40.0);
  hc_eventT0_scint_midN = new TH1F("hc_eventT0_scint_midN",
                                   "BKLM Scint: #DeltaT_{0} (5 #leq N^{+}+N^{-} < 15);#DeltaT_{0} [ns]", nBin_t0, -40.0, 40.0);
  hc_eventT0_scint_highN = new TH1F("hc_eventT0_scint_highN",
                                    "BKLM Scint: #DeltaT_{0} (N^{+}+N^{-} #geq 15);#DeltaT_{0} [ns]", nBin_t0, -40.0, 40.0);
 
  hc_eventT0_scint_end_lowN = new TH1F("hc_eventT0_scint_end_lowN",
                                       "EKLM Scint: #DeltaT_{0} (N^{+}+N^{-} < 5);#DeltaT_{0} [ns]", nBin_t0, -20.0, 20.0);
  hc_eventT0_scint_end_midN = new TH1F("hc_eventT0_scint_end_midN",
                                       "EKLM Scint: #DeltaT_{0} (5 #leq N^{+}+N^{-} < 15);#DeltaT_{0} [ns]", nBin_t0, -20.0, 20.0);
  hc_eventT0_scint_end_highN = new TH1F("hc_eventT0_scint_end_highN",
                                        "EKLM Scint: #DeltaT_{0} (N^{+}+N^{-} #geq 15);#DeltaT_{0} [ns]", nBin_t0, -20.0, 20.0);
 
  if (!m_saveAllPlots) {
    B2INFO("Skipping debug histogram allocation (m_saveAllPlots = false)");
    return;  // Skip all debugging histogram allocation
  }
 
  for (int iF = 0; iF < 2; ++iF) {
    hn = Form("h_timeF%d_rpc", iF);
    ht = Form("Time distribution for RPC of %s; T_rec-T_0-T_fly-T_propagation[ns]", iFstring[iF].Data());
    h_timeF_rpc[iF] = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryRPC, m_UpperTimeBoundaryRPC);
    hn = Form("h_timeF%d_scint", iF);
    ht = Form("Time distribution for Scintillator of %s; T_rec-T_0-T_fly-T_propagation[ns]", iFstring[iF].Data());
    h_timeF_scint[iF] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsBKLM,
                                 m_UpperTimeBoundaryScintillatorsBKLM);
    hn = Form("h_timeF%d_scint_end", iF);
    ht = Form("Time distribution for Scintillator of %s (Endcap); T_rec-T_0-T_fly-T_propagation[ns]", iFstring[iF].Data());
    h_timeF_scint_end[iF] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM,
                                     m_UpperTimeBoundaryScintillatorsEKLM);
 
    hn = Form("h2_timeF%d_rpc", iF);
    ht = Form("Time distribution for RPC of %s; Sector Index; T_rec-T_0-T_fly-T_propagation[ns]", iFstring[iF].Data());
    h2_timeF_rpc[iF] = new TH2F(hn.Data(), ht.Data(), 8, 0, 8, nBin, m_LowerTimeBoundaryRPC, m_UpperTimeBoundaryRPC);
    hn = Form("h2_timeF%d_scint", iF);
    ht = Form("Time distribution for Scintillator of %s; Sector Index; T_rec-T_0-T_fly-T_propagation[ns]", iFstring[iF].Data());
    h2_timeF_scint[iF] = new TH2F(hn.Data(), ht.Data(), 8, 0, 8, nBin_scint, m_LowerTimeBoundaryScintillatorsBKLM,
                                  m_UpperTimeBoundaryScintillatorsBKLM);
    hn = Form("h2_timeF%d_scint_end", iF);
    ht = Form("Time distribution for Scintillator of %s (Endcap); Sector Index; T_rec-T_0-T_fly-T_propagation[ns]",
              iFstring[iF].Data());
    h2_timeF_scint_end[iF] = new TH2F(hn.Data(), ht.Data(), 4, 0, 4, nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM,
                                      m_UpperTimeBoundaryScintillatorsEKLM);
 
    hn = Form("hc_timeF%d_rpc", iF);
    ht = Form("Calibrated time distribution for RPC of %s; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]", iFstring[iF].Data());
    hc_timeF_rpc[iF] = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryCalibratedRPC, m_UpperTimeBoundaryCalibratedRPC);
    hn = Form("hc_timeF%d_scint", iF);
    ht = Form("Calibrated time distribution for Scintillator of %s; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
              iFstring[iF].Data());
    hc_timeF_scint[iF] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsBKLM,
                                  m_UpperTimeBoundaryCalibratedScintillatorsBKLM);
    hn = Form("hc_timeF%d_scint_end", iF);
    ht = Form("Calibrated time distribution for Scintillator of %s (Endcap); T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
              iFstring[iF].Data());
    hc_timeF_scint_end[iF] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsEKLM,
                                      m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
 
    hn = Form("h2c_timeF%d_rpc", iF);
    ht = Form("Calibrated time distribution for RPC of %s; Sector Index; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
              iFstring[iF].Data());
    h2c_timeF_rpc[iF] = new TH2F(hn.Data(), ht.Data(), 8, 0, 8, nBin, m_LowerTimeBoundaryCalibratedRPC,
                                 m_UpperTimeBoundaryCalibratedRPC);
    hn = Form("h2c_timeF%d_scint", iF);
    ht = Form("Calibrated time distribution for Scintillator of %s; Sector Index; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
              iFstring[iF].Data());
    h2c_timeF_scint[iF] = new TH2F(hn.Data(), ht.Data(), 8, 0, 8, nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsBKLM,
                                   m_UpperTimeBoundaryCalibratedScintillatorsBKLM);
    hn = Form("h2c_timeF%d_scint_end", iF);
    ht = Form("Calibrated time distribution for Scintillator of %s (Endcap) ; Sector Index; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
              iFstring[iF].Data());
    h2c_timeF_scint_end[iF] = new TH2F(hn.Data(), ht.Data(), 4, 0, 4, nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsEKLM,
                                       m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
 
    for (int iS = 0; iS < 8; ++iS) {
      // Barrel parts
      hn = Form("h_timeF%d_S%d_scint", iF, iS);
      ht = Form("Time distribution for Scintillator of Sector%d, %s; T_rec-T_0-T_fly-T_propagation[ns]", iS, iFstring[iF].Data());
      h_timeFS_scint[iF][iS] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsBKLM,
                                        m_UpperTimeBoundaryScintillatorsBKLM);
      hn = Form("h_timeF%d_S%d_rpc", iF, iS);
      ht = Form("Time distribution for RPC of Sector%d, %s; T_rec-T_0-T_fly-T_propagation[ns]", iS, iFstring[iF].Data());
      h_timeFS_rpc[iF][iS] = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryRPC, m_UpperTimeBoundaryRPC);
      hn = Form("h2_timeF%d_S%d", iF, iS);
      ht = Form("Time distribution of Sector%d, %s; Layer Index; T_rec-T_0-T_fly-T_propagation[ns]", iS, iFstring[iF].Data());
      h2_timeFS[iF][iS] = new TH2F(hn.Data(), ht.Data(), 15, 0, 15, nBin_scint, m_LowerTimeBoundaryRPC,
                                   m_UpperTimeBoundaryScintillatorsBKLM);
 
      hn = Form("hc_timeF%d_S%d_scint", iF, iS);
      ht = Form("Calibrated time distribution for Scintillator of Sector%d, %s; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]", iS,
                iFstring[iF].Data());
      hc_timeFS_scint[iF][iS] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsBKLM,
                                         m_UpperTimeBoundaryCalibratedScintillatorsBKLM);
      hn = Form("hc_timeF%d_S%d_rpc", iF, iS);
      ht = Form("Calibrated time distribution for RPC of Sector%d, %s; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]", iS,
                iFstring[iF].Data());
      hc_timeFS_rpc[iF][iS] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedRPC,
                                       m_UpperTimeBoundaryCalibratedRPC);
      hn = Form("h2c_timeF%d_S%d", iF, iS);
      ht = Form("Calibrated time distribution of Sector%d, %s; Layer Index; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]", iS,
                iFstring[iF].Data());
      h2c_timeFS[iF][iS] = new TH2F(hn.Data(), ht.Data(), 15, 0, 15, nBin_scint, m_LowerTimeBoundaryCalibratedRPC,
                                    m_UpperTimeBoundaryCalibratedScintillatorsBKLM);
 
      // Inner 2 layers --> Scintillators
      for (int iL = 0; iL < 2; ++iL) {
        hn = Form("h_timeF%d_S%d_L%d", iF, iS, iL);
        ht = Form("Time distribution for Scintillator of Layer%d, Sector%d, %s; T_rec-T_0-T_fly-T_propagation[ns]", iL, iS,
                  iFstring[iF].Data());
        h_timeFSL[iF][iS][iL] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsBKLM,
                                         m_UpperTimeBoundaryScintillatorsBKLM);
        hn = Form("hc_timeF%d_S%d_L%d", iF, iS, iL);
        ht = Form("Calibrated time distribution for Scintillator of Layer%d, Sector%d, %s; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                  iL, iS, iFstring[iF].Data());
        hc_timeFSL[iF][iS][iL] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsBKLM,
                                          m_UpperTimeBoundaryCalibratedScintillatorsBKLM);
 
        for (int iP = 0; iP < 2; ++iP) {
          hn = Form("h_timeF%d_S%d_L%d_P%d", iF, iS, iL, iP);
          ht = Form("Time distribution for Scintillator of %s, Layer%d, Sector%d, %s; T_rec-T_0-T_fly-T_propagation[ns]",
                    iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h_timeFSLP[iF][iS][iL][iP] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsBKLM,
                                                m_UpperTimeBoundaryScintillatorsBKLM);
          hn = Form("h2_timeF%d_S%d_L%d_P%d", iF, iS, iL, iP);
          ht = Form("Time distribution for Scintillator of %s, Layer%d, Sector%d, %s; Channel Index; T_rec-T_0-T_fly-T_propagation[ns]",
                    iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h2_timeFSLP[iF][iS][iL][iP] = new TH2F(hn.Data(), ht.Data(), 54, 0, 54, nBin_scint, m_LowerTimeBoundaryScintillatorsBKLM,
                                                 m_UpperTimeBoundaryScintillatorsBKLM);
 
          hn = Form("hc_timeF%d_S%d_L%d_P%d", iF, iS, iL, iP);
          ht = Form("Calibrated time distribution for Scintillator of %s, Layer%d, Sector%d, %s; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                    iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          hc_timeFSLP[iF][iS][iL][iP] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsBKLM,
                                                 m_UpperTimeBoundaryCalibratedScintillatorsBKLM);
          hn = Form("h2c_timeF%d_S%d_L%d_P%d", iF, iS, iL, iP);
          ht = Form("Calibrated time distribution for Scintillator of %s, Layer%d, Sector%d, %s; Channel Index; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                    iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h2c_timeFSLP[iF][iS][iL][iP] = new TH2F(hn.Data(), ht.Data(), 54, 0, 54, nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsBKLM,
                                                  m_UpperTimeBoundaryCalibratedScintillatorsBKLM);
        }
      }
 
      for (int iL = 2; iL < 15; ++iL) {
        hn = Form("h_timeF%d_S%d_L%d", iF, iS, iL);
        ht = Form("time distribution for RPC of Layer%d, Sector%d, %s; T_rec-T_0-T_fly-T_propagation[ns]", iL, iS, iFstring[iF].Data());
        h_timeFSL[iF][iS][iL] = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryRPC, m_UpperTimeBoundaryRPC);
 
        hn = Form("hc_timeF%d_S%d_L%d", iF, iS, iL);
        ht = Form("Calibrated time distribution for RPC of Layer%d, Sector%d, %s; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]", iL, iS,
                  iFstring[iF].Data());
        hc_timeFSL[iF][iS][iL] = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryCalibratedRPC, m_UpperTimeBoundaryCalibratedRPC);
 
        for (int iP = 0; iP < 2; ++iP) {
          hn = Form("h_timeF%d_S%d_L%d_P%d", iF, iS, iL, iP);
          ht = Form("time distribution for RPC of %s, Layer%d, Sector%d, %s; T_rec-T_0-T_fly-T_propagation[ns]", iPstring[iP].Data(), iL, iS,
                    iFstring[iF].Data());
          h_timeFSLP[iF][iS][iL][iP] = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryRPC, m_UpperTimeBoundaryRPC);
 
          hn = Form("h2_timeF%d_S%d_L%d_P%d", iF, iS, iL, iP);
          ht = Form("time distribution for RPC of %s, Layer%d, Sector%d, %s; Channel Index; T_rec-T_0-T_fly-T_propagation[ns]",
                    iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h2_timeFSLP[iF][iS][iL][iP] = new TH2F(hn.Data(), ht.Data(), 48, 0, 48, nBin, m_LowerTimeBoundaryRPC, m_UpperTimeBoundaryRPC);
 
          hn = Form("hc_timeF%d_S%d_L%d_P%d", iF, iS, iL, iP);
          ht = Form("Calibrated time distribution for RPC of %s, Layer%d, Sector%d, %s; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                    iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          hc_timeFSLP[iF][iS][iL][iP] = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryCalibratedRPC,
                                                 m_UpperTimeBoundaryCalibratedRPC);
 
          hn = Form("h2c_timeF%d_S%d_L%d_P%d", iF, iS, iL, iP);
          ht = Form("Calibrated time distribution for RPC of %s, Layer%d, Sector%d, %s; Channel Index; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                    iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h2c_timeFSLP[iF][iS][iL][iP] = new TH2F(hn.Data(), ht.Data(), 48, 0, 48, nBin, m_LowerTimeBoundaryCalibratedRPC,
                                                  m_UpperTimeBoundaryCalibratedRPC);
        }
      }
    }
    // Endcap part
    int maxLay = 12 + 2 * iF;
    for (int iS = 0; iS < 4; ++iS) {
      hn = Form("h_timeF%d_S%d_scint_end", iF, iS);
      ht = Form("Time distribution for Scintillator of Sector%d, %s (Endcap); T_rec-T_0-T_fly-T_propagation[ns]", iS,
                iFstring[iF].Data());
      h_timeFS_scint_end[iF][iS] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM,
                                            m_UpperTimeBoundaryScintillatorsEKLM);
      hn = Form("h2_timeF%d_S%d_end", iF, iS);
      ht = Form("Time distribution of Sector%d, %s (Endcap); Layer Index; T_rec-T_0-T_fly-T_propagation[ns]", iS, iFstring[iF].Data());
      h2_timeFS_end[iF][iS] = new TH2F(hn.Data(), ht.Data(), maxLay, 0, maxLay, nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM,
                                       m_UpperTimeBoundaryScintillatorsEKLM);
      hn = Form("hc_timeF%d_S%d_scint_end", iF, iS);
      ht = Form("Calibrated time distribution for Scintillator of Sector%d (Endcap), %s; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                iS, iFstring[iF].Data());
      hc_timeFS_scint_end[iF][iS] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsEKLM,
                                             m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
      hn = Form("h2c_timeF%d_S%d_end", iF, iS);
      ht = Form("Calibrated time distribution of Sector%d, %s (Endcap); Layer Index; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                iS, iFstring[iF].Data());
      h2c_timeFS_end[iF][iS] = new TH2F(hn.Data(), ht.Data(), maxLay, 0, maxLay, nBin_scint,
                                        m_LowerTimeBoundaryCalibratedScintillatorsEKLM,
                                        m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
 
      for (int iL = 0; iL < maxLay; ++iL) {
        hn = Form("h_timeF%d_S%d_L%d_end", iF, iS, iL);
        ht = Form("Time distribution for Scintillator of Layer%d, Sector%d, %s (Endcap); T_rec-T_0-T_fly-T_propagation[ns]", iL, iS,
                  iFstring[iF].Data());
        h_timeFSL_end[iF][iS][iL] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM,
                                             m_UpperTimeBoundaryScintillatorsEKLM);
        hn = Form("hc_timeF%d_S%d_L%d_end", iF, iS, iL);
        ht = Form("Calibrated time distribution for Scintillator of Layer%d, Sector%d, %s (Endcap); T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                  iL, iS, iFstring[iF].Data());
        hc_timeFSL_end[iF][iS][iL] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsEKLM,
                                              m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
 
        for (int iP = 0; iP < 2; ++iP) {
          hn = Form("h_timeF%d_S%d_L%d_P%d_end", iF, iS, iL, iP);
          ht = Form("Time distribution for Scintillator of %s, Layer%d, Sector%d, %s (Endcap); T_rec-T_0-T_fly-T_propagation[ns]",
                    iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h_timeFSLP_end[iF][iS][iL][iP] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM,
                                                    m_UpperTimeBoundaryScintillatorsEKLM);
 
          hn = Form("h2_timeF%d_S%d_L%d_P%d_end", iF, iS, iL, iP);
          ht = Form("Time distribution for Scintillator of %s, Layer%d, Sector%d, %s (Endcap); Channel Index; T_rec-T_0-T_fly-T_propagation[ns]",
                    iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h2_timeFSLP_end[iF][iS][iL][iP] = new TH2F(hn.Data(), ht.Data(), 75, 0, 75, nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM,
                                                     m_UpperTimeBoundaryScintillatorsEKLM);
 
          hn = Form("hc_timeF%d_S%d_L%d_P%d_end", iF, iS, iL, iP);
          ht = Form("Calibrated time distribution for Scintillator of %s, Layer%d, Sector%d, %s (Endcap); T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                    iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          hc_timeFSLP_end[iF][iS][iL][iP] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsEKLM,
                                                     m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
 
          hn = Form("h2c_timeF%d_S%d_L%d_P%d_end", iF, iS, iL, iP);
          ht = Form("Calibrated time distribution for Scintillator of %s, Layer%d, Sector%d, %s (Endcap); Channel Index; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                    iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
          h2c_timeFSLP_end[iF][iS][iL][iP] = new TH2F(hn.Data(), ht.Data(), 75, 0, 75, nBin_scint,
                                                      m_LowerTimeBoundaryCalibratedScintillatorsEKLM,
                                                      m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
        }
      }
    }
  }
 
  // NOTE: Directory structure for per-channel histograms is created in createHistograms()
  // because m_outFile is not yet created when setupDatabase() is called.
}

dumpOutputJson()

const std::string dumpOutputJson ( ) const

inlineinherited

Dump the JSON string of the output JSON object.

Definition at line 223 of file CalibrationAlgorithm.h.

{return m_jsonExecutionOutput.dump();}

esti_timeRes()

double esti_timeRes

(

const KLMChannelIndex &

klmChannel

)

Estimate value of calibration constant for calibrated channels.

Parameters

[in]

klmChannel

KLM channel index.

Definition at line 2711 of file KLMTimeAlgorithm.cc.

{
  double tR = 0.0;
  int iSub = klmChannel.getSubdetector();
  int iF = klmChannel.getSection();
  int iS = klmChannel.getSector();
  int iL = klmChannel.getLayer();
  int iP = klmChannel.getPlane();
  int iC = klmChannel.getStrip();
  int totNStrips = EKLMElementNumbers::getMaximalStripNumber();
  if (iSub == KLMElementNumbers::c_BKLM)
    totNStrips = BKLMElementNumbers::getNStrips(iF, iS, iL, iP);
  if (iC == 1) {
    KLMChannelIndex kCIndex_upper(iSub, iF, iS, iL, iP, iC + 1);
    tR = tR_upperStrip(kCIndex_upper).second;
  } else if (iC == totNStrips) {
    KLMChannelIndex kCIndex_lower(iSub, iF, iS, iL, iP, iC - 1);
    tR = tR_lowerStrip(kCIndex_lower).second;
  } else {
    KLMChannelIndex kCIndex_upper(iSub, iF, iS, iL, iP, iC + 1);
    KLMChannelIndex kCIndex_lower(iSub, iF, iS, iL, iP, iC - 1);
    std::pair<int, double> tR_upper = tR_upperStrip(kCIndex_upper);
    std::pair<int, double> tR_lower = tR_lowerStrip(kCIndex_lower);
    unsigned int tr_upper = tR_upper.first - iC;
    unsigned int tr_lower = iC - tR_lower.first;
    unsigned int tr = tR_upper.first - tR_lower.first;
    tR = (double(tr_upper) * tR_lower.second + double(tr_lower) * tR_upper.second) / double(tr);
  }
  return tR;
}

esti_timeShift()

double esti_timeShift

(

const KLMChannelIndex &

klmChannel

)

Estimate value of calibration constant for uncalibrated channels.

Parameters

[in]

klmChannel

KLM channel index.

Definition at line 2631 of file KLMTimeAlgorithm.cc.

{
  double tS = 0.0;
  int iSub = klmChannel.getSubdetector();
  int iF = klmChannel.getSection();
  int iS = klmChannel.getSector();
  int iL = klmChannel.getLayer();
  int iP = klmChannel.getPlane();
  int iC = klmChannel.getStrip();
  int totNStrips = EKLMElementNumbers::getMaximalStripNumber();
  if (iSub == KLMElementNumbers::c_BKLM)
    totNStrips = BKLMElementNumbers::getNStrips(iF, iS, iL, iP);
  if (iC == 1) {
    KLMChannelIndex kCIndex_upper(iSub, iF, iS, iL, iP, iC + 1);
    tS = tS_upperStrip(kCIndex_upper).second;
  } else if (iC == totNStrips) {
    KLMChannelIndex kCIndex_lower(iSub, iF, iS, iL, iP, iC - 1);
    tS = tS_lowerStrip(kCIndex_lower).second;
  } else {
    KLMChannelIndex kCIndex_upper(iSub, iF, iS, iL, iP, iC + 1);
    KLMChannelIndex kCIndex_lower(iSub, iF, iS, iL, iP, iC - 1);
    std::pair<int, double> tS_upper = tS_upperStrip(kCIndex_upper);
    std::pair<int, double> tS_lower = tS_lowerStrip(kCIndex_lower);
    unsigned int td_upper = tS_upper.first - iC;
    unsigned int td_lower = iC - tS_lower.first;
    unsigned int td = tS_upper.first - tS_lower.first;
    tS = (double(td_upper) * tS_lower.second + double(td_lower) * tS_upper.second) / double(td);
  }
  return tS;
}

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.

{
  B2DEBUG(29, "Running execute() using Python Object as input argument");
  // Reset the execution specific data in case the algorithm was previously called
  m_data.reset();
  m_data.setIteration(iteration);
  vector<ExpRun> vecRuns;
  // Is it a list?
  if (PySequence_Check(runs)) {
    boost::python::handle<> handle(boost::python::borrowed(runs));
    boost::python::list listRuns(handle);
 
    int nList = boost::python::len(listRuns);
    for (int iList = 0; iList < nList; ++iList) {
      boost::python::object pyExpRun(listRuns[iList]);
      if (!checkPyExpRun(pyExpRun.ptr())) {
        B2ERROR("Received Python ExpRuns couldn't be converted to C++");
        m_data.setResult(c_Failure);
        return c_Failure;
      } else {
        vecRuns.push_back(convertPyExpRun(pyExpRun.ptr()));
      }
    }
  } else {
    B2ERROR("Tried to set the input runs but we didn't receive a Python sequence object (list,tuple).");
    m_data.setResult(c_Failure);
    return c_Failure;
  }
  return execute(vecRuns, iteration, iov);
}

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.

{
  // Check if we are calling this function directly and need to reset, or through Python where it was already done.
  if (m_data.getResult() != c_Undefined) {
    m_data.reset();
    m_data.setIteration(iteration);
  }
 
  if (m_inputFileNames.empty()) {
    B2ERROR("There aren't any input files set. Please use CalibrationAlgorithm::setInputFiles()");
    m_data.setResult(c_Failure);
    return c_Failure;
  }
 
  // Did we receive runs to execute over explicitly?
  if (!(runs.empty())) {
    for (auto expRun : runs) {
      B2DEBUG(29, "ExpRun requested = (" << expRun.first << ", " << expRun.second << ")");
    }
    // We've asked explicitly for certain runs, but we should check if the data granularity is 'run'
    if (strcmp(getGranularity().c_str(), "all") == 0) {
      B2ERROR(("The data is collected with granularity=all (exp=-1,run=-1), but you seem to request calibration for specific runs."
               " We'll continue but using ALL the input data given instead of the specific runs requested."));
    }
  } else {
    // If no runs are provided, infer the runs from all collected data
    runs = getRunListFromAllData();
    // Let's check that we have some now
    if (runs.empty()) {
      B2ERROR("No collected data in input files.");
      m_data.setResult(c_Failure);
      return c_Failure;
    }
    for (auto expRun : runs) {
      B2DEBUG(29, "ExpRun requested = (" << expRun.first << ", " << expRun.second << ")");
    }
  }
 
  m_data.setRequestedRuns(runs);
  if (iov.empty()) {
    // If no user specified IoV we use the IoV from the executed run list
    iov = IntervalOfValidity(runs[0].first, runs[0].second, runs[runs.size() - 1].first, runs[runs.size() - 1].second);
  }
  m_data.setRequestedIov(iov);
  // After here, the getObject<...>(...) helpers start to work
 
  CalibrationAlgorithm::EResult result = calibrate();
  m_data.setResult(result);
  return result;
}

fillRunToInputFilesMap()

void fillRunToInputFilesMap ( )

inherited

Fill the mapping of ExpRun -> Files.

Definition at line 330 of file CalibrationAlgorithm.cc.

{
  m_runsToInputFiles.clear();
  // Save TDirectory to change back at the end
  TDirectory* dir = gDirectory;
  RunRange* runRange;
  // Construct the TDirectory name where we expect our objects to be
  string runRangeObjName(getPrefix() + "/" + RUN_RANGE_OBJ_NAME);
  for (const auto& fileName : m_inputFileNames) {
    //Open TFile to get the objects
    unique_ptr<TFile> f;
    f.reset(TFile::Open(fileName.c_str(), "READ"));
    runRange = dynamic_cast<RunRange*>(f->Get(runRangeObjName.c_str()));
    if (runRange) {
      // Insert or extend the run -> file mapping for this ExpRun
      auto expRuns = runRange->getExpRunSet();
      for (const auto& expRun : expRuns) {
        auto runFiles = m_runsToInputFiles.find(expRun);
        if (runFiles != m_runsToInputFiles.end()) {
          (runFiles->second).push_back(fileName);
        } else {
          m_runsToInputFiles.insert(std::make_pair(expRun, std::vector<std::string> {fileName}));
        }
      }
    } else {
      B2WARNING("Missing a RunRange object for file: " << fileName);
    }
  }
  dir->cd();
}

fillTimeDistanceProfiles()

void fillTimeDistanceProfiles ( TProfile * profileRpcPhi, TProfile * profileRpcZ, TProfile * profileBKLMScintillatorPhi, TProfile * profileBKLMScintillatorZ, TProfile * profileEKLMScintillatorPlane1, TProfile * profileEKLMScintillatorPlane2, bool fill2dHistograms )

private

Fill profiles of time versus distance.

Parameters

[out]	profileRpcPhi	BKLM RPC phi plane.
[out]	profileRpcZ	BKLM RPC z plane.
[out]	profileBKLMScintillatorPhi	BKLM scintillator phi plane.
[out]	profileBKLMScintillatorZ	BKLM scintillator z plane.
[out]	profileEKLMScintillatorPlane1	EKLM scintillator plane1.
[out]	profileEKLMScintillatorPlane2	EKLM scintillator plane2.
[in]	fill2dHistograms	Whether to fill 2d histograms.

Definition at line 766 of file KLMTimeAlgorithm.cc.

{
  B2INFO("Filling time-distance profiles" << (fill2dHistograms ? " with 2D histograms" : "") << " (batched processing)...");
 
  TString iFstring[2] = {"Backward", "Forward"};
  TString iPstring[2] = {"ZReadout", "PhiReadout"};
 
  // Define the 6 batches (same as in calibrate())
  auto isRPCBackward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_BKLM &&
           ch.getLayer() >= BKLMElementNumbers::c_FirstRPCLayer &&
           ch.getSection() == BKLMElementNumbers::c_BackwardSection;
  };
 
  auto isRPCForward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_BKLM &&
           ch.getLayer() >= BKLMElementNumbers::c_FirstRPCLayer &&
           ch.getSection() == BKLMElementNumbers::c_ForwardSection;
  };
 
  auto isBKLMScintillatorBackward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_BKLM &&
           ch.getLayer() < BKLMElementNumbers::c_FirstRPCLayer &&
           ch.getSection() == BKLMElementNumbers::c_BackwardSection;
  };
 
  auto isBKLMScintillatorForward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_BKLM &&
           ch.getLayer() < BKLMElementNumbers::c_FirstRPCLayer &&
           ch.getSection() == BKLMElementNumbers::c_ForwardSection;
  };
 
  auto isEKLMScintillatorBackward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_EKLM &&
           ch.getSection() == EKLMElementNumbers::c_BackwardSection;
  };
 
  auto isEKLMScintillatorForward = [](const KLMChannelIndex & ch) {
    return ch.getSubdetector() == KLMElementNumbers::c_EKLM &&
           ch.getSection() == EKLMElementNumbers::c_ForwardSection;
  };
 
  std::vector<std::pair<std::string, std::function<bool(const KLMChannelIndex&)>>> batches = {
    {"RPC Backward", isRPCBackward},
    {"RPC Forward", isRPCForward},
    {"BKLM Scintillator Backward", isBKLMScintillatorBackward},
    {"BKLM Scintillator Forward", isBKLMScintillatorForward},
    {"EKLM Scintillator Backward", isEKLMScintillatorBackward},
    {"EKLM Scintillator Forward", isEKLMScintillatorForward}
  };
 
  // Process each batch
  for (const auto& batch : batches) {
    B2INFO("Processing batch for profiles: " << batch.first);
    readCalibrationDataBatch(batch.second);
 
    // Temporary storage for per-channel 2D histograms (only if fill2dHistograms is true)
    // Store pairs of (histogram, target directory) so we can write to correct folder
    std::map<KLMChannelNumber, std::pair<TH2F*, TDirectory*>> tempHistBKLM;
    std::map<KLMChannelNumber, std::pair<TH2F*, TDirectory*>> tempHistEKLM;
 
    for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
      KLMChannelNumber channel = klmChannel.getKLMChannelNumber();
 
      // Skip if not in current batch
      if (!batch.second(klmChannel))
        continue;
 
      if (m_cFlag[channel] == ChannelCalibrationStatus::c_NotEnoughData)
        continue;
 
      if (m_evts.find(channel) == m_evts.end())
        continue;
 
      std::vector<struct Event> eventsChannel = m_evts[channel];
      int iSub = klmChannel.getSubdetector();
 
      // Create 2D histogram for this channel if needed
      TH2F* hist2d = nullptr;
      if (fill2dHistograms) {
        if (iSub == KLMElementNumbers::c_BKLM) {
          int iF = klmChannel.getSection();
          int iS = klmChannel.getSector() - 1;
          int iL = klmChannel.getLayer() - 1;
          int iP = klmChannel.getPlane();
          int iC = klmChannel.getStrip() - 1;
 
          // Only create for scintillators (layers 0-1)
          if (iL < 2) {
            TString hn = Form("time_length_bklm_F%d_S%d_L%d_P%d_C%d", iF, iS, iL, iP, iC);
            double stripLength = 200;
            hist2d = new TH2F(hn.Data(),
                              "Time versus propagation length; "
                              "propagation distance[cm]; "
                              "T_rec-T_0-T_fly-'T_calibration'[ns]",
                              50, 0.0, stripLength,
                              50, m_LowerTimeBoundaryCalibratedScintillatorsBKLM,
                              m_UpperTimeBoundaryCalibratedScintillatorsBKLM);
            tempHistBKLM[channel] = std::make_pair(hist2d, m_channelHistDir_BKLM[iF][iS][iL][iP]);
          }
        } else { // EKLM
          int iF = klmChannel.getSection() - 1;
          int iS = klmChannel.getSector() - 1;
          int iL = klmChannel.getLayer() - 1;
          int iP = klmChannel.getPlane() - 1;
          int iC = klmChannel.getStrip() - 1;
 
          TString hn = Form("time_length_eklm_F%d_S%d_L%d_P%d_C%d", iF, iS, iL, iP, iC);
          double stripLength = m_EKLMGeometry->getStripLength(iC + 1) / CLHEP::cm * Unit::cm;
          hist2d = new TH2F(hn.Data(),
                            "Time versus propagation length; "
                            "propagation distance[cm]; "
                            "T_rec-T_0-T_fly-'T_calibration'[ns]",
                            50, 0.0, stripLength,
                            50, m_LowerTimeBoundaryCalibratedScintillatorsEKLM,
                            m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
          tempHistEKLM[channel] = std::make_pair(hist2d, m_channelHistDir_EKLM[iF][iS][iL][iP]);
        }
      }
 
      // Fill histograms
      for (const Event& event : eventsChannel) {
        double timeHit = event.time() - m_timeShift[channel];
        if (m_useEventT0)
          timeHit = timeHit - event.t0;
        double distHit = event.dist;
 
        if (timeHit <= -400e3)
          continue;
 
        if (iSub == KLMElementNumbers::c_BKLM) {
          int iL = klmChannel.getLayer() - 1;
          int iP = klmChannel.getPlane();
 
          if (iL > 1) {
            // RPC
            if (iP) {
              profileRpcPhi->Fill(distHit, timeHit);
            } else {
              profileRpcZ->Fill(distHit, timeHit);
            }
          } else {
            // Scintillator
            if (m_applyChargeRestriction) {
              uint16_t Charge = event.getADCcount;
              if (Charge <= 30 || Charge >= 320) {
                continue;
              }
            }
 
            if (hist2d)
              hist2d->Fill(distHit, timeHit);
 
            if (iP) {
              profileBKLMScintillatorPhi->Fill(distHit, timeHit);
            } else {
              profileBKLMScintillatorZ->Fill(distHit, timeHit);
            }
          }
        } else {
          // EKLM
          if (m_applyChargeRestriction) {
            uint16_t Charge = event.getADCcount;
            if (Charge <= 40 || Charge >= 350) {
              continue;
            }
          }
 
          int iP = klmChannel.getPlane() - 1;
 
          if (hist2d)
            hist2d->Fill(distHit, timeHit);
 
          if (iP) {
            profileEKLMScintillatorPlane1->Fill(distHit, timeHit);
          } else {
            profileEKLMScintillatorPlane2->Fill(distHit, timeHit);
          }
        }
      }
    }
 
    // Write and delete 2D histograms for this batch
    // Use m_saveChannelHists (not m_saveAllPlots) since these are per-channel histograms
    // and the directories are created based on m_saveChannelHists
    if (fill2dHistograms) {
      for (auto& entry : tempHistBKLM) {
        writeThenDelete_(entry.second.first, m_saveChannelHists, entry.second.second);
      }
      for (auto& entry : tempHistEKLM) {
        writeThenDelete_(entry.second.first, m_saveChannelHists, entry.second.second);
      }
    }
 
    m_evts.clear();
    B2INFO("Batch processed and cleared: " << batch.first);
  }
 
  B2INFO("Time-distance profile filling complete.");
}

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.

{
  m_boundaries.clear();
  if (m_inputFileNames.empty()) {
    B2ERROR("There aren't any input files set. Please use CalibrationAlgorithm::setInputFiles()");
    return m_boundaries;
  }
  // Reset the internal execution data just in case something is hanging around
  m_data.reset();
  if (runs.empty()) {
    // Want to loop over all runs we could possibly know about
    runs = getRunListFromAllData();
  }
  // Let's check that we have some now
  if (runs.empty()) {
    B2ERROR("No collected data in input files.");
    return m_boundaries;
  }
  // In order to find run boundaries we must have collected with data granularity == 'run'
  if (strcmp(getGranularity().c_str(), "all") == 0) {
    B2ERROR("The data is collected with granularity='all' (exp=-1,run=-1), and we can't use that to find run boundaries.");
    return m_boundaries;
  }
  m_data.setIteration(iteration);
  // User defined setup function
  boundaryFindingSetup(runs, iteration);
  std::vector<ExpRun> runList;
  // Loop over run list and call derived class "isBoundaryRequired" member function
  for (auto currentRun : runs) {
    runList.push_back(currentRun);
    m_data.setRequestedRuns(runList);
    // After here, the getObject<...>(...) helpers start to work
    if (isBoundaryRequired(currentRun)) {
      m_boundaries.push_back(currentRun);
    }
    // Only want run-by-run
    runList.clear();
    // Don't want memory hanging around
    m_data.clearCalibrationData();
  }
  m_data.reset();
  boundaryFindingTearDown();
  return m_boundaries;
}

getAllGranularityExpRun()

Calibration::ExpRun getAllGranularityExpRun ( ) const

inlineprotectedinherited

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

Definition at line 327 of file CalibrationAlgorithm.h.

{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.

{return getPrefix();}

getDescription()

const std::string & getDescription ( ) const

inlineinherited

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

Definition at line 216 of file CalibrationAlgorithm.h.

{return m_description;}

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.

{
  string expRunString;
  expRunString += to_string(expRun.first);
  expRunString += ".";
  expRunString += to_string(expRun.second);
  return expRunString;
}

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.

{
  string dirName = getPrefix() + "/" + name;
  string objName = name + "_" + getExpRunString(expRun);
  return dirName + "/" + objName;
}

getGranularity()

std::string getGranularity ( ) const

inlineinherited

Get the granularity of collected data.

Definition at line 188 of file CalibrationAlgorithm.h.

{return m_granularityOfData;};

getGranularityFromData()

string getGranularityFromData ( ) const

protectedinherited

Get the granularity of collected data.

Definition at line 383 of file CalibrationAlgorithm.cc.

{
  // Save TDirectory to change back at the end
  TDirectory* dir = gDirectory;
  RunRange* runRange;
  string runRangeObjName(getPrefix() + "/" + RUN_RANGE_OBJ_NAME);
  // We only check the first file
  string fileName = m_inputFileNames[0];
  unique_ptr<TFile> f;
  f.reset(TFile::Open(fileName.c_str(), "READ"));
  runRange = dynamic_cast<RunRange*>(f->Get(runRangeObjName.c_str()));
  if (!runRange) {
    B2FATAL("The input file " << fileName << " does not contain a RunRange object at "
            << runRangeObjName << ". Please set your input files to exclude it.");
    return "";
  }
  string granularity = runRange->getGranularity();
  dir->cd();
  return granularity;
}

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.

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

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.

{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.

    {
      return m_jsonExecutionInput.at(key);
    }

getIovFromAllData()

IntervalOfValidity getIovFromAllData ( ) const

inherited

Get the complete IoV from inspection of collected data.

Definition at line 325 of file CalibrationAlgorithm.cc.

{
  return getRunRangeFromAllData().getIntervalOfValidity();
}

getIteration()

int getIteration ( ) const

inlineprotectedinherited

Get current iteration.

Definition at line 269 of file CalibrationAlgorithm.h.

{ return m_data.getIteration(); }

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.

    {
      if (m_runsToInputFiles.size() == 0)
        fillRunToInputFilesMap();
      return getObjectPtr<T>(name, m_data.getRequestedRuns());
    }

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.

    {
      return m_jsonExecutionOutput.at(key);
    }

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.

{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.

{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.

{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.

{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.

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

getRunRangeFromAllData()

RunRange getRunRangeFromAllData ( ) const

inherited

Get the complete RunRange from inspection of collected data.

Definition at line 361 of file CalibrationAlgorithm.cc.

{
  // Save TDirectory to change back at the end
  TDirectory* dir = gDirectory;
  RunRange runRange;
  // Construct the TDirectory name where we expect our objects to be
  string runRangeObjName(getPrefix() + "/" + RUN_RANGE_OBJ_NAME);
  for (const auto& fileName : m_inputFileNames) {
    //Open TFile to get the objects
    unique_ptr<TFile> f;
    f.reset(TFile::Open(fileName.c_str(), "READ"));
    RunRange* runRangeOther = dynamic_cast<RunRange*>(f->Get(runRangeObjName.c_str()));
    if (runRangeOther) {
      runRange.merge(runRangeOther);
    } else {
      B2WARNING("Missing a RunRange object for file: " << fileName);
    }
  }
  dir->cd();
  return runRange;
}

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.

{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.

{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.

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

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.

{
  try {
    auto jsonInput = nlohmann::json::parse(jsonString);
    // Input string has an object (dict) as the top level object?
    if (jsonInput.is_object()) {
      m_jsonExecutionInput = jsonInput;
      return true;
    } else {
      B2ERROR("JSON input string isn't an object type i.e. not a '{}' at the top level.");
      return false;
    }
  } catch (nlohmann::json::parse_error&) {
    B2ERROR("Parsing of JSON input string failed");
    return false;
  }
}

passesADCCut()

bool passesADCCut ( const Event & event, int subdetector, int layer ) const

private

Check if event passes ADC count cuts for quality selection.

Parameters

event	The event to check
subdetector	KLM subdetector (BKLM or EKLM)
layer	Layer number (to distinguish RPC from scintillator in BKLM)

Returns

true if event passes ADC cuts, false otherwise

Definition at line 1097 of file KLMTimeAlgorithm.cc.

{
  // If charge restriction is disabled, accept all hits
  if (!m_applyChargeRestriction) {
    return true;
  }
 
  uint16_t charge = event.getADCcount;
 
  if (subdetector == KLMElementNumbers::c_BKLM) {
    // FIXED: Use constant for RPC check (0-indexed comparison)
    if (layer_0indexed >= (BKLMElementNumbers::c_FirstRPCLayer - 1)) {
      return true;  // RPC - no ADC cut
    } else {
      return (charge > 30 && charge < 320);  // Scintillator
    }
  } else {
    return (charge > 40 && charge < 350);  // EKLM
  }
}

readCalibrationData()

CalibrationAlgorithm::EResult readCalibrationData ( )

private

Read calibration data.

Returns

CalibrationAlgorithm::c_OK if the amount of data is sufficient, CalibrationAlgorithm::c_NotEnoughData otherwise.

Definition at line 146 of file KLMTimeAlgorithm.cc.

{
  B2INFO("Read tree entries (initial data check only).");
  std::shared_ptr<TTree> timeCalibrationData;
  timeCalibrationData = getObjectPtr<TTree>("time_calibration_data");
 
  int n = timeCalibrationData->GetEntries();
  B2INFO(LogVar("Total number of digits:", n));
 
  if (n < m_MinimalDigitNumber)
    return CalibrationAlgorithm::c_NotEnoughData;
 
  return CalibrationAlgorithm::c_OK;
}

readCalibrationDataBatch()

void readCalibrationDataBatch ( std::function< bool(const KLMChannelIndex &)> channelFilter )

private

Load calibration data for a specific batch of channels.

Parameters

[in]

channelFilter

Function that returns true for channels in the batch.

Definition at line 237 of file KLMTimeAlgorithm.cc.

{
  B2INFO("Loading calibration data batch...");
  Event event;
  std::shared_ptr<TTree> timeCalibrationData;
  timeCalibrationData = getObjectPtr<TTree>("time_calibration_data");
  timeCalibrationData->SetBranchAddress("Run", &event.Run);
  timeCalibrationData->SetBranchAddress("Event", &event.Events);
  timeCalibrationData->SetBranchAddress("nTrack", &event.nTrack);
  timeCalibrationData->SetBranchAddress("Track_Charge", &event.Track_Charge);
 
  timeCalibrationData->SetBranchAddress("t0", &event.t0);
  timeCalibrationData->SetBranchAddress("t0_uc", &event.t0_uc);
  timeCalibrationData->SetBranchAddress("flyTime", &event.flyTime);
  timeCalibrationData->SetBranchAddress("recTime", &event.recTime);
  timeCalibrationData->SetBranchAddress("dist", &event.dist);
  timeCalibrationData->SetBranchAddress("diffDistX", &event.diffDistX);
  timeCalibrationData->SetBranchAddress("diffDistY", &event.diffDistY);
  timeCalibrationData->SetBranchAddress("diffDistZ", &event.diffDistZ);
  timeCalibrationData->SetBranchAddress("eDep", &event.eDep);
  timeCalibrationData->SetBranchAddress("nPE", &event.nPE);
  timeCalibrationData->SetBranchAddress("channelId", &event.channelId);
  timeCalibrationData->SetBranchAddress("inRPC", &event.inRPC);
  timeCalibrationData->SetBranchAddress("isFlipped", &event.isFlipped);
  timeCalibrationData->SetBranchAddress("isGood", &event.isGood);
  timeCalibrationData->SetBranchAddress("getADCcount", &event.getADCcount);
 
  m_evts.clear();
 
  int n = timeCalibrationData->GetEntries();
  int loadedEvents = 0;
 
  for (int i = 0; i < n; ++i) {
    timeCalibrationData->GetEntry(i);
 
    // Convert channel number to KLMChannelIndex using channelNumberToElementNumbers
    int subdetector, section, sector, layer, plane, strip;
    m_ElementNumbers->channelNumberToElementNumbers(
      event.channelId, &subdetector, &section, &sector, &layer, &plane, &strip);
    KLMChannelIndex klmChannel(subdetector, section, sector, layer, plane, strip);
 
    if (channelFilter(klmChannel)) {
      m_evts[event.channelId].push_back(event);
      loadedEvents++;
    }
  }
 
  B2INFO("Batch loaded." << LogVar("Events", loadedEvents) << LogVar("Channels", m_evts.size()));
}

readCalibrationDataCounts()

void readCalibrationDataCounts ( std::map< KLMChannelNumber, unsigned int > & eventCounts )

private

Count events per channel (lightweight scan without loading full data).

Parameters

[out]

eventCounts

Map from channel number to event count.

Definition at line 161 of file KLMTimeAlgorithm.cc.

{
  B2INFO("Counting events per channel (lightweight scan)...");
  Event event;
  std::shared_ptr<TTree> timeCalibrationData;
  timeCalibrationData = getObjectPtr<TTree>("time_calibration_data");
  timeCalibrationData->SetBranchAddress("channelId", &event.channelId);
 
  eventCounts.clear();
 
  int n = timeCalibrationData->GetEntries();
  for (int i = 0; i < n; ++i) {
    timeCalibrationData->GetEntry(i);
    eventCounts[event.channelId]++;
  }
 
  B2INFO("Event counting complete." << LogVar("Total events", n) << LogVar("Unique channels", eventCounts.size()));
}

readCalibrationDataFor2DFit()

void readCalibrationDataFor2DFit ( const std::vector< std::pair< KLMChannelNumber, unsigned int > > & channelsBKLM, const std::vector< std::pair< KLMChannelNumber, unsigned int > > & channelsEKLM )

private

Load calibration data only for channels needed for 2D fit.

Parameters

[in]	channelsBKLM	BKLM channels sorted by event count.
[in]	channelsEKLM	EKLM channels sorted by event count.

Definition at line 180 of file KLMTimeAlgorithm.cc.

{
  B2INFO("Loading data for 2D fit (top 1000 channels from BKLM and EKLM)...");
  Event event;
  std::shared_ptr<TTree> timeCalibrationData;
  timeCalibrationData = getObjectPtr<TTree>("time_calibration_data");
  timeCalibrationData->SetBranchAddress("Run", &event.Run);
  timeCalibrationData->SetBranchAddress("Event", &event.Events);
  timeCalibrationData->SetBranchAddress("nTrack", &event.nTrack);
  timeCalibrationData->SetBranchAddress("Track_Charge", &event.Track_Charge);
 
  timeCalibrationData->SetBranchAddress("t0", &event.t0);
  timeCalibrationData->SetBranchAddress("t0_uc", &event.t0_uc);
  timeCalibrationData->SetBranchAddress("flyTime", &event.flyTime);
  timeCalibrationData->SetBranchAddress("recTime", &event.recTime);
  timeCalibrationData->SetBranchAddress("dist", &event.dist);
  timeCalibrationData->SetBranchAddress("diffDistX", &event.diffDistX);
  timeCalibrationData->SetBranchAddress("diffDistY", &event.diffDistY);
  timeCalibrationData->SetBranchAddress("diffDistZ", &event.diffDistZ);
  timeCalibrationData->SetBranchAddress("eDep", &event.eDep);
  timeCalibrationData->SetBranchAddress("nPE", &event.nPE);
  timeCalibrationData->SetBranchAddress("channelId", &event.channelId);
  timeCalibrationData->SetBranchAddress("inRPC", &event.inRPC);
  timeCalibrationData->SetBranchAddress("isFlipped", &event.isFlipped);
  timeCalibrationData->SetBranchAddress("isGood", &event.isGood);
  timeCalibrationData->SetBranchAddress("getADCcount", &event.getADCcount);
 
  m_evts.clear();
 
  // Build set of channels we need for 2D fit (top 1000 from each)
  std::set<KLMChannelNumber> neededChannels;
  int maxChannels = 1000;
 
  for (size_t i = 0; i < channelsBKLM.size() && i < static_cast<size_t>(maxChannels); ++i) {
    neededChannels.insert(channelsBKLM[i].first);
  }
  for (size_t i = 0; i < channelsEKLM.size() && i < static_cast<size_t>(maxChannels); ++i) {
    neededChannels.insert(channelsEKLM[i].first);
  }
 
  int n = timeCalibrationData->GetEntries();
  int loadedEvents = 0;
 
  for (int i = 0; i < n; ++i) {
    timeCalibrationData->GetEntry(i);
 
    if (neededChannels.find(event.channelId) != neededChannels.end()) {
      m_evts[event.channelId].push_back(event);
      loadedEvents++;
    }
  }
 
  B2INFO("2D fit data loaded." << LogVar("Events", loadedEvents) << LogVar("Channels", m_evts.size()));
}

resetInputJson()

void resetInputJson ( )

inlineprotectedinherited

Clears the m_inputJson member variable.

Definition at line 330 of file CalibrationAlgorithm.h.

{m_jsonExecutionInput.clear();}

resetOutputJson()

void resetOutputJson ( )

inlineprotectedinherited

Clears the m_outputJson member variable.

Definition at line 333 of file CalibrationAlgorithm.h.

{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.

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

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.

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

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.

{
  saveCalibration(data, DataStore::objectName(data->IsA(), ""));
}

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.

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

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.

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

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.

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

saveHist()

void saveHist

(

)

Save histograms to file.

Definition at line 2407 of file KLMTimeAlgorithm.cc.

{
  m_outFile->cd();
  B2INFO("Save Histograms into Files.");
 
  /* Save vital plots. */
  TDirectory* dir_monitor = m_outFile->mkdir("monitor_Hists", "", true);
  dir_monitor->cd();
  h_calibrated->SetDirectory(dir_monitor);
  hc_calibrated->SetDirectory(dir_monitor);
  h_diff->SetDirectory(dir_monitor);
 
  m_outFile->cd();
  TDirectory* dir_eventT0 = m_outFile->mkdir("EventT0", "", true);
  dir_eventT0->cd();
 
  // Original histograms
  h_eventT0_rpc->SetDirectory(dir_eventT0);
  h_eventT0_scint->SetDirectory(dir_eventT0);
  h_eventT0_scint_end->SetDirectory(dir_eventT0);
 
  hc_eventT0_rpc->SetDirectory(dir_eventT0);
  hc_eventT0_scint->SetDirectory(dir_eventT0);
  hc_eventT0_scint_end->SetDirectory(dir_eventT0);
 
  // ==== NEW DIAGNOSTIC PLOTS ====
 
  // Hit multiplicity
  h_nHits_plus_rpc->SetDirectory(dir_eventT0);
  h_nHits_minus_rpc->SetDirectory(dir_eventT0);
  h_nHits_plus_scint->SetDirectory(dir_eventT0);
  h_nHits_minus_scint->SetDirectory(dir_eventT0);
  h_nHits_plus_scint_end->SetDirectory(dir_eventT0);
  h_nHits_minus_scint_end->SetDirectory(dir_eventT0);
 
  // ΔT0 vs v
  h2_deltaT0_vs_v_rpc->SetDirectory(dir_eventT0);
  h2_deltaT0_vs_v_scint->SetDirectory(dir_eventT0);
  h2_deltaT0_vs_v_scint_end->SetDirectory(dir_eventT0);
 
  // Profile plots
  prof_deltaT0_rms_vs_v_rpc->SetDirectory(dir_eventT0);
  prof_deltaT0_rms_vs_v_scint->SetDirectory(dir_eventT0);
  prof_deltaT0_rms_vs_v_scint_end->SetDirectory(dir_eventT0);
 
  // ΔT0 vs total hits
  h2_deltaT0_vs_nhits_rpc->SetDirectory(dir_eventT0);
  h2_deltaT0_vs_nhits_scint->SetDirectory(dir_eventT0);
  h2_deltaT0_vs_nhits_scint_end->SetDirectory(dir_eventT0);
 
  // Multiplicity-binned ΔT0
  hc_eventT0_rpc_lowN->SetDirectory(dir_eventT0);
  hc_eventT0_rpc_midN->SetDirectory(dir_eventT0);
  hc_eventT0_rpc_highN->SetDirectory(dir_eventT0);
  hc_eventT0_scint_lowN->SetDirectory(dir_eventT0);
  hc_eventT0_scint_midN->SetDirectory(dir_eventT0);
  hc_eventT0_scint_highN->SetDirectory(dir_eventT0);
  hc_eventT0_scint_end_lowN->SetDirectory(dir_eventT0);
  hc_eventT0_scint_end_midN->SetDirectory(dir_eventT0);
  hc_eventT0_scint_end_highN->SetDirectory(dir_eventT0);
 
  m_outFile->cd();
  TDirectory* dir_effC = m_outFile->mkdir("effC_Hists", "", true);
  dir_effC->cd();
  m_ProfileRpcPhi->SetDirectory(dir_effC);
  m_ProfileRpcZ->SetDirectory(dir_effC);
  m_ProfileBKLMScintillatorPhi->SetDirectory(dir_effC);
  m_ProfileBKLMScintillatorZ->SetDirectory(dir_effC);
  m_ProfileEKLMScintillatorPlane1->SetDirectory(dir_effC);
  m_ProfileEKLMScintillatorPlane2->SetDirectory(dir_effC);
  m_Profile2RpcPhi->SetDirectory(dir_effC);
  m_Profile2RpcZ->SetDirectory(dir_effC);
  m_Profile2BKLMScintillatorPhi->SetDirectory(dir_effC);
  m_Profile2BKLMScintillatorZ->SetDirectory(dir_effC);
  m_Profile2EKLMScintillatorPlane1->SetDirectory(dir_effC);
  m_Profile2EKLMScintillatorPlane2->SetDirectory(dir_effC);
 
  m_outFile->cd();
  TDirectory* dir_time = m_outFile->mkdir("time", "", true);
  dir_time->cd();
 
  h_time_scint->SetDirectory(dir_time);
  hc_time_scint->SetDirectory(dir_time);
 
  h_time_scint_end->SetDirectory(dir_time);
  hc_time_scint_end->SetDirectory(dir_time);
 
  h_time_rpc->SetDirectory(dir_time);
  hc_time_rpc->SetDirectory(dir_time);
 
  gre_time_channel_rpc->Write("gre_time_channel_rpc");
  gre_time_channel_scint->Write("gre_time_channel_scint");
  gre_time_channel_scint_end->Write("gre_time_channel_scint_end");
  gr_timeShift_channel_rpc->Write("gr_timeShift_channel_rpc");
  gr_timeShift_channel_scint->Write("gr_timeShift_channel_scint");
  gr_timeShift_channel_scint_end->Write("gr_timeShift_channel_scint_end");
  gre_ctime_channel_rpc->Write("gre_ctime_channel_rpc");
  gre_ctime_channel_scint->Write("gre_ctime_channel_scint");
  gre_ctime_channel_scint_end->Write("gre_ctime_channel_scint_end");
  gr_timeRes_channel_rpc->Write("gr_timeRes_channel_rpc");
  gr_timeRes_channel_scint->Write("gr_timeRes_channel_scint");
  gr_timeRes_channel_scint_end->Write("gr_timeRes_channel_scint_end");
 
  B2INFO("Top file setup Done.");
 
  /* Save debug plots (only if m_saveAllPlots is true). */
  if (!m_saveAllPlots) {
    B2INFO("Skipping debug histogram directory creation (m_saveAllPlots = false)");
    m_outFile->cd();
    m_outFile->Write();
    m_outFile->Close();
    B2INFO("File Write and Close. Done.");
    return;
  }
 
  TDirectory* dir_time_F[2];
  TDirectory* dir_time_FS[2][8];
  TDirectory* dir_time_FSL[2][8][15];
  TDirectory* dir_time_FSLP[2][8][15][2];
  TDirectory* dir_time_F_end[2];
  TDirectory* dir_time_FS_end[2][4];
  TDirectory* dir_time_FSL_end[2][4][14];
  TDirectory* dir_time_FSLP_end[2][4][14][2];
  char dirname[50];
  B2INFO("Sub files declare Done.");
  for (int iF = 0; iF < 2; ++iF) {
    h_timeF_rpc[iF]->SetDirectory(dir_time);
    hc_timeF_rpc[iF]->SetDirectory(dir_time);
 
    h2_timeF_rpc[iF]->SetDirectory(dir_time);
    h2c_timeF_rpc[iF]->SetDirectory(dir_time);
 
    h_timeF_scint[iF]->SetDirectory(dir_time);
    hc_timeF_scint[iF]->SetDirectory(dir_time);
 
    h2_timeF_scint[iF]->SetDirectory(dir_time);
    h2c_timeF_scint[iF]->SetDirectory(dir_time);
 
    h_timeF_scint_end[iF]->SetDirectory(dir_time);
    hc_timeF_scint_end[iF]->SetDirectory(dir_time);
 
    h2_timeF_scint_end[iF]->SetDirectory(dir_time);
    h2c_timeF_scint_end[iF]->SetDirectory(dir_time);
 
    sprintf(dirname, "isForward_%d", iF);
    dir_time_F[iF] = dir_time->mkdir(dirname, "", true);
    dir_time_F[iF]->cd();
 
    for (int iS = 0; iS < 8; ++iS) {
      h_timeFS_rpc[iF][iS]->SetDirectory(dir_time_F[iF]);
      hc_timeFS_rpc[iF][iS]->SetDirectory(dir_time_F[iF]);
 
      h_timeFS_scint[iF][iS]->SetDirectory(dir_time_F[iF]);
      hc_timeFS_scint[iF][iS]->SetDirectory(dir_time_F[iF]);
 
      h2_timeFS[iF][iS]->SetDirectory(dir_time_F[iF]);
      h2c_timeFS[iF][iS]->SetDirectory(dir_time_F[iF]);
 
      sprintf(dirname, "Sector_%d", iS + 1);
      dir_time_FS[iF][iS] = dir_time_F[iF]->mkdir(dirname, "", true);
      dir_time_FS[iF][iS]->cd();
 
      for (int iL = 0; iL < 15; ++iL) {
        h_timeFSL[iF][iS][iL]->SetDirectory(dir_time_FS[iF][iS]);
        hc_timeFSL[iF][iS][iL]->SetDirectory(dir_time_FS[iF][iS]);
 
        sprintf(dirname, "Layer_%d", iL + 1);
        dir_time_FSL[iF][iS][iL] = dir_time_FS[iF][iS]->mkdir(dirname, "", true);
        dir_time_FSL[iF][iS][iL]->cd();
        for (int iP = 0; iP < 2; ++iP) {
          h_timeFSLP[iF][iS][iL][iP]->SetDirectory(dir_time_FSL[iF][iS][iL]);
          hc_timeFSLP[iF][iS][iL][iP]->SetDirectory(dir_time_FSL[iF][iS][iL]);
          h2_timeFSLP[iF][iS][iL][iP]->SetDirectory(dir_time_FSL[iF][iS][iL]);
          h2c_timeFSLP[iF][iS][iL][iP]->SetDirectory(dir_time_FSL[iF][iS][iL]);
 
          sprintf(dirname, "Plane_%d", iP);
          dir_time_FSLP[iF][iS][iL][iP] = dir_time_FSL[iF][iS][iL]->mkdir(dirname, "", true);
          dir_time_FSLP[iF][iS][iL][iP]->cd();
 
        }
      }
    }
 
    sprintf(dirname, "isForward_%d_end", iF + 1);
    dir_time_F_end[iF] = dir_time->mkdir(dirname, "", true);
    dir_time_F_end[iF]->cd();
    int maxLayer = 12 + 2 * iF;
    for (int iS = 0; iS < 4; ++iS) {
      h_timeFS_scint_end[iF][iS]->SetDirectory(dir_time_F_end[iF]);
      hc_timeFS_scint_end[iF][iS]->SetDirectory(dir_time_F_end[iF]);
 
      h2_timeFS_end[iF][iS]->SetDirectory(dir_time_F_end[iF]);
      h2c_timeFS_end[iF][iS]->SetDirectory(dir_time_F_end[iF]);
 
      sprintf(dirname, "Sector_%d_end", iS + 1);
      dir_time_FS_end[iF][iS] = dir_time_F_end[iF]->mkdir(dirname, "", true);
      dir_time_FS_end[iF][iS]->cd();
      for (int iL = 0; iL < maxLayer; ++iL) {
        h_timeFSL_end[iF][iS][iL]->SetDirectory(dir_time_FS_end[iF][iS]);
        hc_timeFSL_end[iF][iS][iL]->SetDirectory(dir_time_FS_end[iF][iS]);
 
        sprintf(dirname, "Layer_%d_end", iL + 1);
        dir_time_FSL_end[iF][iS][iL] = dir_time_FS_end[iF][iS]->mkdir(dirname, "", true);
        dir_time_FSL_end[iF][iS][iL]->cd();
        for (int iP = 0; iP < 2; ++iP) {
          h_timeFSLP_end[iF][iS][iL][iP]->SetDirectory(dir_time_FSL_end[iF][iS][iL]);
          hc_timeFSLP_end[iF][iS][iL][iP]->SetDirectory(dir_time_FSL_end[iF][iS][iL]);
          h2_timeFSLP_end[iF][iS][iL][iP]->SetDirectory(dir_time_FSL_end[iF][iS][iL]);
          h2c_timeFSLP_end[iF][iS][iL][iP]->SetDirectory(dir_time_FSL_end[iF][iS][iL]);
 
          sprintf(dirname, "plane_%d_end", iP);
          dir_time_FSLP_end[iF][iS][iL][iP] = dir_time_FSL_end[iF][iS][iL]->mkdir(dirname, "", true);
          dir_time_FSLP_end[iF][iS][iL][iP]->cd();
 
        }
      }
    }
  }
  m_outFile->cd();
  m_outFile->Write();
  m_outFile->Close();
  B2INFO("File Write and Close. Done.");
}

setApplyChargeRestriction()

void setApplyChargeRestriction ( bool apply )

inline

Enable or disable ADC/charge restriction cuts for scintillators.

When enabled (default), BKLM scintillator requires 30 < ADC < 320 and EKLM requires 40 < ADC < 350.

Parameters

[in]

apply

True to apply charge cuts (default), false to disable.

Definition at line 202 of file KLMTimeAlgorithm.h.

    {
      m_applyChargeRestriction = apply;
    }

setDebug()

void setDebug ( )

inline

Turn on debug mode (prints histograms and output running log).

Definition at line 155 of file KLMTimeAlgorithm.h.

    {
      m_debug = true;
    }

setDescription()

void setDescription ( const std::string & description )

inlineprotectedinherited

Set algorithm description (in constructor)

Definition at line 321 of file CalibrationAlgorithm.h.

{m_description = description;}

setInputFileNames() [1/2]

void setInputFileNames ( PyObject * inputFileNames )

inherited

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

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

Definition at line 166 of file CalibrationAlgorithm.cc.

{
  // The reasoning for this very 'manual' approach to extending the Python interface
  // (instead of using boost::python) is down to my fear of putting off final users with
  // complexity on their side.
  //
  // I didn't want users that inherit from this class to be forced to use boost and
  // to have to define a new python module just to use the CAF. A derived class from
  // from a boost exposed class would need to have its own boost python module definition
  // to allow access from a steering file and to the base class functions (I think).
  // I also couldn't be bothered to write a full framework to get around the issue in a similar
  // way to Module()...maybe there's an easy way.
  //
  // But this way we can allow people to continue using their ROOT implemented classes and inherit
  // easily from this one. But add in a few helper functions that work with Python objects
  // created in their steering file i.e. instead of being forced to use STL objects as input
  // to the algorithm.
  if (PyList_Check(inputFileNames)) {
    boost::python::handle<> handle(boost::python::borrowed(inputFileNames));
    boost::python::list listInputFileNames(handle);
    auto vecInputFileNames = PyObjConvUtils::convertPythonObject(listInputFileNames, vector<string>());
    setInputFileNames(vecInputFileNames);
  } else {
    B2ERROR("Tried to set the input files but we didn't receive a Python list.");
  }
}

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.

{
  // A lot of code below is tweaked from RootInputModule::initialize,
  // since we're basically copying the functionality anyway.
  if (inputFileNames.empty()) {
    B2WARNING("You have called setInputFileNames() with an empty list. Did you mean to do that?");
    return;
  }
  auto tmpInputFileNames = RootIOUtilities::expandWordExpansions(inputFileNames);
 
  // We'll use a set to enforce sorted unique file paths as we check them
  set<string> setInputFileNames;
  // Check that files exist and convert to absolute paths
  for (auto path : tmpInputFileNames) {
    string fullPath = fs::absolute(path).string();
    if (fs::exists(fullPath)) {
      setInputFileNames.insert(fs::canonical(fullPath).string());
    } else {
      B2WARNING("Couldn't find the file " << path);
    }
  }
 
  if (setInputFileNames.empty()) {
    B2WARNING("No valid files specified!");
    return;
  } else {
    // Reset the run -> files map as our files are likely different
    m_runsToInputFiles.clear();
  }
 
  // Open TFile to check they can be accessed by ROOT
  TDirectory* dir = gDirectory;
  for (const string& fileName : setInputFileNames) {
    unique_ptr<TFile> f;
    try {
      f.reset(TFile::Open(fileName.c_str(), "READ"));
    } catch (logic_error&) {
      //this might happen for ~invaliduser/foo.root
      //actually undefined behaviour per standard, reported as ROOT-8490 in JIRA
    }
    if (!f || !f->IsOpen()) {
      B2FATAL("Couldn't open input file " + fileName);
    }
  }
  dir->cd();
 
  // Copy the entries of the set to a vector
  m_inputFileNames = vector<string>(setInputFileNames.begin(), setInputFileNames.end());
  m_granularityOfData = getGranularityFromData();
}

setLowerLimit()

void setLowerLimit ( int counts )

inline

Set the lower number of hits collected on one single strip.

If the hit number is lower than the limit, the strip will not be calibrated and set the average value of the calibration constant.

Definition at line 191 of file KLMTimeAlgorithm.h.

    {
      m_lower_limit_counts = counts;
    }

setMC()

void setMC ( bool mc )

inline

Set flag indicating whether the input is MC sample.

The histogram ranges are different for data and MC. This setting cannot be determined automatically, because the collector output does not contain metadata.

Definition at line 165 of file KLMTimeAlgorithm.h.

    {
      m_mc = mc;
    }

setMinimalDigitNumber()

void setMinimalDigitNumber ( int minimalDigitNumber )

inline

Set minimal digit number (total).

Definition at line 181 of file KLMTimeAlgorithm.h.

    {
      m_MinimalDigitNumber = minimalDigitNumber;
    }

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.

{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.

{m_prefix = prefix;}

setSaveAllPlots()

void setSaveAllPlots ( bool on )

inline

Save every preallocated debug histogram family (sectors/layers/planes/2D maps).

Default is false (minimal mode).

Definition at line 211 of file KLMTimeAlgorithm.h.

    {
      m_saveAllPlots = on;
    }

setSaveChannelHists()

void setSaveChannelHists ( bool on )

inline

When running in minimal mode, also write the per-channel temporary histograms (the vital tc, raw, hc 1D’s created on-the-fly) before deleting them.

Default is false.

Definition at line 221 of file KLMTimeAlgorithm.h.

    {
      m_saveChannelHists = on;
    }

setupDatabase()

void setupDatabase ( )

private

Setup the database.

Definition at line 108 of file KLMTimeAlgorithm.cc.

{
  const std::vector<Calibration::ExpRun>& runs = getRunList();
  int firstExperiment = runs[0].first;
  int lastExperiment = runs[runs.size() - 1].first;
  if (firstExperiment != lastExperiment) {
    B2FATAL("Runs from different experiments are used "
            "for KLM time calibration (single algorithm run).");
  }
  /* DataStore. */
  DataStore::Instance().setInitializeActive(true);
  StoreObjPtr<EventMetaData> eventMetaData;
  eventMetaData.registerInDataStore();
  DataStore::Instance().setInitializeActive(false);
  /* Database. */
  if (eventMetaData.isValid()) {
    if (eventMetaData->getExperiment() != firstExperiment) {
      B2FATAL("Runs from different experiments are used "
              "for KLM time calibration (consecutive algorithm runs).");
    }
    eventMetaData->setExperiment(firstExperiment);
    eventMetaData->setRun(runs[0].second);
  } else {
    eventMetaData.construct(1, runs[0].second, firstExperiment);
  }
  DBStore& dbStore = DBStore::Instance();
  dbStore.update();
  dbStore.updateEvent();
  /*
   * For calibration algorithms, the database is not initialized on class
   * creation. Do not move the database object to class members.
   */
  DBObjPtr<BKLMGeometryPar> bklmGeometry;
  m_BKLMGeometry = bklm::GeometryPar::instance(*bklmGeometry);
  m_EKLMGeometry = &(EKLM::GeometryData::Instance());
}

timeDistance2dFit()

void timeDistance2dFit ( const std::vector< std::pair< KLMChannelNumber, unsigned int > > & channels, double & delay, double & delayError )

private

Two-dimensional fit for individual channels.

Parameters

[in]	channels	Channels.
[out]	delay	Delay (ns / cm).
[out]	delayError	Delay error.

Definition at line 971 of file KLMTimeAlgorithm.cc.

{
  std::vector<struct Event> eventsChannel;
  int nFits = 1000;
  int nConvergedFits = 0;
  delay = 0;
  delayError = 0;
  if (nFits > (int)channels.size())
    nFits = channels.size();
  for (int i = 0; i < nFits; ++i) {
    int subdetector, section, sector, layer, plane, strip;
    m_ElementNumbers->channelNumberToElementNumbers(
      channels[i].first, &subdetector, &section, &sector, &layer, &plane,
      &strip);
    if (subdetector == KLMElementNumbers::c_BKLM) {
      s_LowerTimeBoundary = m_LowerTimeBoundaryScintillatorsBKLM;
      s_UpperTimeBoundary = m_UpperTimeBoundaryScintillatorsBKLM;
      const bklm::Module* module =
        m_BKLMGeometry->findModule(section, sector, layer);
      s_StripLength = module->getStripLength(plane, strip);
    } else {
      s_LowerTimeBoundary = m_LowerTimeBoundaryScintillatorsEKLM;
      s_UpperTimeBoundary = m_UpperTimeBoundaryScintillatorsEKLM;
      s_StripLength = m_EKLMGeometry->getStripLength(strip) /
                      CLHEP::cm * Unit::cm;
    }
    for (int j = 0; j < c_NBinsTime; ++j) {
      for (int k = 0; k < c_NBinsDistance; ++k)
        s_BinnedData[j][k] = 0;
    }
    eventsChannel = m_evts[channels[i].first];
    double averageTime = 0;
    for (const Event& event : eventsChannel) {
      double timeHit = event.time();
      if (m_useEventT0)
        timeHit = timeHit - event.t0;
 
      if (timeHit <= -400e3) {
        continue;
      }
 
      averageTime = averageTime + timeHit;
      int timeBin = std::floor((timeHit - s_LowerTimeBoundary) * c_NBinsTime /
                               (s_UpperTimeBoundary - s_LowerTimeBoundary));
      if (timeBin < 0 || timeBin >= c_NBinsTime)
        continue;
      int distanceBin = std::floor(event.dist * c_NBinsDistance / s_StripLength);
      if (distanceBin < 0 || distanceBin >= c_NBinsDistance) {
        B2ERROR("The distance to SiPM is greater than the strip length.");
        continue;
      }
      s_BinnedData[timeBin][distanceBin] += 1;
    }
    averageTime = averageTime / eventsChannel.size();
    TMinuit minuit(5);
    minuit.SetPrintLevel(-1);
    int minuitResult;
    minuit.mnparm(0, "P0", 1, 0.001, 0, 0, minuitResult);
    minuit.mnparm(1, "N", 10, 0.001, 0, 0, minuitResult);
    minuit.mnparm(2, "T0", averageTime, 0.001, 0, 0, minuitResult);
    minuit.mnparm(3, "SIGMA", 10, 0.001, 0, 0, minuitResult);
    minuit.mnparm(4, "DELAY", 0.0, 0.001, 0, 0, minuitResult);
    minuit.SetFCN(fcn);
    minuit.mncomd("FIX 2 3 4 5", minuitResult);
    minuit.mncomd("MIGRAD 10000", minuitResult);
    minuit.mncomd("RELEASE 2", minuitResult);
    minuit.mncomd("MIGRAD 10000", minuitResult);
    minuit.mncomd("RELEASE 3", minuitResult);
    minuit.mncomd("MIGRAD 10000", minuitResult);
    minuit.mncomd("RELEASE 4", minuitResult);
    minuit.mncomd("MIGRAD 10000", minuitResult);
    minuit.mncomd("RELEASE 5", minuitResult);
    minuit.mncomd("MIGRAD 10000", minuitResult);
    /* Require converged fit with accurate error matrix. */
    if (minuit.fISW[1] != 3)
      continue;
    nConvergedFits++;
    double channelDelay, channelDelayError;
    minuit.GetParameter(4, channelDelay, channelDelayError);
    delay = delay + channelDelay;
    delayError = delayError + channelDelayError * channelDelayError;
  }
  delay = delay / nConvergedFits;
  delayError = sqrt(delayError) / (nConvergedFits - 1);
}

tR_lowerStrip()

std::pair< int, double > tR_lowerStrip

(

const KLMChannelIndex &

klmChannel

)

Tracing available channels with decreasing strip number.

Parameters

[in]

klmChannel

KLM channel index.

Definition at line 2768 of file KLMTimeAlgorithm.cc.

{
  std::pair<int, double> tR;
  int cId = klmChannel.getKLMChannelNumber();
  int iSub = klmChannel.getSubdetector();
  int iF = klmChannel.getSection();
  int iS = klmChannel.getSector();
  int iL = klmChannel.getLayer();
  int iP = klmChannel.getPlane();
  int iC = klmChannel.getStrip();
  if (m_timeRes.find(cId) != m_timeRes.end()) {
    tR.first = iC;
    tR.second = m_timeRes[cId];
  } else if (iC == 1) {
    tR.first = iC;
    tR.second = 0.0;
  } else {
    KLMChannelIndex kCIndex(iSub, iF, iS, iL, iP, iC - 1);
    tR = tR_lowerStrip(kCIndex);
  }
  return tR;
}

tR_upperStrip()

std::pair< int, double > tR_upperStrip

(

const KLMChannelIndex &

klmChannel

)

Tracing available channels with increasing strip number.

Parameters

[in]

klmChannel

KLM channel index.

Definition at line 2742 of file KLMTimeAlgorithm.cc.

{
  std::pair<int, double> tR;
  int cId = klmChannel.getKLMChannelNumber();
  int iSub = klmChannel.getSubdetector();
  int iF = klmChannel.getSection();
  int iS = klmChannel.getSector();
  int iL = klmChannel.getLayer();
  int iP = klmChannel.getPlane();
  int iC = klmChannel.getStrip();
  int totNStrips = EKLMElementNumbers::getMaximalStripNumber();
  if (iSub == KLMElementNumbers::c_BKLM)
    totNStrips = BKLMElementNumbers::getNStrips(iF, iS, iL, iP);
  if (m_timeRes.find(cId) != m_timeRes.end()) {
    tR.first = iC;
    tR.second = m_timeRes[cId];
  } else if (iC == totNStrips) {
    tR.first = iC;
    tR.second = 0.0;
  } else {
    KLMChannelIndex kCIndex(iSub, iF, iS, iL, iP, iC + 1);
    tR = tR_upperStrip(kCIndex);
  }
  return tR;
}

tS_lowerStrip()

std::pair< int, double > tS_lowerStrip

(

const KLMChannelIndex &

klmChannel

)

Tracing available channels with decreasing strip number.

Parameters

[in]

klmChannel

KLM channel index.

Definition at line 2688 of file KLMTimeAlgorithm.cc.

{
  std::pair<int, double> tS;
  int cId = klmChannel.getKLMChannelNumber();
  int iSub = klmChannel.getSubdetector();
  int iF = klmChannel.getSection();
  int iS = klmChannel.getSector();
  int iL = klmChannel.getLayer();
  int iP = klmChannel.getPlane();
  int iC = klmChannel.getStrip();
  if (m_timeShift.find(cId) != m_timeShift.end()) {
    tS.first = iC;
    tS.second = m_timeShift[cId];
  } else if (iC == 1) {
    tS.first = iC;
    tS.second = 0.0;
  } else {
    KLMChannelIndex kCIndex(iSub, iF, iS, iL, iP, iC - 1);
    tS = tS_lowerStrip(kCIndex);
  }
  return tS;
}

tS_upperStrip()

std::pair< int, double > tS_upperStrip

(

const KLMChannelIndex &

klmChannel

)

Tracing available channels with increasing strip number.

Parameters

[in]

klmChannel

KLM channel index.

Definition at line 2662 of file KLMTimeAlgorithm.cc.

{
  std::pair<int, double> tS;
  int cId = klmChannel.getKLMChannelNumber();
  int iSub = klmChannel.getSubdetector();
  int iF = klmChannel.getSection();
  int iS = klmChannel.getSector();
  int iL = klmChannel.getLayer();
  int iP = klmChannel.getPlane();
  int iC = klmChannel.getStrip();
  int totNStrips = EKLMElementNumbers::getMaximalStripNumber();
  if (iSub == KLMElementNumbers::c_BKLM)
    totNStrips = BKLMElementNumbers::getNStrips(iF, iS, iL, iP);
  if (m_timeShift.find(cId) != m_timeShift.end()) {
    tS.first = iC;
    tS.second = m_timeShift[cId];
  } else if (iC == totNStrips) {
    tS.first = iC;
    tS.second = 0.0;
  } else {
    KLMChannelIndex kCIndex(iSub, iF, iS, iL, iP, iC + 1);
    tS = tS_upperStrip(kCIndex);
  }
  return tS;
}

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.

{
  // Construct an EventMetaData object but NOT in the Datastore
  EventMetaData emd(event, run, experiment);
  // Explicitly update while avoiding registering a Datastore object
  DBStore::Instance().update(emd);
  // Also update the intra-run objects to the event at the same time (maybe unnecessary...)
  DBStore::Instance().updateEvent(event);
}

useEvtT0()

void useEvtT0 ( )

inline

Use event T0 as the initial time point or not.

Definition at line 173 of file KLMTimeAlgorithm.h.

    {
      m_useEventT0 = true;
    }

writeThenDelete_() [1/2]

void writeThenDelete_ ( TH1 * h, bool write, TDirectory * dir = nullptr )

private

Optionally write a histogram, then delete it to free memory.

Used for on-the-fly per-channel hists in minimal mode.

Parameters

h	Histogram to write and delete.
write	Whether to write the histogram.
dir	Optional directory to write the histogram to.

Definition at line 1059 of file KLMTimeAlgorithm.cc.

{
  if (h == nullptr)
    return;
  if (write && m_outFile) {
    // Follow the pattern from saveHist(): cd into directory, then SetDirectory, then Write
    if (dir) {
      dir->cd();
      h->SetDirectory(dir);
    } else {
      m_outFile->cd();
      h->SetDirectory(m_outFile);
    }
    h->Write();
    m_outFile->cd();  // Return to root directory
  }
  delete h;
}

writeThenDelete_() [2/2]

void writeThenDelete_ ( TH2 * h, bool write, TDirectory * dir = nullptr )

private

Same as above, but for 2D histograms.

Definition at line 1078 of file KLMTimeAlgorithm.cc.

{
  if (h == nullptr)
    return;
  if (write && m_outFile) {
    // Follow the pattern from saveHist(): cd into directory, then SetDirectory, then Write
    if (dir) {
      dir->cd();
      h->SetDirectory(dir);
    } else {
      m_outFile->cd();
      h->SetDirectory(m_outFile);
    }
    h->Write();
    m_outFile->cd();  // Return to root directory
  }
  delete h;
}

Member Data Documentation

fcn_const

TF1* fcn_const = nullptr

private

Const function.

Global time distribution fitting.

Definition at line 958 of file KLMTimeAlgorithm.h.

fcn_gaus

TF1* fcn_gaus = nullptr

private

Gaussian function.

Scitillator time distribution fitting.

Definition at line 961 of file KLMTimeAlgorithm.h.

fcn_land

TF1* fcn_land = nullptr

private

Landau function.

RPC time distribution fitting.

Definition at line 964 of file KLMTimeAlgorithm.h.

fcn_pol1

TF1* fcn_pol1 = nullptr

private

Pol1 function.

Effective light speed fitting.

Definition at line 955 of file KLMTimeAlgorithm.h.

gr_timeRes_channel_rpc

TGraph* gr_timeRes_channel_rpc = nullptr

private

BKLM RPC.

Definition at line 596 of file KLMTimeAlgorithm.h.

gr_timeRes_channel_scint

TGraph* gr_timeRes_channel_scint = nullptr

private

BKLM scintillator.

Definition at line 599 of file KLMTimeAlgorithm.h.

gr_timeRes_channel_scint_end

TGraph* gr_timeRes_channel_scint_end = nullptr

private

EKLM.

Definition at line 602 of file KLMTimeAlgorithm.h.

gr_timeShift_channel_rpc

TGraph* gr_timeShift_channel_rpc = nullptr

private

BKLM RPC.

Definition at line 585 of file KLMTimeAlgorithm.h.

gr_timeShift_channel_scint

TGraph* gr_timeShift_channel_scint = nullptr

private

BKLM scintillator.

Definition at line 588 of file KLMTimeAlgorithm.h.

gr_timeShift_channel_scint_end

TGraph* gr_timeShift_channel_scint_end = nullptr

private

EKLM.

Definition at line 591 of file KLMTimeAlgorithm.h.

gre_ctime_channel_rpc

TGraphErrors* gre_ctime_channel_rpc = nullptr

private

BKLM RPC.

Definition at line 574 of file KLMTimeAlgorithm.h.

gre_ctime_channel_scint

TGraphErrors* gre_ctime_channel_scint = nullptr

private

BKLM Scintillator.

Definition at line 577 of file KLMTimeAlgorithm.h.

gre_ctime_channel_scint_end

TGraphErrors* gre_ctime_channel_scint_end = nullptr

private

EKLM.

Definition at line 580 of file KLMTimeAlgorithm.h.

gre_time_channel_rpc

TGraphErrors* gre_time_channel_rpc = nullptr

private

BKLM RPC.

Definition at line 563 of file KLMTimeAlgorithm.h.

gre_time_channel_scint

TGraphErrors* gre_time_channel_scint = nullptr

private

BKLM Scintillator.

Definition at line 566 of file KLMTimeAlgorithm.h.

gre_time_channel_scint_end

TGraphErrors* gre_time_channel_scint_end = nullptr

private

EKLM.

Definition at line 569 of file KLMTimeAlgorithm.h.

h2_deltaT0_vs_nhits_rpc

TH2F* h2_deltaT0_vs_nhits_rpc

private

DeltaT0 vs total hit count for RPC.

Definition at line 917 of file KLMTimeAlgorithm.h.

h2_deltaT0_vs_nhits_scint

TH2F* h2_deltaT0_vs_nhits_scint

private

DeltaT0 vs total hit count for BKLM scintillator.

Definition at line 920 of file KLMTimeAlgorithm.h.

h2_deltaT0_vs_nhits_scint_end

TH2F* h2_deltaT0_vs_nhits_scint_end

private

DeltaT0 vs total hit count for EKLM scintillator.

Definition at line 923 of file KLMTimeAlgorithm.h.

h2_deltaT0_vs_v_rpc

TH2F* h2_deltaT0_vs_v_rpc

private

DeltaT0 vs inverse hit count for RPC.

Definition at line 899 of file KLMTimeAlgorithm.h.

h2_deltaT0_vs_v_scint

TH2F* h2_deltaT0_vs_v_scint

private

DeltaT0 vs inverse hit count for BKLM scintillator.

Definition at line 902 of file KLMTimeAlgorithm.h.

h2_deltaT0_vs_v_scint_end

TH2F* h2_deltaT0_vs_v_scint_end

private

DeltaT0 vs inverse hit count for EKLM scintillator.

Definition at line 905 of file KLMTimeAlgorithm.h.

h2_timeF_rpc

TH2F* h2_timeF_rpc[2] = {nullptr}

private

BKLM RPC part.

Definition at line 714 of file KLMTimeAlgorithm.h.

{nullptr};

h2_timeF_scint

TH2F* h2_timeF_scint[2] = {nullptr}

private

BKLM scintillator part.

Definition at line 717 of file KLMTimeAlgorithm.h.

{nullptr};

h2_timeF_scint_end

TH2F* h2_timeF_scint_end[2] = {nullptr}

private

EKLM part.

Definition at line 720 of file KLMTimeAlgorithm.h.

{nullptr};

h2_timeFS

TH2F* h2_timeFS[2][8] = {{nullptr}}

private

BKLM part.

Definition at line 764 of file KLMTimeAlgorithm.h.

{{nullptr}};

h2_timeFS_end

TH2F* h2_timeFS_end[2][4] = {{nullptr}}

private

EKLM part.

Definition at line 767 of file KLMTimeAlgorithm.h.

{{nullptr}};

h2_timeFSLP

TH2F* h2_timeFSLP[2][8][15][2] = {{{{nullptr}}}}

private

BKLM part.

Definition at line 818 of file KLMTimeAlgorithm.h.

{{{{nullptr}}}};

h2_timeFSLP_end

TH2F* h2_timeFSLP_end[2][4][14][2] = {{{{nullptr}}}}

private

EKLM part.

Definition at line 821 of file KLMTimeAlgorithm.h.

{{{{nullptr}}}};

h2c_timeF_rpc

TH2F* h2c_timeF_rpc[2] = {nullptr}

private

BKLM RPC part.

Definition at line 728 of file KLMTimeAlgorithm.h.

{nullptr};

h2c_timeF_scint

TH2F* h2c_timeF_scint[2] = {nullptr}

private

BKLM scintillator part.

Definition at line 731 of file KLMTimeAlgorithm.h.

{nullptr};

h2c_timeF_scint_end

TH2F* h2c_timeF_scint_end[2] = {nullptr}

private

EKLM part.

Definition at line 734 of file KLMTimeAlgorithm.h.

{nullptr};

h2c_timeFS

TH2F* h2c_timeFS[2][8] = {{nullptr}}

private

BKLM part.

Definition at line 775 of file KLMTimeAlgorithm.h.

{{nullptr}};

h2c_timeFS_end

TH2F* h2c_timeFS_end[2][4] = {{nullptr}}

private

EKLM part.

Definition at line 778 of file KLMTimeAlgorithm.h.

{{nullptr}};

h2c_timeFSLP

TH2F* h2c_timeFSLP[2][8][15][2] = {{{{nullptr}}}}

private

BKLM part.

Definition at line 829 of file KLMTimeAlgorithm.h.

{{{{nullptr}}}};

h2c_timeFSLP_end

TH2F* h2c_timeFSLP_end[2][4][14][2] = {{{{nullptr}}}}

private

EKLM part.

Definition at line 832 of file KLMTimeAlgorithm.h.

{{{{nullptr}}}};

h_calibrated

TH1I* h_calibrated = nullptr

private

Calibration statistics for each channel.

Definition at line 552 of file KLMTimeAlgorithm.h.

h_diff

TH1F* h_diff = nullptr

private

Distance between global and local position.

Definition at line 558 of file KLMTimeAlgorithm.h.

h_eventT0_rpc

TH1F* h_eventT0_rpc = nullptr

private

EventT0 seen by RPC hits.

Definition at line 863 of file KLMTimeAlgorithm.h.

h_eventT0_scint

TH1F* h_eventT0_scint = nullptr

private

EventT0 seen by BKLM scintillator hits.

Definition at line 866 of file KLMTimeAlgorithm.h.

h_eventT0_scint_end

TH1F* h_eventT0_scint_end = nullptr

private

EventT0 seen by EKLM scintillator hits.

Definition at line 869 of file KLMTimeAlgorithm.h.

h_nHits_minus_rpc

TH1F* h_nHits_minus_rpc

private

Number of RPC hits per mu- track.

Definition at line 884 of file KLMTimeAlgorithm.h.

h_nHits_minus_scint

TH1F* h_nHits_minus_scint

private

Number of BKLM scintillator hits per mu- track.

Definition at line 890 of file KLMTimeAlgorithm.h.

h_nHits_minus_scint_end

TH1F* h_nHits_minus_scint_end

private

Number of EKLM scintillator hits per mu- track.

Definition at line 896 of file KLMTimeAlgorithm.h.

h_nHits_plus_rpc

TH1F* h_nHits_plus_rpc

private

Number of RPC hits per mu+ track.

Definition at line 881 of file KLMTimeAlgorithm.h.

h_nHits_plus_scint

TH1F* h_nHits_plus_scint

private

Number of BKLM scintillator hits per mu+ track.

Definition at line 887 of file KLMTimeAlgorithm.h.

h_nHits_plus_scint_end

TH1F* h_nHits_plus_scint_end

private

Number of EKLM scintillator hits per mu+ track.

Definition at line 893 of file KLMTimeAlgorithm.h.

h_time_rpc

TH1F* h_time_rpc = nullptr

private

BKLM RPC part.

Definition at line 661 of file KLMTimeAlgorithm.h.

h_time_rpc_tc

TH1F* h_time_rpc_tc = nullptr

private

BKLM RPC part.

Definition at line 650 of file KLMTimeAlgorithm.h.

h_time_scint

TH1F* h_time_scint = nullptr

private

BKLM scintillator part.

Definition at line 664 of file KLMTimeAlgorithm.h.

h_time_scint_end

TH1F* h_time_scint_end = nullptr

private

EKLM part.

Definition at line 667 of file KLMTimeAlgorithm.h.

h_time_scint_tc

TH1F* h_time_scint_tc = nullptr

private

BKLM scintillator part.

Definition at line 653 of file KLMTimeAlgorithm.h.

h_time_scint_tc_end

TH1F* h_time_scint_tc_end = nullptr

private

EKLM part.

Definition at line 656 of file KLMTimeAlgorithm.h.

h_timeF_rpc

TH1F* h_timeF_rpc[2] = {nullptr}

private

BKLM RPC part.

Definition at line 686 of file KLMTimeAlgorithm.h.

{nullptr};

h_timeF_scint

TH1F* h_timeF_scint[2] = {nullptr}

private

BKLM scintillator part.

Definition at line 689 of file KLMTimeAlgorithm.h.

{nullptr};

h_timeF_scint_end

TH1F* h_timeF_scint_end[2] = {nullptr}

private

EKLM part.

Definition at line 692 of file KLMTimeAlgorithm.h.

{nullptr};

h_timeFS_rpc

TH1F* h_timeFS_rpc[2][8] = {{nullptr}}

private

BKLM RPC part.

Definition at line 739 of file KLMTimeAlgorithm.h.

{{nullptr}};

h_timeFS_scint

TH1F* h_timeFS_scint[2][8] = {{nullptr}}

private

BKLM scintillator part.

Definition at line 742 of file KLMTimeAlgorithm.h.

{{nullptr}};

h_timeFS_scint_end

TH1F* h_timeFS_scint_end[2][4] = {{nullptr}}

private

EKLM part.

Definition at line 745 of file KLMTimeAlgorithm.h.

{{nullptr}};

h_timeFSL

TH1F* h_timeFSL[2][8][15] = {{{nullptr}}}

private

BKLM part.

Definition at line 783 of file KLMTimeAlgorithm.h.

{{{nullptr}}};

h_timeFSL_end

TH1F* h_timeFSL_end[2][4][14] = {{{nullptr}}}

private

EKLM part.

Definition at line 786 of file KLMTimeAlgorithm.h.

{{{nullptr}}};

h_timeFSLP

TH1F* h_timeFSLP[2][8][15][2] = {{{{nullptr}}}}

private

BKLM part.

Definition at line 799 of file KLMTimeAlgorithm.h.

{{{{nullptr}}}};

h_timeFSLP_end

TH1F* h_timeFSLP_end[2][4][14][2] = {{{{nullptr}}}}

private

EKLM part.

Definition at line 802 of file KLMTimeAlgorithm.h.

{{{{nullptr}}}};

h_timeFSLPC

TH1F* h_timeFSLPC[2][8][15][2][54] = {{{{{nullptr}}}}}

private

BKLM part.

Definition at line 840 of file KLMTimeAlgorithm.h.

{{{{{nullptr}}}}};

h_timeFSLPC_end

TH1F* h_timeFSLPC_end[2][4][14][2][75] = {{{{{nullptr}}}}}

private

EKLM part.

Definition at line 849 of file KLMTimeAlgorithm.h.

{{{{{nullptr}}}}};

h_timeFSLPC_tc

TH1F* h_timeFSLPC_tc[2][8][15][2][54] = {{{{{nullptr}}}}}

private

BKLM part, used for effective light speed estimation.

Definition at line 837 of file KLMTimeAlgorithm.h.

{{{{{nullptr}}}}};

h_timeFSLPC_tc_end

TH1F* h_timeFSLPC_tc_end[2][4][14][2][75] = {{{{{nullptr}}}}}

private

EKLM part, used for effective light speed estimation.

Definition at line 846 of file KLMTimeAlgorithm.h.

{{{{{nullptr}}}}};

hc_calibrated

TH1I* hc_calibrated = nullptr

private

Calibration statistics for each channel.

Definition at line 555 of file KLMTimeAlgorithm.h.

hc_eventT0_rpc

TH1F* hc_eventT0_rpc = nullptr

private

Corrected EventT0 for RPC hits.

Definition at line 872 of file KLMTimeAlgorithm.h.

hc_eventT0_rpc_highN

TH1F* hc_eventT0_rpc_highN

private

Corrected EventT0 for RPC with high hit count.

Definition at line 932 of file KLMTimeAlgorithm.h.

hc_eventT0_rpc_lowN

TH1F* hc_eventT0_rpc_lowN

private

Corrected EventT0 for RPC with low hit count.

Definition at line 926 of file KLMTimeAlgorithm.h.

hc_eventT0_rpc_midN

TH1F* hc_eventT0_rpc_midN

private

Corrected EventT0 for RPC with medium hit count.

Definition at line 929 of file KLMTimeAlgorithm.h.

hc_eventT0_scint

TH1F* hc_eventT0_scint = nullptr

private

Corrected EventT0 for BKLM scintillator hits.

Definition at line 875 of file KLMTimeAlgorithm.h.

hc_eventT0_scint_end

TH1F* hc_eventT0_scint_end = nullptr

private

Corrected EventT0 for EKLM scintillator hits.

Definition at line 878 of file KLMTimeAlgorithm.h.

hc_eventT0_scint_end_highN

TH1F* hc_eventT0_scint_end_highN

private

Corrected EventT0 for EKLM scintillator with high hit count.

Definition at line 950 of file KLMTimeAlgorithm.h.

hc_eventT0_scint_end_lowN

TH1F* hc_eventT0_scint_end_lowN

private

Corrected EventT0 for EKLM scintillator with low hit count.

Definition at line 944 of file KLMTimeAlgorithm.h.

hc_eventT0_scint_end_midN

TH1F* hc_eventT0_scint_end_midN

private

Corrected EventT0 for EKLM scintillator with medium hit count.

Definition at line 947 of file KLMTimeAlgorithm.h.

hc_eventT0_scint_highN

TH1F* hc_eventT0_scint_highN

private

Corrected EventT0 for BKLM scintillator with high hit count.

Definition at line 941 of file KLMTimeAlgorithm.h.

hc_eventT0_scint_lowN

TH1F* hc_eventT0_scint_lowN

private

Corrected EventT0 for BKLM scintillator with low hit count.

Definition at line 935 of file KLMTimeAlgorithm.h.

hc_eventT0_scint_midN

TH1F* hc_eventT0_scint_midN

private

Corrected EventT0 for BKLM scintillator with medium hit count.

Definition at line 938 of file KLMTimeAlgorithm.h.

hc_time_rpc

TH1F* hc_time_rpc = nullptr

private

BKLM RPC part.

Definition at line 672 of file KLMTimeAlgorithm.h.

hc_time_scint

TH1F* hc_time_scint = nullptr

private

BKLM scintillator part.

Definition at line 675 of file KLMTimeAlgorithm.h.

hc_time_scint_end

TH1F* hc_time_scint_end = nullptr

private

EKLM part.

Definition at line 678 of file KLMTimeAlgorithm.h.

hc_timeF_rpc

TH1F* hc_timeF_rpc[2] = {nullptr}

private

BKLM RPC part.

Definition at line 700 of file KLMTimeAlgorithm.h.

{nullptr};

hc_timeF_scint

TH1F* hc_timeF_scint[2] = {nullptr}

private

BKLM scintillator part.

Definition at line 703 of file KLMTimeAlgorithm.h.

{nullptr};

hc_timeF_scint_end

TH1F* hc_timeF_scint_end[2] = {nullptr}

private

EKLM part.

Definition at line 706 of file KLMTimeAlgorithm.h.

{nullptr};

hc_timeFS_rpc

TH1F* hc_timeFS_rpc[2][8] = {{nullptr}}

private

BKLM RPC part.

Definition at line 750 of file KLMTimeAlgorithm.h.

{{nullptr}};

hc_timeFS_scint

TH1F* hc_timeFS_scint[2][8] = {{nullptr}}

private

BKLM scintillator part.

Definition at line 753 of file KLMTimeAlgorithm.h.

{{nullptr}};

hc_timeFS_scint_end

TH1F* hc_timeFS_scint_end[2][4] = {{nullptr}}

private

EKLM part.

Definition at line 756 of file KLMTimeAlgorithm.h.

{{nullptr}};

hc_timeFSL

TH1F* hc_timeFSL[2][8][15] = {{{nullptr}}}

private

BKLM part.

Definition at line 791 of file KLMTimeAlgorithm.h.

{{{nullptr}}};

hc_timeFSL_end

TH1F* hc_timeFSL_end[2][4][14] = {{{nullptr}}}

private

EKLM part.

Definition at line 794 of file KLMTimeAlgorithm.h.

{{{nullptr}}};

hc_timeFSLP

TH1F* hc_timeFSLP[2][8][15][2] = {{{{nullptr}}}}

private

BKLM part.

Definition at line 807 of file KLMTimeAlgorithm.h.

{{{{nullptr}}}};

hc_timeFSLP_end

TH1F* hc_timeFSLP_end[2][4][14][2] = {{{{nullptr}}}}

private

EKLM part.

Definition at line 810 of file KLMTimeAlgorithm.h.

{{{{nullptr}}}};

hc_timeFSLPC

TH1F* hc_timeFSLPC[2][8][15][2][54] = {{{{{nullptr}}}}}

private

BKLM part.

Definition at line 857 of file KLMTimeAlgorithm.h.

{{{{{nullptr}}}}};

hc_timeFSLPC_end

TH1F* hc_timeFSLPC_end[2][4][14][2][75] = {{{{{nullptr}}}}}

private

EKLM part.

Definition at line 860 of file KLMTimeAlgorithm.h.

{{{{{nullptr}}}}};

m_allExpRun

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

staticprivateinherited

allExpRun

Definition at line 364 of file CalibrationAlgorithm.h.

m_applyChargeRestriction

bool m_applyChargeRestriction = false

private

Whether to apply ADC/charge restriction cuts for scintillators.

Definition at line 549 of file KLMTimeAlgorithm.h.

m_BKLMGeometry

const bklm::GeometryPar* m_BKLMGeometry = nullptr

private

BKLM geometry data.

Definition at line 513 of file KLMTimeAlgorithm.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_cFlag

std::map<KLMChannelNumber, int> m_cFlag

private

Calibration flag if the channel has enough hits collected and fitted OK.

Definition at line 387 of file KLMTimeAlgorithm.h.

m_channelHistDir_BKLM

TDirectory* m_channelHistDir_BKLM[2][8][15][2] = {}

private

Directory structure for per-channel histograms (BKLM).

Indexed as [forward/backward][sector][layer][plane].

Definition at line 979 of file KLMTimeAlgorithm.h.

{};

m_channelHistDir_EKLM

TDirectory* m_channelHistDir_EKLM[2][4][14][2] = {}

private

Directory structure for per-channel histograms (EKLM).

Indexed as [forward/backward][sector][layer][plane].

Definition at line 985 of file KLMTimeAlgorithm.h.

{};

m_ctime_channel

std::map<KLMChannelNumber, double> m_ctime_channel

private

Calibrated time distribution central value of each channel.

Definition at line 402 of file KLMTimeAlgorithm.h.

m_ctime_channelAvg_rpc

double m_ctime_channelAvg_rpc = 0.0

private

Calibrated central value of the global time distribution (BKLM RPC part).

Definition at line 482 of file KLMTimeAlgorithm.h.

m_ctime_channelAvg_scint

double m_ctime_channelAvg_scint = 0.0

private

Calibrated central value of the global time distribution (BKLM scintillator part).

Definition at line 489 of file KLMTimeAlgorithm.h.

m_ctime_channelAvg_scint_end

double m_ctime_channelAvg_scint_end = 0.0

private

Calibrated central value of the global time distribution (EKLM scintillator part).

Definition at line 497 of file KLMTimeAlgorithm.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_debug

bool m_debug = false

private

Debug mode.

Definition at line 540 of file KLMTimeAlgorithm.h.

m_description

std::string m_description {""}

privateinherited

Description of the algorithm.

Definition at line 385 of file CalibrationAlgorithm.h.

{""};

m_EKLMGeometry

const EKLM::GeometryData* m_EKLMGeometry = nullptr

private

EKLM geometry data.

Definition at line 516 of file KLMTimeAlgorithm.h.

m_ElementNumbers

const KLMElementNumbers* m_ElementNumbers

private

Element numbers.

Definition at line 510 of file KLMTimeAlgorithm.h.

m_etime_channel

std::map<KLMChannelNumber, double> m_etime_channel

private

Time distribution central value Error of each channel.

Definition at line 399 of file KLMTimeAlgorithm.h.

m_etime_channelAvg_rpc

double m_etime_channelAvg_rpc = 0.0

private

Central value error of the global time distribution (BKLM RPC part).

Definition at line 463 of file KLMTimeAlgorithm.h.

m_etime_channelAvg_scint

double m_etime_channelAvg_scint = 0.0

private

Central value error of the global time distribution (BKLM scintillator part).

Definition at line 471 of file KLMTimeAlgorithm.h.

m_etime_channelAvg_scint_end

double m_etime_channelAvg_scint_end = 0.0

private

Central value error of the global time distribution (EKLM scintillator part).

Definition at line 479 of file KLMTimeAlgorithm.h.

m_eventT0HitResolution

KLMEventT0HitResolution* m_eventT0HitResolution = nullptr

private

DBObject of per-hit time resolution for EventT0.

Definition at line 537 of file KLMTimeAlgorithm.h.

m_evts

std::map<KLMChannelNumber, std::vector<struct Event> > m_evts

private

Container of hit information.

the global element number of the strip is used as the key.

Definition at line 381 of file KLMTimeAlgorithm.h.

m_fixedRPCDelay

double m_fixedRPCDelay = 0.0667

private

Fixed propagation delay for RPCs (ns/cm).

Default value corresponds to c_eff = 0.5c = 15 cm/ns → delay = 0.0667 ns/cm. Used when m_useFixedRPCDelay is true.

Definition at line 445 of file KLMTimeAlgorithm.h.

m_granularityOfData

std::string m_granularityOfData

privateinherited

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

Definition at line 379 of file CalibrationAlgorithm.h.

m_HistTimeLengthBKLM

TH2F* m_HistTimeLengthBKLM[2][8][15][2][54] = {{{{{nullptr}}}}}

private

Two-dimensional distributions of time versus propagation length.

Definition at line 843 of file KLMTimeAlgorithm.h.

{{{{{nullptr}}}}};

m_HistTimeLengthEKLM

TH2F* m_HistTimeLengthEKLM[2][4][14][2][75] = {{{{{nullptr}}}}}

private

Two-dimensional distributions of time versus propagation length.

Definition at line 852 of file KLMTimeAlgorithm.h.

{{{{{nullptr}}}}};

m_inputFileNames

std::vector<std::string> m_inputFileNames

privateinherited

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

Definition at line 373 of file CalibrationAlgorithm.h.

m_jsonExecutionInput

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

privateinherited

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

Definition at line 397 of file CalibrationAlgorithm.h.

m_jsonExecutionOutput

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

privateinherited

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

Definition at line 403 of file CalibrationAlgorithm.h.

m_klmChannels

KLMChannelIndex m_klmChannels

private

KLM ChannelIndex object.

Definition at line 519 of file KLMTimeAlgorithm.h.

m_lower_limit_counts

int m_lower_limit_counts = 50

private

Lower limit of hits collected for on single channel.

Definition at line 507 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryCalibratedRPC

double m_LowerTimeBoundaryCalibratedRPC = -40.0

private

Lower time boundary for RPC (calibrated data).

Definition at line 426 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryCalibratedScintillatorsBKLM

double m_LowerTimeBoundaryCalibratedScintillatorsBKLM = -40.0

private

Lower time boundary for BKLM scintillators (calibrated data).

Definition at line 448 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryCalibratedScintillatorsEKLM

double m_LowerTimeBoundaryCalibratedScintillatorsEKLM = -40.0

private

Lower time boundary for EKLM scintillators (calibrated data).

Definition at line 454 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryRPC

double m_LowerTimeBoundaryRPC = -10.0

private

Lower time boundary for RPC.

Definition at line 408 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryScintillatorsBKLM

double m_LowerTimeBoundaryScintillatorsBKLM = 20.0

private

Lower time boundary for BKLM scintillators.

Definition at line 414 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryScintillatorsEKLM

double m_LowerTimeBoundaryScintillatorsEKLM = 20.0

private

Lower time boundary for EKLM scintillators.

Definition at line 420 of file KLMTimeAlgorithm.h.

m_mc

bool m_mc = false

private

MC or data.

Definition at line 543 of file KLMTimeAlgorithm.h.

m_MinimalDigitNumber

int m_MinimalDigitNumber = 100000000

private

Minimal digit number (total).

Definition at line 504 of file KLMTimeAlgorithm.h.

m_minimizerOptions

ROOT::Math::MinimizerOptions m_minimizerOptions

private

Minimization options.

Definition at line 522 of file KLMTimeAlgorithm.h.

m_outFile

TFile* m_outFile = nullptr

private

Output file.

Definition at line 967 of file KLMTimeAlgorithm.h.

m_prefix

std::string m_prefix {""}

privateinherited

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

Definition at line 388 of file CalibrationAlgorithm.h.

{""};

m_Profile2BKLMScintillatorPhi

TProfile* m_Profile2BKLMScintillatorPhi = nullptr

private

For BKLM scintillator phi plane.

Definition at line 633 of file KLMTimeAlgorithm.h.

m_Profile2BKLMScintillatorZ

TProfile* m_Profile2BKLMScintillatorZ = nullptr

private

For BKLM scintillator z plane.

Definition at line 636 of file KLMTimeAlgorithm.h.

m_Profile2EKLMScintillatorPlane1

TProfile* m_Profile2EKLMScintillatorPlane1 = nullptr

private

For EKLM scintillator plane1.

Definition at line 639 of file KLMTimeAlgorithm.h.

m_Profile2EKLMScintillatorPlane2

TProfile* m_Profile2EKLMScintillatorPlane2 = nullptr

private

For EKLM scintillator plane2.

Definition at line 642 of file KLMTimeAlgorithm.h.

m_Profile2RpcPhi

TProfile* m_Profile2RpcPhi = nullptr

private

For BKLM RPC phi plane.

Definition at line 627 of file KLMTimeAlgorithm.h.

m_Profile2RpcZ

TProfile* m_Profile2RpcZ = nullptr

private

For BKLM RPC z plane.

Definition at line 630 of file KLMTimeAlgorithm.h.

m_ProfileBKLMScintillatorPhi

TProfile* m_ProfileBKLMScintillatorPhi = nullptr

private

For BKLM scintillator phi plane.

Definition at line 613 of file KLMTimeAlgorithm.h.

m_ProfileBKLMScintillatorZ

TProfile* m_ProfileBKLMScintillatorZ = nullptr

private

For BKLM scintillator z plane.

Definition at line 616 of file KLMTimeAlgorithm.h.

m_ProfileEKLMScintillatorPlane1

TProfile* m_ProfileEKLMScintillatorPlane1 = nullptr

private

For EKLM scintillator plane1.

Definition at line 619 of file KLMTimeAlgorithm.h.

m_ProfileEKLMScintillatorPlane2

TProfile* m_ProfileEKLMScintillatorPlane2 = nullptr

private

For EKLM scintillator plane2.

Definition at line 622 of file KLMTimeAlgorithm.h.

m_ProfileRpcPhi

TProfile* m_ProfileRpcPhi = nullptr

private

For BKLM RPC phi plane.

Definition at line 607 of file KLMTimeAlgorithm.h.

m_ProfileRpcZ

TProfile* m_ProfileRpcZ = nullptr

private

For BKLM RPC z plane.

Definition at line 610 of file KLMTimeAlgorithm.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_saveAllPlots

bool m_saveAllPlots = false

private

Default minimal unless you set true in your header script.

Definition at line 970 of file KLMTimeAlgorithm.h.

m_saveChannelHists

bool m_saveChannelHists = false

private

Write per-channel temporary histograms (tc/raw/hc) in minimal mode.

Definition at line 973 of file KLMTimeAlgorithm.h.

m_time_channel

std::map<KLMChannelNumber, double> m_time_channel

private

Time distribution central value of each channel.

Definition at line 396 of file KLMTimeAlgorithm.h.

m_time_channelAvg_rpc

double m_time_channelAvg_rpc = 0.0

private

Central value of the global time distribution (BKLM RPC part).

Definition at line 460 of file KLMTimeAlgorithm.h.

m_time_channelAvg_scint

double m_time_channelAvg_scint = 0.0

private

Central value of the global time distribution (BKLM scintillator part).

Definition at line 467 of file KLMTimeAlgorithm.h.

m_time_channelAvg_scint_end

double m_time_channelAvg_scint_end = 0.0

private

Central value of the global time distribution (EKLM scintillator part).

Definition at line 475 of file KLMTimeAlgorithm.h.

m_timeCableDelay

KLMTimeCableDelay* m_timeCableDelay = nullptr

private

DBObject of the calibration constant of each channel due to cable decay.

Definition at line 531 of file KLMTimeAlgorithm.h.

m_timeConstants

KLMTimeConstants* m_timeConstants = nullptr

private

DBObject of time cost on some parts of the detector.

Definition at line 525 of file KLMTimeAlgorithm.h.

m_timeRes

std::map<KLMChannelNumber, double> m_timeRes

private

Resolution values of each channel.

Definition at line 393 of file KLMTimeAlgorithm.h.

m_timeResolution

KLMTimeResolution* m_timeResolution = nullptr

private

DBObject of time resolution.

Definition at line 534 of file KLMTimeAlgorithm.h.

m_timeShift

std::map<KLMChannelNumber, double> m_timeShift

private

Shift values of each channel.

Definition at line 390 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryCalibratedRPC

double m_UpperTimeBoundaryCalibratedRPC = 40.0

private

Upper time boundary for RPC (calibrated data).

Definition at line 429 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryCalibratedScintillatorsBKLM

double m_UpperTimeBoundaryCalibratedScintillatorsBKLM = 40.0

private

Upper time boundary for BKLM scintillators (calibrated data).

Definition at line 451 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryCalibratedScintillatorsEKLM

double m_UpperTimeBoundaryCalibratedScintillatorsEKLM = 40.0

private

Upper time boundary for BKLM scintillators (calibrated data).

Definition at line 457 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryRPC

double m_UpperTimeBoundaryRPC = 10.0

private

Upper time boundary for RPC.

Definition at line 411 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryScintillatorsBKLM

double m_UpperTimeBoundaryScintillatorsBKLM = 70.0

private

Upper time boundary for BKLM scintillators.

Definition at line 417 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryScintillatorsEKLM

double m_UpperTimeBoundaryScintillatorsEKLM = 70.0

private

Upper time boundary for BKLM scintillators.

Definition at line 423 of file KLMTimeAlgorithm.h.

m_useEventT0

bool m_useEventT0 = true

private

Whether to use event T0 from CDC.

Definition at line 546 of file KLMTimeAlgorithm.h.

m_useFixedRPCDelay

bool m_useFixedRPCDelay = false

private

Whether to use fixed propagation delay for RPCs.

Technical note BELLE2-NOTE-TE-2021-015 states that c_eff estimation for RPC is "meaningless" and should be fixed at 0.5c. Default is false to allow extraction from data (now that the propagation distance calculation is fixed for RPCs).

Definition at line 438 of file KLMTimeAlgorithm.h.

mc_etime_channel

std::map<KLMChannelNumber, double> mc_etime_channel

private

Calibrated time distribution central value Error of each channel.

Definition at line 405 of file KLMTimeAlgorithm.h.

mc_etime_channelAvg_rpc

double mc_etime_channelAvg_rpc = 0.0

private

Calibrated central value error of the global time distribution (BKLM RPC part).

Definition at line 485 of file KLMTimeAlgorithm.h.

mc_etime_channelAvg_scint

double mc_etime_channelAvg_scint = 0.0

private

Calibrated central value error of the global time distribution (BKLM scintillator part).

Definition at line 493 of file KLMTimeAlgorithm.h.

mc_etime_channelAvg_scint_end

double mc_etime_channelAvg_scint_end = 0.0

private

Calibrated central value error of the global time distribution (EKLM scintillator part).

Definition at line 501 of file KLMTimeAlgorithm.h.

prof_deltaT0_rms_vs_v_rpc

TProfile* prof_deltaT0_rms_vs_v_rpc

private

DeltaT0 RMS vs inverse hit count profile for RPC.

Definition at line 908 of file KLMTimeAlgorithm.h.

prof_deltaT0_rms_vs_v_scint

TProfile* prof_deltaT0_rms_vs_v_scint

private

DeltaT0 RMS vs inverse hit count profile for BKLM scintillator.

Definition at line 911 of file KLMTimeAlgorithm.h.

prof_deltaT0_rms_vs_v_scint_end

TProfile* prof_deltaT0_rms_vs_v_scint_end

private

DeltaT0 RMS vs inverse hit count profile for EKLM scintillator.

Definition at line 914 of file KLMTimeAlgorithm.h.

---

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

• klm/calibration/include/KLMTimeAlgorithm.h
• klm/calibration/src/KLMTimeAlgorithm.cc