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	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	createHistograms ()
	Create histograms.
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).
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.
bool	m_debug = false
	Debug mode.
bool	m_mc = false
	MC or data.
bool	m_useEventT0 = true
	Whether to use event T0 from CDC.
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.
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.
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 41 of file KLMTimeAlgorithm.h.

Member Enumeration Documentation

ChannelCalibrationStatus

enum ChannelCalibrationStatus

Channel calibration status.

Definition at line 99 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 93 of file KLMTimeAlgorithm.cc.

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

~KLMTimeAlgorithm()

~KLMTimeAlgorithm

(

)

Destructor.

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

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 738 of file KLMTimeAlgorithm.cc.

{
  int channelId;
  gROOT->SetBatch(kTRUE);
  setupDatabase();
  m_timeCableDelay = new KLMTimeCableDelay();
  m_timeConstants = new KLMTimeConstants();
  m_timeResolution = new KLMTimeResolution();
 
  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");
 
  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;
    /* Overflow. */
    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);
 
  /* Sort channels by number of events. */
  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 (m_evts.find(channel) == m_evts.end())
      continue;
    int nEvents = m_evts[channel].size();
    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 for the channel with the maximal number of events. */
  double delayBKLM, delayBKLMError;
  double delayEKLM, delayEKLMError;
  timeDistance2dFit(channelsBKLM, delayBKLM, delayBKLMError);
  timeDistance2dFit(channelsEKLM, delayEKLM, delayEKLMError);
 
  /**********************************
   * First loop
   * Estimation of effective light speed for Scintillators and RPCs, separately.
   **********************************/
  B2INFO("Effective light speed Estimation.");
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    if (m_cFlag[channelId] == ChannelCalibrationStatus::c_NotEnoughData)
      continue;
 
    eventsChannel = m_evts[channelId];
    int iSub = klmChannel.getSubdetector();
 
    for (const Event& event : eventsChannel) {
      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 (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;
        h_timeFSLPC_tc[iF][iS][iL][iP][iC]->Fill(timeHit);
        if (iL > 1) {
          h_time_rpc_tc->Fill(timeHit);
        } else {
          h_time_scint_tc->Fill(timeHit);
        }
      } else {
        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;
        h_timeFSLPC_tc_end[iF][iS][iL][iP][iC]->Fill(timeHit);
        h_time_scint_tc_end->Fill(timeHit);
      }
    }
  }
  B2INFO("Effective light speed Estimation! Hists and Graph filling done.");
 
  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));
 
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    if (m_cFlag[channelId] == ChannelCalibrationStatus::c_NotEnoughData)
      continue;
 
    int iSub = klmChannel.getSubdetector();
    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;
      h_timeFSLPC_tc[iF][iS][iL][iP][iC]->Fit(fcn_gaus, "LESQ");
      double tmpMean_channel = fcn_gaus->GetParameter(1);
      if (iL > 1) {
        m_timeShift[channelId] = tmpMean_channel - tmpMean_rpc_global;
      } else {
        m_timeShift[channelId] = tmpMean_channel - tmpMean_scint_global;
      }
    } else {
      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;
      h_timeFSLPC_tc_end[iF][iS][iL][iP][iC]->Fit(fcn_gaus, "LESQ");
      double tmpMean_channel = fcn_gaus->GetParameter(1);
      m_timeShift[channelId] = tmpMean_channel - tmpMean_scint_global_end;
    }
  }
 
  delete h_time_scint_tc;
  delete h_time_scint_tc_end;
  delete h_time_rpc_tc;
  B2INFO("Effective Light m_timeShift obtained. done.");
 
  fillTimeDistanceProfiles(
    m_ProfileRpcPhi, m_ProfileRpcZ,
    m_ProfileBKLMScintillatorPhi, m_ProfileBKLMScintillatorZ,
    m_ProfileEKLMScintillatorPlane1, m_ProfileEKLMScintillatorPlane2, false);
 
  B2INFO("Effective light speed fitting.");
  m_ProfileRpcPhi->Fit("fcn_pol1", "EMQ");
  double delayRPCPhi = fcn_pol1->GetParameter(1);
  double e_slope_rpc_phi = fcn_pol1->GetParError(1);
 
  m_ProfileRpcZ->Fit("fcn_pol1", "EMQ");
  double delayRPCZ = fcn_pol1->GetParameter(1);
  double e_slope_rpc_z = fcn_pol1->GetParError(1);
 
  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;
  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()));
 
  // Default Effective light speed in current Database
  //delayEKLM = 0.5 * (slope_scint_plane1_end + slope_scint_plane2_end);
  //delayBKLM = 0.5 * (slope_scint_phi + slope_scint_z);
 
  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);
 
  B2INFO("Time distribution filling begins.");
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    int iSub = klmChannel.getSubdetector();
 
    if (m_cFlag[channelId] == ChannelCalibrationStatus::c_NotEnoughData)
      continue;
    eventsChannel = m_evts[channelId];
 
    for (const Event& event : eventsChannel) {
      double timeHit = event.time();
      if (m_useEventT0)
        timeHit = timeHit - event.t0;
      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;
        if (iL > 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_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);
          h_timeFSLPC[iF][iS][iL][iP][iC]->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_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);
          h_timeFSLPC[iF][iS][iL][iP][iC]->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 {
        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;
        double propgationT = event.dist * delayEKLM;
        double time = timeHit - propgationT;
        h_time_scint_end->Fill(time);
        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);
        h_timeFSLPC_end[iF][iS][iL][iP][iC]->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);
      }
    }
  }
 
  B2INFO("Original filling done.");
 
  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_NotEnoughData)
      continue;
    int iSub = klmChannel.getSubdetector();
 
    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;
 
      TFitResultPtr r = h_timeFSLPC[iF][iS][iL][iP][iC]->Fit(fcn_gaus, "LESQ");
      if (int(r) != 0)
        continue;
      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);
      if (iL > 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 {
      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;
 
      TFitResultPtr r = h_timeFSLPC_end[iF][iS][iL][iP][iC]->Fit(fcn_gaus, "LESQ");
      if (int(r) != 0)
        continue;
      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);
      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];
    int iSub = klmChannel.getSubdetector();
    if (iSub == KLMElementNumbers::c_BKLM) {
      int iL = klmChannel.getLayer() - 1;
      if (iL > 1)
        m_timeShift[channelId] = timeShift;
      else
        m_timeShift[channelId] = timeShift;
    } else {
      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) {
      int iL = klmChannel.getLayer();
      if (iL > 2) {
        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++;
    }
  }
 
  fillTimeDistanceProfiles(
    m_Profile2RpcPhi, m_Profile2RpcZ,
    m_Profile2BKLMScintillatorPhi, m_Profile2BKLMScintillatorZ,
    m_Profile2EKLMScintillatorPlane1,  m_Profile2EKLMScintillatorPlane2, true);
 
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    channelId = klmChannel.getKLMChannelNumber();
    int iSub = klmChannel.getSubdetector();
    eventsChannel = m_evts[channelId];
    for (const Event& event : eventsChannel) {
      double timeHit = event.time();
      if (m_useEventT0)
        timeHit = timeHit - event.t0;
      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;
        if (iL > 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_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);
          hc_timeFSLPC[iF][iS][iL][iP][iC]->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_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);
          hc_timeFSLPC[iF][iS][iL][iP][iC]->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 {
        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;
        double propgationT = event.dist * delayEKLM;
        double time = timeHit - propgationT - m_timeShift[channelId];
        hc_time_scint_end->Fill(time);
        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);
        hc_timeFSLPC_end[iF][iS][iL][iP][iC]->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);
      }
    }
  }
 
  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_NotEnoughData)
      continue;
    int iSub = klmChannel.getSubdetector();
 
    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;
 
      TFitResultPtr rc = hc_timeFSLPC[iF][iS][iL][iP][iC]->Fit(fcn_gaus, "LESQ");
      if (int(rc) != 0)
        continue;
      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);
      if (iL > 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 {
      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;
 
      TFitResultPtr rc = hc_timeFSLPC_end[iF][iS][iL][iP][iC]->Fit(fcn_gaus, "LESQ");
      if (int(rc) != 0)
        continue;
      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);
      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];
    int iSub = klmChannel.getSubdetector();
    if (iSub == KLMElementNumbers::c_BKLM) {
      int iL = klmChannel.getLayer() - 1;
      if (iL > 1)
        m_timeRes[channelId] = timeRes;
      else
        m_timeRes[channelId] = timeRes;
    } else {
      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) {
      int iL = klmChannel.getLayer();
      if (iL > 2) {
        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++;
    }
  }
  saveHist();
 
  delete fcn_const;
  m_evts.clear();
  m_timeShift.clear();
  m_timeRes.clear();
  m_cFlag.clear();
 
  saveCalibration(m_timeCableDelay, "KLMTimeCableDelay");
  saveCalibration(m_timeConstants, "KLMTimeConstants");
  saveCalibration(m_timeResolution, "KLMTimeResolution");
  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 174 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;
 
  }
  int nBin = 200;
  int nBin_scint = 400;
 
  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]", 400, 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]", 400, 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]",
                                              200, 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]",
                                            200, 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]",
                                                 200, 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]",
                                                 200, 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]", 400, 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]", 400, 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]",
                                               200, 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]",
                                             200, 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]",
                                                  200, 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]",
                                                  200, 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);
 
  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);
 
          int nchannel_max = BKLMElementNumbers::getNStrips(iF, iS + 1, iL + 1, iP);
          for (int iC = 0; iC < nchannel_max; ++iC) {
            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; T_rec-T_0-T_fly-T_propagation[ns]", iC,
                      iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
            h_timeFSLPC_tc[iF][iS][iL][iP][iC] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsBKLM,
                                                          m_UpperTimeBoundaryScintillatorsBKLM);
 
            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; T_rec-T_0-T_fly-T_propagation[ns]", iC,
                      iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
            h_timeFSLPC[iF][iS][iL][iP][iC] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsBKLM,
                                                       m_UpperTimeBoundaryScintillatorsBKLM);
 
            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; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                      iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
            hc_timeFSLPC[iF][iS][iL][iP][iC] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsBKLM,
                                                        m_UpperTimeBoundaryCalibratedScintillatorsBKLM);
            hn = Form("time_length_bklm_F%d_S%d_L%d_P%d_C%d", iF, iS, iL, iP, iC);
            double stripLength = 200;
            m_HistTimeLengthBKLM[iF][iS][iL][iP][iC] =
              new TH2F(hn.Data(),
                       "Time versus propagation length; "
                       "propagation distance[cm]; "
                       "T_rec-T_0-T_fly-'T_calibration'[ns]",
                       200, 0.0, stripLength,
                       400, 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);
 
          int nchannel_max = BKLMElementNumbers::getNStrips(iF, iS + 1, iL + 1, iP);
          for (int iC = 0; iC < nchannel_max; ++iC) {
            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; T_rec-T_0-T_fly-T_propagation[ns]", iC,
                      iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
            h_timeFSLPC_tc[iF][iS][iL][iP][iC] = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryRPC, m_UpperTimeBoundaryRPC);
 
            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; T_rec-T_0-T_fly-T_propagation[ns]", iC,
                      iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
            h_timeFSLPC[iF][iS][iL][iP][iC] = new TH1F(hn.Data(), ht.Data(), nBin, m_LowerTimeBoundaryRPC, m_UpperTimeBoundaryRPC);
 
            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; T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                      iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
            hc_timeFSLPC[iF][iS][iL][iP][iC] = new TH1F(hn.Data(), ht.Data(), 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);
 
          for (int iC = 0; iC < 75; ++iC) {
            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); T_rec-T_0-T_fly-T_propagation[ns]",
                      iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
            h_timeFSLPC_tc_end[iF][iS][iL][iP][iC] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM,
                                                              m_UpperTimeBoundaryScintillatorsEKLM);
 
            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); T_rec-T_0-T_fly-T_propagation[ns]",
                      iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
            h_timeFSLPC_end[iF][iS][iL][iP][iC] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryScintillatorsEKLM,
                                                           m_UpperTimeBoundaryScintillatorsEKLM);
            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); T_rec-T_0-T_fly-T_propagation-T_calibration[ns]",
                      iC, iPstring[iP].Data(), iL, iS, iFstring[iF].Data());
            hc_timeFSLPC_end[iF][iS][iL][iP][iC] = new TH1F(hn.Data(), ht.Data(), nBin_scint, m_LowerTimeBoundaryCalibratedScintillatorsEKLM,
                                                            m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
            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;
            m_HistTimeLengthEKLM[iF][iS][iL][iP][iC] =
              new TH2F(hn.Data(),
                       "Time versus propagation length; "
                       "propagation distance[cm]; "
                       "T_rec-T_0-T_fly-'T_calibration'[ns]",
                       200, 0.0, stripLength,
                       400, m_LowerTimeBoundaryCalibratedScintillatorsEKLM,
                       m_UpperTimeBoundaryCalibratedScintillatorsEKLM);
          }
        }
      }
    }
  }
}

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 1630 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 1550 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 595 of file KLMTimeAlgorithm.cc.

{
  for (KLMChannelIndex klmChannel = m_klmChannels.begin(); klmChannel != m_klmChannels.end(); ++klmChannel) {
    KLMChannelNumber channel = klmChannel.getKLMChannelNumber();
    if (m_cFlag[channel] == ChannelCalibrationStatus::c_NotEnoughData)
      continue;
 
    std::vector<struct Event> eventsChannel;
    eventsChannel = m_evts[channel];
    int iSub = klmChannel.getSubdetector();
 
    for (const Event& event : eventsChannel) {
      double timeHit = event.time() - m_timeShift[channel];
      if (m_useEventT0)
        timeHit = timeHit - event.t0;
      double distHit = event.dist;
 
      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;
        if (iL > 1) {
          if (iP) {
            profileRpcPhi->Fill(distHit, timeHit);
          } else {
            profileRpcZ->Fill(distHit, timeHit);
          }
        } else {
          if (fill2dHistograms)
            m_HistTimeLengthBKLM[iF][iS][iL][iP][iC]->Fill(distHit, timeHit);
          if (iP) {
            profileBKLMScintillatorPhi->Fill(distHit, timeHit);
          } else {
            profileBKLMScintillatorZ->Fill(distHit, timeHit);
          }
        }
      } else {
        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;
        if (fill2dHistograms)
          m_HistTimeLengthEKLM[iF][iS][iL][iP][iC]->Fill(distHit, timeHit);
        if (iP) {
          profileEKLMScintillatorPlane1->Fill(distHit, timeHit);
        } else {
          profileEKLMScintillatorPlane2->Fill(distHit, timeHit);
        }
      }
    }
  }
}

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()

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()

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()

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

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

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 141 of file KLMTimeAlgorithm.cc.

{
  B2INFO("Read tree entries and separate events by module id.");
  Event event;
  std::shared_ptr<TTree> timeCalibrationData;
  timeCalibrationData = getObjectPtr<TTree>("time_calibration_data");
  timeCalibrationData->SetBranchAddress("t0", &event.t0);
  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);
 
  B2INFO(LogVar("Total number of digits:", timeCalibrationData->GetEntries()));
  m_evts.clear();
 
  int n = timeCalibrationData->GetEntries();
  if (n < m_MinimalDigitNumber)
    return CalibrationAlgorithm::c_NotEnoughData;
  for (int i = 0; i < n; ++i) {
    timeCalibrationData->GetEntry(i);
    m_evts[event.channelId].push_back(event);
  }
  B2INFO("Events packing finish.");
  return CalibrationAlgorithm::c_OK;
}

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 1373 of file KLMTimeAlgorithm.cc.

{
  m_outFile->cd();
  B2INFO("Save Histograms into Files.");
  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_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.");
 
  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();
 
          int nchannel_max = BKLMElementNumbers::getNStrips(iF, iS + 1, iL + 1, iP);
          for (int iC = 0; iC < nchannel_max; ++iC) {
            if (iL < 2)
              m_HistTimeLengthBKLM[iF][iS][iL][iP][iC]->SetDirectory(dir_time_FSLP[iF][iS][iL][iP]);
            h_timeFSLPC[iF][iS][iL][iP][iC]->SetDirectory(dir_time_FSLP[iF][iS][iL][iP]);
            hc_timeFSLPC[iF][iS][iL][iP][iC]->SetDirectory(dir_time_FSLP[iF][iS][iL][iP]);
            delete h_timeFSLPC_tc[iF][iS][iL][iP][iC];
          }
        }
      }
    }
 
    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();
 
          for (int iC = 0; iC < 75; ++iC) {
            h_timeFSLPC_end[iF][iS][iL][iP][iC]->SetDirectory(dir_time_FSLP_end[iF][iS][iL][iP]);
            hc_timeFSLPC_end[iF][iS][iL][iP][iC]->SetDirectory(dir_time_FSLP_end[iF][iS][iL][iP]);
            m_HistTimeLengthEKLM[iF][iS][iL][iP][iC]->SetDirectory(dir_time_FSLP_end[iF][iS][iL][iP]);
            delete h_timeFSLPC_tc_end[iF][iS][iL][iP][iC];
          }
        }
      }
    }
  }
  m_outFile->cd();
  m_outFile->Write();
  m_outFile->Close();
  B2INFO("File Write and Close. Done.");
}

setDebug()

void setDebug ( )

inline

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

Definition at line 125 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 161 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 135 of file KLMTimeAlgorithm.h.

    {
      m_mc = mc;
    }

setMinimalDigitNumber()

void setMinimalDigitNumber ( int  minimalDigitNumber )

inline

Set minimal digit number (total).

Definition at line 151 of file KLMTimeAlgorithm.h.

    {
      m_MinimalDigitNumber = minimalDigitNumber;
    }

setOutputJsonValue()

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

inlineprotectedinherited

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

Definition at line 337 of file CalibrationAlgorithm.h.

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

setupDatabase()

void setupDatabase ( )

private

Setup the database.

Definition at line 104 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 655 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;
      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 1687 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 1661 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 1607 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 1581 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 143 of file KLMTimeAlgorithm.h.

    {
      m_useEventT0 = true;
    }

Member Data Documentation

fcn_const

TF1* fcn_const = nullptr

private

Const function.

Global time distribution fitting.

Definition at line 744 of file KLMTimeAlgorithm.h.

fcn_gaus

TF1* fcn_gaus = nullptr

private

Gaussian function.

Scitillator time distribution fitting.

Definition at line 747 of file KLMTimeAlgorithm.h.

fcn_land

TF1* fcn_land = nullptr

private

Landau function.

RPC time distribution fitting.

Definition at line 750 of file KLMTimeAlgorithm.h.

fcn_pol1

TF1* fcn_pol1 = nullptr

private

Pol1 function.

Effective light speed fitting.

Definition at line 741 of file KLMTimeAlgorithm.h.

gr_timeRes_channel_rpc

TGraph* gr_timeRes_channel_rpc = nullptr

private

BKLM RPC.

Definition at line 472 of file KLMTimeAlgorithm.h.

gr_timeRes_channel_scint

TGraph* gr_timeRes_channel_scint = nullptr

private

BKLM scintillator.

Definition at line 475 of file KLMTimeAlgorithm.h.

gr_timeRes_channel_scint_end

TGraph* gr_timeRes_channel_scint_end = nullptr

private

EKLM.

Definition at line 478 of file KLMTimeAlgorithm.h.

gr_timeShift_channel_rpc

TGraph* gr_timeShift_channel_rpc = nullptr

private

BKLM RPC.

Definition at line 461 of file KLMTimeAlgorithm.h.

gr_timeShift_channel_scint

TGraph* gr_timeShift_channel_scint = nullptr

private

BKLM scintillator.

Definition at line 464 of file KLMTimeAlgorithm.h.

gr_timeShift_channel_scint_end

TGraph* gr_timeShift_channel_scint_end = nullptr

private

EKLM.

Definition at line 467 of file KLMTimeAlgorithm.h.

gre_ctime_channel_rpc

TGraphErrors* gre_ctime_channel_rpc = nullptr

private

BKLM RPC.

Definition at line 450 of file KLMTimeAlgorithm.h.

gre_ctime_channel_scint

TGraphErrors* gre_ctime_channel_scint = nullptr

private

BKLM Scintillator.

Definition at line 453 of file KLMTimeAlgorithm.h.

gre_ctime_channel_scint_end

TGraphErrors* gre_ctime_channel_scint_end = nullptr

private

EKLM.

Definition at line 456 of file KLMTimeAlgorithm.h.

gre_time_channel_rpc

TGraphErrors* gre_time_channel_rpc = nullptr

private

BKLM RPC.

Definition at line 439 of file KLMTimeAlgorithm.h.

gre_time_channel_scint

TGraphErrors* gre_time_channel_scint = nullptr

private

BKLM Scintillator.

Definition at line 442 of file KLMTimeAlgorithm.h.

gre_time_channel_scint_end

TGraphErrors* gre_time_channel_scint_end = nullptr

private

EKLM.

Definition at line 445 of file KLMTimeAlgorithm.h.

h2_timeF_rpc

TH2F* h2_timeF_rpc[2] = {nullptr}

private

BKLM RPC part.

Definition at line 590 of file KLMTimeAlgorithm.h.

h2_timeF_scint

TH2F* h2_timeF_scint[2] = {nullptr}

private

BKLM scintillator part.

Definition at line 593 of file KLMTimeAlgorithm.h.

h2_timeF_scint_end

TH2F* h2_timeF_scint_end[2] = {nullptr}

private

EKLM part.

Definition at line 596 of file KLMTimeAlgorithm.h.

h2_timeFS

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

private

BKLM part.

Definition at line 640 of file KLMTimeAlgorithm.h.

h2_timeFS_end

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

private

EKLM part.

Definition at line 643 of file KLMTimeAlgorithm.h.

h2_timeFSLP

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

private

BKLM part.

Definition at line 694 of file KLMTimeAlgorithm.h.

h2_timeFSLP_end

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

private

EKLM part.

Definition at line 697 of file KLMTimeAlgorithm.h.

h2c_timeF_rpc

TH2F* h2c_timeF_rpc[2] = {nullptr}

private

BKLM RPC part.

Definition at line 604 of file KLMTimeAlgorithm.h.

h2c_timeF_scint

TH2F* h2c_timeF_scint[2] = {nullptr}

private

BKLM scintillator part.

Definition at line 607 of file KLMTimeAlgorithm.h.

h2c_timeF_scint_end

TH2F* h2c_timeF_scint_end[2] = {nullptr}

private

EKLM part.

Definition at line 610 of file KLMTimeAlgorithm.h.

h2c_timeFS

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

private

BKLM part.

Definition at line 651 of file KLMTimeAlgorithm.h.

h2c_timeFS_end

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

private

EKLM part.

Definition at line 654 of file KLMTimeAlgorithm.h.

h2c_timeFSLP

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

private

BKLM part.

Definition at line 705 of file KLMTimeAlgorithm.h.

h2c_timeFSLP_end

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

private

EKLM part.

Definition at line 708 of file KLMTimeAlgorithm.h.

h_calibrated

TH1I* h_calibrated = nullptr

private

Calibration statistics for each channel.

Definition at line 428 of file KLMTimeAlgorithm.h.

h_diff

TH1F* h_diff = nullptr

private

Distance between global and local position.

Definition at line 434 of file KLMTimeAlgorithm.h.

h_time_rpc

TH1F* h_time_rpc = nullptr

private

BKLM RPC part.

Definition at line 537 of file KLMTimeAlgorithm.h.

h_time_rpc_tc

TH1F* h_time_rpc_tc = nullptr

private

BKLM RPC part.

Definition at line 526 of file KLMTimeAlgorithm.h.

h_time_scint

TH1F* h_time_scint = nullptr

private

BKLM scintillator part.

Definition at line 540 of file KLMTimeAlgorithm.h.

h_time_scint_end

TH1F* h_time_scint_end = nullptr

private

EKLM part.

Definition at line 543 of file KLMTimeAlgorithm.h.

h_time_scint_tc

TH1F* h_time_scint_tc = nullptr

private

BKLM scintillator part.

Definition at line 529 of file KLMTimeAlgorithm.h.

h_time_scint_tc_end

TH1F* h_time_scint_tc_end = nullptr

private

EKLM part.

Definition at line 532 of file KLMTimeAlgorithm.h.

h_timeF_rpc

TH1F* h_timeF_rpc[2] = {nullptr}

private

BKLM RPC part.

Definition at line 562 of file KLMTimeAlgorithm.h.

h_timeF_scint

TH1F* h_timeF_scint[2] = {nullptr}

private

BKLM scintillator part.

Definition at line 565 of file KLMTimeAlgorithm.h.

h_timeF_scint_end

TH1F* h_timeF_scint_end[2] = {nullptr}

private

EKLM part.

Definition at line 568 of file KLMTimeAlgorithm.h.

h_timeFS_rpc

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

private

BKLM RPC part.

Definition at line 615 of file KLMTimeAlgorithm.h.

h_timeFS_scint

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

private

BKLM scintillator part.

Definition at line 618 of file KLMTimeAlgorithm.h.

h_timeFS_scint_end

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

private

EKLM part.

Definition at line 621 of file KLMTimeAlgorithm.h.

h_timeFSL

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

private

BKLM part.

Definition at line 659 of file KLMTimeAlgorithm.h.

h_timeFSL_end

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

private

EKLM part.

Definition at line 662 of file KLMTimeAlgorithm.h.

h_timeFSLP

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

private

BKLM part.

Definition at line 675 of file KLMTimeAlgorithm.h.

h_timeFSLP_end

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

private

EKLM part.

Definition at line 678 of file KLMTimeAlgorithm.h.

h_timeFSLPC

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

private

BKLM part.

Definition at line 716 of file KLMTimeAlgorithm.h.

h_timeFSLPC_end

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

private

EKLM part.

Definition at line 725 of file KLMTimeAlgorithm.h.

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 713 of file KLMTimeAlgorithm.h.

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 722 of file KLMTimeAlgorithm.h.

hc_calibrated

TH1I* hc_calibrated = nullptr

private

Calibration statistics for each channel.

Definition at line 431 of file KLMTimeAlgorithm.h.

hc_time_rpc

TH1F* hc_time_rpc = nullptr

private

BKLM RPC part.

Definition at line 548 of file KLMTimeAlgorithm.h.

hc_time_scint

TH1F* hc_time_scint = nullptr

private

BKLM scintillator part.

Definition at line 551 of file KLMTimeAlgorithm.h.

hc_time_scint_end

TH1F* hc_time_scint_end = nullptr

private

EKLM part.

Definition at line 554 of file KLMTimeAlgorithm.h.

hc_timeF_rpc

TH1F* hc_timeF_rpc[2] = {nullptr}

private

BKLM RPC part.

Definition at line 576 of file KLMTimeAlgorithm.h.

hc_timeF_scint

TH1F* hc_timeF_scint[2] = {nullptr}

private

BKLM scintillator part.

Definition at line 579 of file KLMTimeAlgorithm.h.

hc_timeF_scint_end

TH1F* hc_timeF_scint_end[2] = {nullptr}

private

EKLM part.

Definition at line 582 of file KLMTimeAlgorithm.h.

hc_timeFS_rpc

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

private

BKLM RPC part.

Definition at line 626 of file KLMTimeAlgorithm.h.

hc_timeFS_scint

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

private

BKLM scintillator part.

Definition at line 629 of file KLMTimeAlgorithm.h.

hc_timeFS_scint_end

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

private

EKLM part.

Definition at line 632 of file KLMTimeAlgorithm.h.

hc_timeFSL

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

private

BKLM part.

Definition at line 667 of file KLMTimeAlgorithm.h.

hc_timeFSL_end

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

private

EKLM part.

Definition at line 670 of file KLMTimeAlgorithm.h.

hc_timeFSLP

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

private

BKLM part.

Definition at line 683 of file KLMTimeAlgorithm.h.

hc_timeFSLP_end

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

private

EKLM part.

Definition at line 686 of file KLMTimeAlgorithm.h.

hc_timeFSLPC

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

private

BKLM part.

Definition at line 733 of file KLMTimeAlgorithm.h.

hc_timeFSLPC_end

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

private

EKLM part.

Definition at line 736 of file KLMTimeAlgorithm.h.

m_allExpRun

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

staticprivateinherited

allExpRun

Definition at line 364 of file CalibrationAlgorithm.h.

m_BKLMGeometry

const bklm::GeometryPar* m_BKLMGeometry = nullptr

private

BKLM geometry data.

Definition at line 395 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 285 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 300 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 364 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 371 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 379 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 419 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 398 of file KLMTimeAlgorithm.h.

m_ElementNumbers

const KLMElementNumbers* m_ElementNumbers

private

Element numbers.

Definition at line 392 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 297 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 345 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 353 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 361 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 279 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 719 of file KLMTimeAlgorithm.h.

m_HistTimeLengthEKLM

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

private

Two-dimensional distributions of time versus propagation length.

Definition at line 728 of file KLMTimeAlgorithm.h.

m_inputFileNames

std::vector<std::string> m_inputFileNames

privateinherited

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

Definition at line 373 of file CalibrationAlgorithm.h.

m_jsonExecutionInput

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

privateinherited

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

Definition at line 397 of file CalibrationAlgorithm.h.

m_jsonExecutionOutput

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

privateinherited

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

Definition at line 403 of file CalibrationAlgorithm.h.

m_klmChannels

KLMChannelIndex m_klmChannels

private

KLM ChannelIndex object.

Definition at line 401 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 389 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryCalibratedRPC

double m_LowerTimeBoundaryCalibratedRPC = -40.0

private

Lower time boundary for RPC (calibrated data).

Definition at line 324 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryCalibratedScintillatorsBKLM

double m_LowerTimeBoundaryCalibratedScintillatorsBKLM = -40.0

private

Lower time boundary for BKLM scintillators (calibrated data).

Definition at line 330 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryCalibratedScintillatorsEKLM

double m_LowerTimeBoundaryCalibratedScintillatorsEKLM = -40.0

private

Lower time boundary for EKLM scintillators (calibrated data).

Definition at line 336 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryRPC

double m_LowerTimeBoundaryRPC = -10.0

private

Lower time boundary for RPC.

Definition at line 306 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryScintillatorsBKLM

double m_LowerTimeBoundaryScintillatorsBKLM = 20.0

private

Lower time boundary for BKLM scintillators.

Definition at line 312 of file KLMTimeAlgorithm.h.

m_LowerTimeBoundaryScintillatorsEKLM

double m_LowerTimeBoundaryScintillatorsEKLM = 20.0

private

Lower time boundary for EKLM scintillators.

Definition at line 318 of file KLMTimeAlgorithm.h.

m_mc

bool m_mc = false

private

MC or data.

Definition at line 422 of file KLMTimeAlgorithm.h.

m_MinimalDigitNumber

int m_MinimalDigitNumber = 100000000

private

Minimal digit number (total).

Definition at line 386 of file KLMTimeAlgorithm.h.

m_minimizerOptions

ROOT::Math::MinimizerOptions m_minimizerOptions

private

Minimization options.

Definition at line 404 of file KLMTimeAlgorithm.h.

m_outFile

TFile* m_outFile = nullptr

private

Output file.

Definition at line 753 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 509 of file KLMTimeAlgorithm.h.

m_Profile2BKLMScintillatorZ

TProfile* m_Profile2BKLMScintillatorZ = nullptr

private

For BKLM scintillator z plane.

Definition at line 512 of file KLMTimeAlgorithm.h.

m_Profile2EKLMScintillatorPlane1

TProfile* m_Profile2EKLMScintillatorPlane1 = nullptr

private

For EKLM scintillator plane1.

Definition at line 515 of file KLMTimeAlgorithm.h.

m_Profile2EKLMScintillatorPlane2

TProfile* m_Profile2EKLMScintillatorPlane2 = nullptr

private

For EKLM scintillator plane2.

Definition at line 518 of file KLMTimeAlgorithm.h.

m_Profile2RpcPhi

TProfile* m_Profile2RpcPhi = nullptr

private

For BKLM RPC phi plane.

Definition at line 503 of file KLMTimeAlgorithm.h.

m_Profile2RpcZ

TProfile* m_Profile2RpcZ = nullptr

private

For BKLM RPC z plane.

Definition at line 506 of file KLMTimeAlgorithm.h.

m_ProfileBKLMScintillatorPhi

TProfile* m_ProfileBKLMScintillatorPhi = nullptr

private

For BKLM scintillator phi plane.

Definition at line 489 of file KLMTimeAlgorithm.h.

m_ProfileBKLMScintillatorZ

TProfile* m_ProfileBKLMScintillatorZ = nullptr

private

For BKLM scintillator z plane.

Definition at line 492 of file KLMTimeAlgorithm.h.

m_ProfileEKLMScintillatorPlane1

TProfile* m_ProfileEKLMScintillatorPlane1 = nullptr

private

For EKLM scintillator plane1.

Definition at line 495 of file KLMTimeAlgorithm.h.

m_ProfileEKLMScintillatorPlane2

TProfile* m_ProfileEKLMScintillatorPlane2 = nullptr

private

For EKLM scintillator plane2.

Definition at line 498 of file KLMTimeAlgorithm.h.

m_ProfileRpcPhi

TProfile* m_ProfileRpcPhi = nullptr

private

For BKLM RPC phi plane.

Definition at line 483 of file KLMTimeAlgorithm.h.

m_ProfileRpcZ

TProfile* m_ProfileRpcZ = nullptr

private

For BKLM RPC z plane.

Definition at line 486 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_time_channel

std::map<KLMChannelNumber, double> m_time_channel

private

Time distribution central value of each channel.

Definition at line 294 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 342 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 349 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 357 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 413 of file KLMTimeAlgorithm.h.

m_timeConstants

KLMTimeConstants* m_timeConstants = nullptr

private

DBObject of time cost on some parts of the detector.

Definition at line 407 of file KLMTimeAlgorithm.h.

m_timeRes

std::map<KLMChannelNumber, double> m_timeRes

private

Resolution values of each channel.

Definition at line 291 of file KLMTimeAlgorithm.h.

m_timeResolution

KLMTimeResolution* m_timeResolution = nullptr

private

DBObject of time resolution.

Definition at line 416 of file KLMTimeAlgorithm.h.

m_timeShift

std::map<KLMChannelNumber, double> m_timeShift

private

Shift values of each channel.

Definition at line 288 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryCalibratedRPC

double m_UpperTimeBoundaryCalibratedRPC = 40.0

private

Upper time boundary for RPC (calibrated data).

Definition at line 327 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryCalibratedScintillatorsBKLM

double m_UpperTimeBoundaryCalibratedScintillatorsBKLM = 40.0

private

Upper time boundary for BKLM scintillators (calibrated data).

Definition at line 333 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryCalibratedScintillatorsEKLM

double m_UpperTimeBoundaryCalibratedScintillatorsEKLM = 40.0

private

Upper time boundary for BKLM scintillators (calibrated data).

Definition at line 339 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryRPC

double m_UpperTimeBoundaryRPC = 10.0

private

Upper time boundary for RPC.

Definition at line 309 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryScintillatorsBKLM

double m_UpperTimeBoundaryScintillatorsBKLM = 70.0

private

Upper time boundary for BKLM scintillators.

Definition at line 315 of file KLMTimeAlgorithm.h.

m_UpperTimeBoundaryScintillatorsEKLM

double m_UpperTimeBoundaryScintillatorsEKLM = 70.0

private

Upper time boundary for BKLM scintillators.

Definition at line 321 of file KLMTimeAlgorithm.h.

m_useEventT0

bool m_useEventT0 = true

private

Whether to use event T0 from CDC.

Definition at line 425 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 303 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 367 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 375 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 383 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