Belle II Software  release-05-02-19
ECLBhabhaTCollectorModule Class Reference

This module generates time vs crystal 2D histograms to later (in eclBhabhaTAlgorithm) find time crystal/crate offsets from bhabha events. More...

#include <ECLBhabhaTCollectorModule.h>

Inheritance diagram for ECLBhabhaTCollectorModule:
Collaboration diagram for ECLBhabhaTCollectorModule:

Public Types

enum  EModulePropFlags {
  c_Input = 1,
  c_Output = 2,
  c_ParallelProcessingCertified = 4,
  c_HistogramManager = 8,
  c_InternalSerializer = 16,
  c_TerminateInAllProcesses = 32,
  c_DontCollectStatistics = 64
}
 Each module can be tagged with property flags, which indicate certain features of the module. More...
 
typedef ModuleCondition::EAfterConditionPath EAfterConditionPath
 Forward the EAfterConditionPath definition from the ModuleCondition.
 

Public Member Functions

 ECLBhabhaTCollectorModule ()
 Module constructor.
 
virtual ~ECLBhabhaTCollectorModule ()
 Module destructor.
 
void inDefineHisto () override
 Replacement for defineHisto() in CalibrationCollector modules.
 
void prepare () override
 Define histograms and read payloads from DB.
 
void collect () override
 Select events and crystals and accumulate histograms. More...
 
void initialize () final
 Set up a default RunRange object in datastore and call prepare()
 
void event () final
 Check current experiment and run and update if needed, fill into RunRange and collect()
 
void beginRun () final
 Reset the m_runCollectOnRun flag, if necessary, to begin collection again. More...
 
void endRun () final
 Write the current collector objects to a file and clear their memory.
 
void terminate () final
 Write the final objects to the file.
 
void defineHisto () final
 Runs due to HistoManager, allows us to discover the correct file.
 
template<class T >
void registerObject (std::string name, T *obj)
 Register object with a name, takes ownership, do not access the pointer beyond prepare()
 
template<class T >
T * getObjectPtr (std::string name)
 Calls the CalibObjManager to get the requested stored collector data.
 
virtual std::vector< std::string > getFileNames (__attribute__((unused)) bool outputFiles)
 Return a list of output filenames for this modules. More...
 
const std::string & getName () const
 Returns the name of the module. More...
 
const std::string & getType () const
 Returns the type of the module (i.e. More...
 
const std::string & getPackage () const
 Returns the package this module is in.
 
const std::string & getDescription () const
 Returns the description of the module.
 
void setName (const std::string &name)
 Set the name of the module. More...
 
void setPropertyFlags (unsigned int propertyFlags)
 Sets the flags for the module properties. More...
 
LogConfiggetLogConfig ()
 Returns the log system configuration.
 
void setLogConfig (const LogConfig &logConfig)
 Set the log system configuration.
 
void setLogLevel (int logLevel)
 Configure the log level.
 
void setDebugLevel (int debugLevel)
 Configure the debug messaging level.
 
void setAbortLevel (int abortLevel)
 Configure the abort log level.
 
void setLogInfo (int logLevel, unsigned int logInfo)
 Configure the printed log information for the given level. More...
 
void if_value (const std::string &expression, const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
 Add a condition to the module. More...
 
void if_false (const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
 A simplified version to add a condition to the module. More...
 
void if_true (const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
 A simplified version to set the condition of the module. More...
 
bool hasCondition () const
 Returns true if at least one condition was set for the module.
 
const ModuleConditiongetCondition () const
 Return a pointer to the first condition (or nullptr, if none was set)
 
const std::vector< ModuleCondition > & getAllConditions () const
 Return all set conditions for this module.
 
bool evalCondition () const
 If at least one condition was set, it is evaluated and true returned if at least one condition returns true. More...
 
std::shared_ptr< PathgetConditionPath () const
 Returns the path of the last true condition (if there is at least one, else reaturn a null pointer). More...
 
Module::EAfterConditionPath getAfterConditionPath () const
 What to do after the conditional path is finished. More...
 
std::vector< std::shared_ptr< Path > > getAllConditionPaths () const
 Return all condition paths currently set (no matter if the condition is true or not).
 
bool hasProperties (unsigned int propertyFlags) const
 Returns true if all specified property flags are available in this module. More...
 
bool hasUnsetForcedParams () const
 Returns true and prints error message if the module has unset parameters which the user has to set in the steering file.
 
const ModuleParamListgetParamList () const
 Return module param list.
 
template<typename T >
ModuleParam< T > & getParam (const std::string &name) const
 Returns a reference to a parameter. More...
 
bool hasReturnValue () const
 Return true if this module has a valid return value set.
 
int getReturnValue () const
 Return the return value set by this module. More...
 
std::shared_ptr< PathElementclone () const override
 Create an independent copy of this module. More...
 
std::shared_ptr< boost::python::list > getParamInfoListPython () const
 Returns a python list of all parameters. More...
 

Static Public Member Functions

static void exposePythonAPI ()
 Exposes methods of the Module class to Python.
 

Protected Member Functions

virtual void startRun ()
 Replacement for beginRun(). Do anything you would normally do in beginRun here.
 
virtual void closeRun ()
 Replacement for endRun(). Do anything you would normally do in endRun here.
 
virtual void finish ()
 Replacement for terminate(). Do anything you would normally do in terminate here.
 
virtual void def_initialize ()
 Wrappers to make the methods without "def_" prefix callable from Python. More...
 
virtual void def_beginRun ()
 Wrapper method for the virtual function beginRun() that has the implementation to be used in a call from Python.
 
virtual void def_event ()
 Wrapper method for the virtual function event() that has the implementation to be used in a call from Python.
 
virtual void def_endRun ()
 This method can receive that the current run ends as a call from the Python side. More...
 
virtual void def_terminate ()
 Wrapper method for the virtual function terminate() that has the implementation to be used in a call from Python.
 
void setDescription (const std::string &description)
 Sets the description of the module. More...
 
void setType (const std::string &type)
 Set the module type. More...
 
template<typename T >
void addParam (const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
 Adds a new parameter to the module. More...
 
template<typename T >
void addParam (const std::string &name, T &paramVariable, const std::string &description)
 Adds a new enforced parameter to the module. More...
 
void setReturnValue (int value)
 Sets the return value for this module as integer. More...
 
void setReturnValue (bool value)
 Sets the return value for this module as bool. More...
 
void setParamList (const ModuleParamList &params)
 Replace existing parameter list.
 

Protected Attributes

TDirectory * m_dir
 The top TDirectory that collector objects for this collector will be stored beneath.
 
CalibObjManager m_manager
 Controls the creation, collection and access to calibration objects.
 
RunRangem_runRange
 Overall list of runs processed.
 
Calibration::ExpRun m_expRun
 Current ExpRun for object retrieval (becomes -1,-1 for granularity=all)
 
StoreObjPtr< EventMetaDatam_emd
 Current EventMetaData.
 

Private Member Functions

bool getPreScaleChoice ()
 I'm a little worried about floating point precision when comparing to 0.0 and 1.0 as special values. More...
 
std::list< ModulePtrgetModules () const override
 no submodules, return empty list
 
std::string getPathString () const override
 return the module name.
 
void setParamPython (const std::string &name, const boost::python::object &pyObj)
 Implements a method for setting boost::python objects. More...
 
void setParamPythonDict (const boost::python::dict &dictionary)
 Implements a method for reading the parameter values from a boost::python dictionary. More...
 

Private Attributes

bool m_saveTree
 If true, save TTree with more detailed event info.
 
StoreArray< Tracktracks
 StoreArray for tracks.
 
StoreObjPtr< EventT0m_eventT0
 StoreObjPtr for T0. More...
 
StoreObjPtr< EventMetaDatam_EventMetaData
 Event metadata.
 
DBObjPtr< ECLCrystalCalibm_ElectronicsDB
 electronics amplitude calibration from database Scale amplitudefor each crystal and for dead pre-amps More...
 
std::vector< float > m_Electronics
 vector obtained from DB object
 
DBObjPtr< ECLCrystalCalibm_ElectronicsTimeDB
 Time offset from electronics calibration from database. More...
 
std::vector< float > m_ElectronicsTime
 vector obtained from DB object
 
DBObjPtr< ECLCrystalCalibm_FlightTimeDB
 Time offset from flight time b/w IP and crystal from database. More...
 
std::vector< float > m_FlightTime
 vector obtained from DB object
 
DBObjPtr< ECLCrystalCalibm_PreviousCrystalTimeDB
 Time offset from previous crystal time calibration (this calibration) from database. More...
 
std::vector< float > m_PreviousCrystalTime
 vector obtained from DB object
 
std::vector< float > m_PreviousCrystalTimeUnc
 vector obtained from DB object
 
DBObjPtr< ECLCrystalCalibm_CrateTimeDB
 Time offset from crate time calibration (also this calibration) from database. More...
 
std::vector< float > m_CrateTime
 vector obtained from DB object
 
std::vector< float > m_CrateTimeUnc
 uncertainty vector obtained from DB object
 
DBObjPtr< ECLReferenceCrystalPerCrateCalibm_RefCrystalsCalibDB
 Crystal IDs of the one reference crystal per crate from database. More...
 
std::vector< short > m_RefCrystalsCalib
 vector obtained from DB object
 
TTree * m_dbgTree_electrons = nullptr
 Output tree with detailed event data. More...
 
TTree * m_dbgTree_tracks = nullptr
 Debug TTree output per track.
 
TTree * m_dbgTree_crystals = nullptr
 Debug TTree output per crystal.
 
TTree * m_dbgTree_event = nullptr
 Debug TTree output per event.
 
TTree * m_dbgTree_allCuts = nullptr
 Debug TTree output after all cuts.
 
TTree * m_dbgTree_evt_allCuts = nullptr
 Debug TTree output per event after all cuts.
 
TTree * m_dbgTree_crys_allCuts = nullptr
 Debug TTree output per crystal after all cuts.
 
int m_tree_evtNum
 Event number for debug TTree output.
 
int m_tree_cid
 ECL Cell ID (1..8736) for debug TTree output.
 
double m_tree_phi
 phi position for debug TTree output
 
double m_tree_theta
 theta position for debug TTree output
 
int m_tree_amp
 Fitting amplitude from ECL for debug TTree output.
 
double m_tree_en
 Energy of crystal with maximum energy within ECL cluster, GeV for debug TTree output.
 
double m_tree_E1Etot
 Energy of crystal with maximum energy within ECL cluster divided by total cluster energy, unitless for debug TTree output.
 
double m_tree_E1E2
 Energy of crystal with maximum energy within ECL cluster divided by second most energetic crystal in the cluster, unitless for debug TTree output.
 
double m_tree_E1p
 Energy of crystal with maximum energy within ECL cluster divided by total cluster energy divided by the track momentum, unitless for debug TTree output.
 
int m_tree_quality
 ECL fit quality for debug TTree output.
 
double m_tree_timeF
 ECL fitting time for debug TTree output.
 
double m_tree_time
 Time for Ts distribution for debug TTree output.
 
double m_tree_timetsPreviousTimeCalibs
 Time for Ts distribution after application of previous time calibrations for debug TTree output.
 
double m_tree_t0 = realNaN
 EventT0 (not from ECL) for debug TTree output.
 
double m_tree_t0_unc = realNaN
 EventT0 uncertainty for debug TTree output.
 
double m_tree_t0_ECLclosestCDC = realNaN
 EventT0 (from ECL) closest to CDC for debug TTree output.
 
double m_tree_t0_ECL_minChi2 = realNaN
 EventT0 (from ECL) min chi2 for debug TTree output.
 
double m_tree_d0 = realNaN
 Track d0 for debug TTree output.
 
double m_tree_z0 = realNaN
 Track z0 for debug TTree output.
 
double m_tree_p = realNaN
 Track momentum for debug TTree output.
 
double m_tree_nCDChits = realNaN
 Number of CDC hits along the track for debug TTree output.
 
double m_tree_clustCrysE_DIV_maxEcrys = realNaN
 ratio of crystal energy to energy of the crystal that has the maximum energy, only for the crystals that meet all the selection criteria for debug TTree output
 
double m_tree_clustCrysE = realNaN
 crystal energy, only for the crystals that meet all the selection criteria for debug TTree output
 
double m_tree_enPlus
 Energy of cluster associated to positively charged track, GeV for debug TTree output.
 
double m_tree_enNeg
 Energy of cluster associated to negatively charged track, GeV for debug TTree output.
 
double m_tree_tClustPos
 Cluster time of cluster associated to positively charged track, ns for debug TTree output.
 
double m_tree_tClustNeg
 Cluster time of cluster associated to negatively charged track, ns for debug TTree output.
 
double m_tree_maxEcrystPosClust
 Time of the highest energy crystal in the cluster associated to positively charged track, ns for debug TTree output.
 
double m_tree_maxEcrystNegClust
 Time of the highest energy crystal in the cluster associated to negatively charged track, ns for debug TTree output.
 
double m_tree_tClust
 Cluster time of a cluster, ns for debug TTree output.
 
double m_tree_ECLCalDigitTime
 Time of an ECLCalDigit within a cluster, ns for debug TTree output.
 
double m_tree_ECLCalDigitE
 Energy of an ECLCalDigit within a cluster, GeV for debug TTree output.
 
double m_tree_ECLDigitAmplitude
 Amplitude (used to calculate energy) of an ECLDigit within a cluster, for debug TTree output.
 
int m_charge
 particle charge, for debug TTree output
 
double m_E_DIV_p
 Energy divided by momentum, for debug TTree output.
 
double m_massInvTracks
 invariant mass of the two tracks, for debug TTree output
 
StoreArray< ECLDigitm_eclDigitArray
 Required input array of ECLDigits.
 
StoreArray< ECLCalDigitm_eclCalDigitArray
 Required input array of ECLCalDigits.
 
StoreArray< ECLClusterm_eclClusterArray
 Required input array of ECLClusters.
 
std::vector< float > m_EperCrys
 ECL cal digit energy for each crystal.
 
std::vector< int > m_eclCalDigitID
 ECL cal digit id sorter.
 
std::vector< int > m_eclDigitID
 ECL digit id sorter.
 
short m_timeAbsMax
 Events with abs(time) > m_timeAbsMax are excluded, mostly for histogram x-range purposes.
 
int m_minCrystal
 First CellId to handle.
 
int m_maxCrystal
 Last CellId to handle.
 
double m_looseTrkZ0 = realNaN
 Loose track z0 minimum cut.
 
double m_tightTrkZ0 = realNaN
 Tight track z0 minimum cut.
 
double m_looseTrkD0 = realNaN
 Loose track d0 minimum cut.
 
double m_tightTrkD0 = realNaN
 Tight track d0 minimum cut.
 
int m_crystalCrate
 Crate id for the crystal.
 
int m_runNum
 run number
 
bool m_storeCalib = true
 Boolean for whether or not to store the previous calibration calibration constants.
 
std::unique_ptr< Belle2::ECL::ECLTimingUtilitiesm_ECLTimeUtil
 ECL timing tools. More...
 
double m_hadronEventT0_TO_bhabhaEventT0_correction
 correction to apply to CDC event t0 values in bhabha events to correct for CDC event t0 bias compared to CDC event t0 in hadronic events in ns
 
std::string m_granularity
 Granularity of data collection = run|all(= no granularity, exp,run=-1,-1)
 
int m_maxEventsPerRun
 Maximum number of events to be collected at the start of each run (-1 = no maximum)
 
float m_preScale
 Prescale module parameter, this fraction of events will have collect() run on them [0.0 -> 1.0].
 
StoreObjPtr< EventMetaDatam_evtMetaData
 Required input for EventMetaData.
 
bool m_runCollectOnRun = true
 Whether or not we will run the collect() at all this run, basically skips the event() function if false.
 
std::map< Calibration::ExpRun, int > m_expRunEvents
 How many events processed for each ExpRun so far, stops counting up once max is hit Only used/incremented if m_maxEventsPerRun > -1.
 
int * m_eventsCollectedInRun
 Will point at correct value in m_expRunEvents.
 
std::string m_name
 The name of the module, saved as a string (user-modifiable)
 
std::string m_type
 The type of the module, saved as a string.
 
std::string m_package
 Package this module is found in (may be empty).
 
std::string m_description
 The description of the module.
 
unsigned int m_propertyFlags
 The properties of the module as bitwise or (with |) of EModulePropFlags.
 
LogConfig m_logConfig
 The log system configuration of the module.
 
ModuleParamList m_moduleParamList
 List storing and managing all parameter of the module.
 
bool m_hasReturnValue
 True, if the return value is set.
 
int m_returnValue
 The return value.
 
std::vector< ModuleConditionm_conditions
 Module condition, only non-null if set.
 

Detailed Description

This module generates time vs crystal 2D histograms to later (in eclBhabhaTAlgorithm) find time crystal/crate offsets from bhabha events.

Definition at line 49 of file ECLBhabhaTCollectorModule.h.

Member Enumeration Documentation

◆ EModulePropFlags

enum EModulePropFlags
inherited

Each module can be tagged with property flags, which indicate certain features of the module.

Enumerator
c_Input 

This module is an input module (reads data).

c_Output 

This module is an output module (writes data).

c_ParallelProcessingCertified 

This module can be run in parallel processing mode safely (All I/O must be done through the data store, in particular, the module must not write any files.)

c_HistogramManager 

This module is used to manage histograms accumulated by other modules.

c_InternalSerializer 

This module is an internal serializer/deserializer for parallel processing.

c_TerminateInAllProcesses 

When using parallel processing, call this module's terminate() function in all processes().

This will also ensure that there is exactly one process (single-core if no parallel modules found) or at least one input, one main and one output process.

c_DontCollectStatistics 

No statistics is collected for this module.

Definition at line 79 of file Module.h.

Member Function Documentation

◆ beginRun()

void beginRun ( )
finalvirtualinherited

Reset the m_runCollectOnRun flag, if necessary, to begin collection again.

It seems that the beginRun() function is called in each basf2 subprocess when the run changes in each process. This is nice because it allows us to write the new (exp,run) object creation in the beginRun function as though the other processes don't exist.

Reimplemented from HistoModule.

Definition at line 70 of file CalibrationCollectorModule.cc.

◆ clone()

std::shared_ptr< PathElement > clone ( ) const
overridevirtualinherited

Create an independent copy of this module.

Note that parameters are shared, so changing them on a cloned module will also affect the original module.

Implements PathElement.

Definition at line 181 of file Module.cc.

◆ collect()

void collect ( )
overridevirtual

Select events and crystals and accumulate histograms.

< vector derived from DB object

Store the crystal cell id of those being used as the reference crystals for ts. One crystal per crate is defined as having ts=0. This histogram only keeps track of the crystal id, not the crate id. The talg can figure out to which crate to associate the crystal.

Record the input database constants

< number of loose tracks

< number of tight tracks

Reimplemented from CalibrationCollectorModule.

Definition at line 315 of file ECLBhabhaTCollectorModule.cc.

316 {
317  int cutIndexPassed = 0;
318  getObjectPtr<TH1F>("cutflow")->Fill(cutIndexPassed);
319  B2DEBUG(22, "Cutflow: no cuts: index = " << cutIndexPassed);
320  B2DEBUG(22, "Event number = " << m_EventMetaData->getEvent());
321 
322 
323  /* Use ECLChannelMapper to get other detector indices for the crystals */
324  /* For conversion from CellID to crate, shaper, and channel ids. */
325 
326  // Use smart pointer to avoid memory leak when the ECLChannelMapper object needs destroying at the end of the event.
327  shared_ptr< ECL::ECLChannelMapper > crystalMapper(new ECL::ECLChannelMapper());
328  crystalMapper->initFromDB();
329 
330  //== Get expected energies and calibration constants from DB. Need to call
331  // hasChanged() for later comparison
332  if (m_ElectronicsDB.hasChanged()) {
333  m_Electronics = m_ElectronicsDB->getCalibVector();
334  }
335  if (m_ElectronicsTimeDB.hasChanged()) {
336  m_ElectronicsTime = m_ElectronicsTimeDB->getCalibVector();
337  }
338  if (m_FlightTimeDB.hasChanged()) {
339  m_FlightTime = m_FlightTimeDB->getCalibVector();
340  }
341 
342  // Get the previous crystal time offset (the same thing that this calibration is meant to calculate).
343  // This can be used for testing purposes, and for the crate time offset.
344  if (m_PreviousCrystalTimeDB.hasChanged()) {
346  m_PreviousCrystalTimeUnc = m_PreviousCrystalTimeDB->getCalibUncVector();
347  }
348 
349  B2DEBUG(29, "Finished checking if previous crystal time payload has changed");
350  if (m_CrateTimeDB.hasChanged()) {
351  m_CrateTime = m_CrateTimeDB->getCalibVector();
352  m_CrateTimeUnc = m_CrateTimeDB->getCalibUncVector();
353  }
354  B2DEBUG(29, "Finished checking if previous crate time payload has changed");
355  B2DEBUG(29, "m_CrateTime size = " << m_CrateTime.size());
356  B2DEBUG(25, "Crate time +- uncertainty [0]= " << m_CrateTime[0] << " +- " << m_CrateTimeUnc[0]);
357  B2DEBUG(25, "Crate time +- uncertainty [8735]= " << m_CrateTime[8735] << " +- " << m_CrateTimeUnc[8735]);
358 
359  B2DEBUG(29, "Finished checking if previous crate time payload has changed");
360  if (m_RefCrystalsCalibDB.hasChanged()) {
361  m_RefCrystalsCalib = m_RefCrystalsCalibDB->getReferenceCrystals();
362  }
363  B2DEBUG(29, "Finished checking if reference crystal cell ids payload has changed");
364 
365 
366  B2DEBUG(25, "ECLBhabhaTCollector:: loaded ECLCrystalTimeOffset from the database"
367  << LogVar("IoV", m_PreviousCrystalTimeDB.getIoV())
368  << LogVar("Checksum", m_PreviousCrystalTimeDB.getChecksum()));
369  B2DEBUG(25, "ECLBhabhaTCollector:: loaded ECLCrateTimeOffset from the database"
370  << LogVar("IoV", m_CrateTimeDB.getIoV())
371  << LogVar("Checksum", m_CrateTimeDB.getChecksum()));
372  B2DEBUG(25, "ECLBhabhaTCollector:: loaded ECLCrystalElectronics from the database"
373  << LogVar("IoV", m_ElectronicsDB.getIoV())
374  << LogVar("Checksum", m_ElectronicsDB.getChecksum()));
375  B2DEBUG(25, "ECLBhabhaTCollector:: loaded ECLCrystalElectronicsTime from the database"
376  << LogVar("IoV", m_ElectronicsTimeDB.getIoV())
377  << LogVar("Checksum", m_ElectronicsTimeDB.getChecksum()));
378  B2DEBUG(25, "ECLBhabhaTCollector:: loaded ECLCrystalFlightTime from the database"
379  << LogVar("IoV", m_FlightTimeDB.getIoV())
380  << LogVar("Checksum", m_FlightTimeDB.getChecksum()));
381  B2DEBUG(25, "ECLBhabhaTCollector:: loaded ECLReferenceCrystalPerCrateCalib from the database"
382  << LogVar("IoV", m_RefCrystalsCalibDB.getIoV())
383  << LogVar("Checksum", m_RefCrystalsCalibDB.getChecksum()));
384 
385 
386 
387  // Conversion coefficient from ADC ticks to nanoseconds
388  // TICKS_TO_NS ~ 0.4913 ns/clock tick
389  // 1/(4fRF) = 0.4913 ns/clock tick, where fRF is the accelerator RF frequency, fRF=508.889 MHz.
390  const double TICKS_TO_NS = 1.0 / (4.0 * EclConfiguration::m_rf) * 1e3;
391 
392 
393  vector<float> Crate_time_ns(52, 0.0);
395  // Make a crate time offset vector with an entry per crate (instead of per crystal) and convert from ADC counts to ns.
396  for (int crysID = 1; crysID <= 8736; crysID++) {
397  int crateID_temp = crystalMapper->getCrateID(crysID);
398  Crate_time_ns[crateID_temp - 1] = m_CrateTime[crysID] * TICKS_TO_NS;
399  }
400 
401 
402 
408  for (int crateID_temp = 1; crateID_temp <= 52; crateID_temp++) {
409  getObjectPtr<TH1F>("refCrysIDzeroingCrate")->Fill(m_RefCrystalsCalib[crateID_temp - 1] + 0.001);
410  }
411 
412 
414  for (int crysID = 1; crysID <= 8736; crysID++) {
415  getObjectPtr<TH1F>("TsDatabase")->SetBinContent(crysID + 0.001, m_PreviousCrystalTime[crysID - 1]);
416  getObjectPtr<TH1F>("TsDatabaseUnc")->SetBinContent(crysID + 0.001, m_PreviousCrystalTimeUnc[crysID - 1]);
417  getObjectPtr<TH1F>("TcrateDatabase")->SetBinContent(crysID + 0.001, m_CrateTime[crysID - 1]);
418  getObjectPtr<TH1F>("TcrateUncDatabase")->SetBinContent(crysID + 0.001, m_CrateTimeUnc[crysID - 1]);
419  }
420  if (m_storeCalib) {
421  B2INFO("ECLBhabhaTCollector:: ECLCrystalTimeOffset from the database information:"
422  << LogVar("IoV", m_PreviousCrystalTimeDB.getIoV())
423  << LogVar("Checksum", m_PreviousCrystalTimeDB.getChecksum()));
424  B2INFO("First event so print out previous ts values");
425  for (int crysID = 1; crysID <= 8736; crysID++) {
426  B2INFO("cid = " << crysID << ", Ts previous = " << m_PreviousCrystalTime[crysID - 1]);
427  }
428  m_storeCalib = false;
429  }
430 
431 
432 
433 
434  for (int crateID_temp = 1; crateID_temp <= 52; crateID_temp++) {
435  getObjectPtr<TH1F>("tcrateDatabase_ns")->SetBinContent(crateID_temp + 0.001, Crate_time_ns[crateID_temp - 1]);
436  }
437 
438  // Use a histogram with only one bin as a counter to know the number of times the database histograms were filled.
439  // This is mostly useful for the talg when running over multiple runs and trying to read ts values.
440  getObjectPtr<TH1I>("databaseCounter")->SetBinContent(1, 1);
441 
442 
443 
444  // Save what CDC event t0 correction was applied
445  getObjectPtr<TH1F>("CDCEventT0Correction")->SetBinContent(1, m_hadronEventT0_TO_bhabhaEventT0_correction);
446 
447 
448 
449 
450  /* Getting the event t0 using the full event t0 rather than from the CDC specifically */
451  double evt_t0 = -1;
452  double evt_t0_unc = -1;
453  double evt_t0_ECL_closestCDC = -1;
454  double evt_t0_ECL_minChi2 = -1;
455 
456  // Determine if there is an event t0 to use and then extract the information about it
457  if (!m_eventT0.isValid()) {
458  //cout << "event t0 not valid\n";
459  return;
460  } else if (!m_eventT0->hasTemporaryEventT0(Const::EDetector::CDC)) {
461  //cout << "no event t0\n";
462  return;
463  } else {
464  // Event has a t0 from CDC
465  cutIndexPassed++;
466  getObjectPtr<TH1F>("cutflow")->Fill(cutIndexPassed);
467  B2DEBUG(22, "Cutflow: Event t0 exists: index = " << cutIndexPassed);
468 
469 
470  // Get event t0 from CDC. We don't want event t0 from ECL as we are calibrating the ECL wrt the more accurately measured time measurements of the time. Start with the CDC since it has an event t0 but in the future we may switch to the TOP detector.
471  // Based on the information from Thomas Hauth <Thomas.Hauth@kit.edu> (leaving physics) we should take the last event t0 in the list of event t0's from the CDC as the later event t0 measurements are calculated in slower but more accurate ways.
472  vector<EventT0::EventT0Component> evt_t0_list = m_eventT0->getTemporaryEventT0s(Const::EDetector::CDC);
473  evt_t0 = evt_t0_list.back().eventT0; // time value
474  evt_t0_unc = evt_t0_list.back().eventT0Uncertainty; // uncertainty on event t0
475 
476 
477  // Correct the CDC event t0 value for the bhabha bias
478  evt_t0 = evt_t0 + m_hadronEventT0_TO_bhabhaEventT0_correction; // Bias not yet fixed in CDC t0 reco.
479 
480 
481  // Get the ECL event t0 for comparison - validations
482  if (m_eventT0->hasTemporaryEventT0(Const::EDetector::ECL)) {
483  vector<EventT0::EventT0Component> evt_t0_list_ECL = m_eventT0->getTemporaryEventT0s(Const::EDetector::ECL);
484 
485 
486  double smallest_CDC_ECL_t0_diff = fabs(evt_t0_list_ECL[0].eventT0 - evt_t0);
487  int smallest_CDC_ECL_t0_diff_idx = 0;
488  for (long unsigned int ECLi = 0; ECLi < evt_t0_list_ECL.size(); ECLi++) {
489  double tempt_ECL_t0 = evt_t0_list_ECL[ECLi].eventT0;
490  if (fabs(tempt_ECL_t0 - evt_t0) < smallest_CDC_ECL_t0_diff) {
491  smallest_CDC_ECL_t0_diff = fabs(tempt_ECL_t0 - evt_t0);
492  smallest_CDC_ECL_t0_diff_idx = ECLi;
493  }
494  }
495 
496  evt_t0_ECL_closestCDC = evt_t0_list_ECL[smallest_CDC_ECL_t0_diff_idx].eventT0; // time value
497  B2DEBUG(26, "evt_t0_ECL_closestCDC = " << evt_t0_ECL_closestCDC);
498 
499 
500 
501  double smallest_ECL_t0_minChi2 = evt_t0_list_ECL[0].quality;
502  int smallest_ECL_t0_minChi2_idx = 0;
503 
504  B2DEBUG(26, "evt_t0_list_ECL[0].quality = " << evt_t0_list_ECL[0].quality
505  << ", with ECL event t0 = " << evt_t0_list_ECL[0].eventT0);
506 
507  for (long unsigned int ECLi = 0; ECLi < evt_t0_list_ECL.size(); ECLi++) {
508  B2DEBUG(26, "evt_t0_list_ECL[" << ECLi << "].quality = " << evt_t0_list_ECL[ECLi].quality
509  << ", with ECL event t0 = " <<
510  evt_t0_list_ECL[ECLi].eventT0);
511  if (evt_t0_list_ECL[ECLi].quality < smallest_ECL_t0_minChi2) {
512  smallest_ECL_t0_minChi2 = evt_t0_list_ECL[ECLi].quality;
513  smallest_ECL_t0_minChi2_idx = ECLi;
514  }
515  }
516 
517  evt_t0_ECL_minChi2 = evt_t0_list_ECL[smallest_ECL_t0_minChi2_idx].eventT0; // time value
518 
519  B2DEBUG(26, "evt_t0_ECL_minChi2 = " << evt_t0_ECL_minChi2);
520  B2DEBUG(26, "smallest_ECL_t0_minChi2_idx = " << smallest_ECL_t0_minChi2_idx);
521  }
522  }
523 
524 
525 
526  /* Determine the energies for each of the crystals since this isn't naturally connected to the cluster.
527  Also determine the indexing of the ecl cal digits and the ecl digits
528  Taken from Chris's ec/modules/eclGammaGammaECollector */
529 
530  // Resize vectors
531  m_EperCrys.resize(8736);
532  m_eclCalDigitID.resize(8736);
533  m_eclDigitID.resize(8736);
534 
535 
536  int idx = 0;
537  for (auto& eclCalDigit : m_eclCalDigitArray) {
538  int tempCrysID = eclCalDigit.getCellId() - 1;
539  m_EperCrys[tempCrysID] = eclCalDigit.getEnergy();
540  m_eclCalDigitID[tempCrysID] = idx;
541  idx++;
542  }
543 
544  idx = 0;
545  for (auto& eclDigit : m_eclDigitArray) {
546  int tempCrysID = eclDigit.getCellId() - 1;
547  m_eclDigitID[tempCrysID] = idx;
548  idx++;
549  }
550 
551 
552 
553 
554  //---------------------------------------------------------------------
555  //..Some utilities
556  ClusterUtils cUtil;
557  const TVector3 clustervertex = cUtil.GetIPPosition();
558  PCmsLabTransform boostrotate;
559 
560  //---------------------------------------------------------------------
561  //..Track properties, including 2 maxp tracks. Use pion (211) mass hypothesis,
562  // which is the only particle hypothesis currently available???
563  double maxp[2] = {0., 0.};
564  int maxiTrk[2] = { -1, -1};
565  int nTrkAll = tracks.getEntries();
566 
567  int nTrkLoose = 0;
568  int nTrkTight = 0;
570  /* Loop over all the tracks to define the tight and loose selection tracks.
571  We will select events with only 2 tight tracks and no additional loose tracks.
572  Tight tracks are a subset of looses tracks. */
573  for (int iTrk = 0; iTrk < nTrkAll; iTrk++) {
574  // Get track biasing towards the particle being a pion based on what particle types
575  // are used for reconstruction at this stage.
576  const TrackFitResult* tempTrackFit = tracks[iTrk]->getTrackFitResultWithClosestMass(Const::pion);
577  if (not tempTrackFit) {continue;}
578 
579  // Collect track info to be used for categorizing
580  short charge = tempTrackFit->getChargeSign();
581  double z0 = tempTrackFit->getZ0();
582  double d0 = tempTrackFit->getD0();
583  int nCDChits = tempTrackFit->getHitPatternCDC().getNHits();
584  double p = tempTrackFit->getMomentum().Mag();
585 
586  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
587  //== Save debug TTree with detailed information if necessary.
588  m_tree_d0 = d0;
589  m_tree_z0 = z0;
590  m_tree_p = p;
591  m_charge = charge;
592  m_tree_nCDChits = nCDChits;
593 
594  if (m_saveTree) {
595  m_dbgTree_tracks->Fill();
596  }
597  //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
598 
599 
600  /* Test if loose track */
601 
602  // d0 and z0 cuts
603  if (fabs(d0) > m_looseTrkD0) {
604  continue;
605  }
606  if (fabs(z0) > m_looseTrkZ0) {
607  continue;
608  }
609  // Number of hits in the CDC
610  if (nCDChits < 1) {
611  continue;
612  }
613  nTrkLoose++;
614 
615 
616 
617  /* Test if the loose track is also a tight track */
618 
619  // Number of hits in the CDC
620  if (nCDChits < 20) {
621  continue;
622  }
623 
624 
625  // d0 and z0 cuts
626  if (fabs(d0) > m_tightTrkD0) {
627  continue;
628  }
629  if (fabs(z0) > m_tightTrkZ0) {
630  continue;
631  }
632  nTrkTight++;
633 
634  // Sorting of tight tracks. Not really required as we only want two tight tracks (at the moment) but okay.
635  //..Find the maximum p negative [0] and positive [1] tracks
636  int icharge = 0;
637  if (charge > 0) {icharge = 1;}
638  if (p > maxp[icharge]) {
639  maxp[icharge] = p;
640  maxiTrk[icharge] = iTrk;
641  }
642 
643  }
644  /* After that last section the numbers of loose and tight tracks are known as well as the
645  index of the loose tracks that have the highest p negatively charged and highest p positively
646  charged tracks as measured in the centre of mass frame */
647 
648 
649  if (nTrkTight != 2) {
650  return;
651  }
652  // There are exactly two tight tracks
653  cutIndexPassed++;
654  getObjectPtr<TH1F>("cutflow")->Fill(cutIndexPassed);
655  B2DEBUG(22, "Cutflow: Two tight tracks: index = " << cutIndexPassed);
656 
657 
658  if (nTrkLoose != 2) {
659  return;
660  }
661  // There are exactly two loose tracks as well, i.e. no additional loose tracks
662  cutIndexPassed++;
663  getObjectPtr<TH1F>("cutflow")->Fill(cutIndexPassed);
664  B2DEBUG(22, "Cutflow: No additional loose tracks: index = " << cutIndexPassed);
665 
666  /* Determine if the two tracks have the opposite electric charge.
667  We know this because the track indices stores the max pt track in [0] for negatively charged track
668  and [1] fo the positively charged track. If both are filled then both a negatively charged
669  and positively charged track were found. */
670  bool oppositelyChargedTracksPassed = maxiTrk[0] != -1 && maxiTrk[1] != -1;
671  if (!oppositelyChargedTracksPassed) {
672  return;
673  }
674  // The two tracks have the opposite electric charges.
675  cutIndexPassed++;
676  getObjectPtr<TH1F>("cutflow")->Fill(cutIndexPassed);
677  B2DEBUG(22, "Cutflow: Oppositely charged tracks: index = " << cutIndexPassed);
678 
679 
680 
681 
682  //---------------------------------------------------------------------
683  /* Determine associated energy clusters to each of the two tracks. Sum the energies of the
684  multiple clusters to each track and find the crystal with the maximum energy within all
685  the sets of clusters associated to the tracks*/
686  double trkEClustLab[2] = {0., 0.};
687  double trkEClustCOM[2] = {0., 0.};
688  double trkpLab[2];
689  double trkpCOM[2];
690  TLorentzVector trkp4Lab[2];
691  TLorentzVector trkp4COM[2];
692 
693  // Index of the cluster and the crystal that has the highest energy crystal for the two tracks
694  int crysIDMax[2] = { -1, -1 };
695  double crysEMax[2] = { -1, -1 };
696  double crysE2Max[2] = { -1, -1 };
697  int numClustersPerTrack[2] = { 0, 0 };
698 
699  double clusterTime[2] = {0, 0};
700 
701  double E_DIV_p[2];
702 
703  vector<double> time_ECLCaldigits_bothClusters;
704  vector<int> cid_ECLCaldigits_bothClusters;
705  vector<double> E_ECLCaldigits_bothClusters;
706  vector<double> amp_ECLDigits_bothClusters;
707  vector<int> chargeID_ECLCaldigits_bothClusters;
708 
709  for (int icharge = 0; icharge < 2; icharge++) {
710  if (maxiTrk[icharge] > -1) {
711  B2DEBUG(22, "looping over the 2 max pt tracks");
712 
713  const TrackFitResult* tempTrackFit = tracks[maxiTrk[icharge]]->getTrackFitResultWithClosestMass(Const::pion);
714  if (not tempTrackFit) {continue;}
715  trkp4Lab[icharge] = tempTrackFit->get4Momentum();
716  trkp4COM[icharge] = boostrotate.rotateLabToCms() * trkp4Lab[icharge];
717  trkpLab[icharge] = trkp4Lab[icharge].Rho();
718  trkpCOM[icharge] = trkp4COM[icharge].Rho();
719 
720 
721  /* For each cluster associated to the current track, sum up the energies to get the total
722  energy of all clusters associated to the track and find which crystal has the highest
723  energy from all those clusters*/
724  auto eclClusterRelationsFromTracks = tracks[maxiTrk[icharge]]->getRelationsTo<ECLCluster>();
725  for (unsigned int clusterIdx = 0; clusterIdx < eclClusterRelationsFromTracks.size(); clusterIdx++) {
726 
727  B2DEBUG(22, "Looking at clusters. index = " << clusterIdx);
728  auto cluster = eclClusterRelationsFromTracks[clusterIdx];
729  bool goodClusterType = false;
730 
731  if (cluster->hasHypothesis(Belle2::ECLCluster::EHypothesisBit::c_nPhotons)) {
732  trkEClustLab[icharge] += cluster->getEnergy(Belle2::ECLCluster::EHypothesisBit::c_nPhotons);
733  goodClusterType = true;
734  numClustersPerTrack[icharge]++;
735  }
736 
737  if (goodClusterType) {
738 
739  clusterTime[icharge] = cluster->getTime();
740 
741  auto eclClusterRelations = cluster->getRelationsTo<ECLCalDigit>("ECLCalDigits");
742 
743  // Find the crystal that has the largest energy
744  for (unsigned int ir = 0; ir < eclClusterRelations.size(); ir++) {
745  const auto calDigit = eclClusterRelations.object(ir);
746  int tempCrysID = calDigit->getCellId() - 1;
747  double tempE = m_EperCrys[tempCrysID];
748 
749  int eclDigitIndex = m_eclDigitID[tempCrysID];
750  ECLDigit* ecl_dig = m_eclDigitArray[eclDigitIndex];
751 
752  // for the max E crystal
753  if (tempE > crysEMax[icharge]) {
754  // Set 2nd highest E crystal to the info from the highest E crystal
755  crysE2Max[icharge] = crysEMax[icharge];
756  // Set the highest E crystal to the current crystal
757  crysEMax[icharge] = tempE;
758  crysIDMax[icharge] = tempCrysID;
759  }
760  // for the 2nd highest E crystal
761  if (tempE > crysE2Max[icharge] && tempCrysID != crysIDMax[icharge]) {
762  crysE2Max[icharge] = tempE;
763  }
764 
765  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
766  // If we drop the information about the second highest energy crystal we could use
767  // m_eclClusterArray[ic]->getMaxECellId()
768 
769  B2DEBUG(26, "calDigit(ir" << ir << ") time = " << calDigit->getTime() << "ns , with E = " << tempE << " GeV");
770  time_ECLCaldigits_bothClusters.push_back(calDigit->getTime());
771  cid_ECLCaldigits_bothClusters.push_back(tempCrysID);
772  E_ECLCaldigits_bothClusters.push_back(tempE);
773  amp_ECLDigits_bothClusters.push_back(ecl_dig->getAmp());
774  chargeID_ECLCaldigits_bothClusters.push_back(icharge);
775 
776  }
777  }
778  }
779  trkEClustCOM[icharge] = trkEClustLab[icharge] * trkpCOM[icharge] / trkpLab[icharge];
780 
781  // Check both electrons to see if their cluster energy / track momentum is good.
782  // The Belle II physics book shows that this is the main way of separating electrons from other particles
783  // Done in the centre of mass reference frame although I believe E/p is invariant under a boost.
784  E_DIV_p[icharge] = trkEClustCOM[icharge] / trkpCOM[icharge];
785 
786  }
787  }
788  /* At the end of this section the 3-momenta magnitudes and the cluster energies are known
789  for the two saved track indices for both the lab and COM frames.
790  The crystal with the maximum energy, one associated to each track, is recorded*/
791 
792 
793 
794  //=== Check each crystal in the processed event and fill histogram.
795 
796  int cid;
797  double time;
798  int numCrystalsPassingCuts = 0;
799 
800  int crystalIDs[2] = { -1, -1};
801  int crateIDs[2] = { -1, -1};
802  double ts_prevCalib[2] = { -1, -1};
803  double tcrate_prevCalib[2] = { -1, -1};
804  double times_noPreviousCalibrations[2] = { -1, -1};
805  bool crystalCutsPassed[2] = {false, false};
806  double crystalEnergies[2] = { -1, -1};
807  double crystalEnergies2[2] = { -1, -1};
808 
809  for (int iCharge = 0; iCharge < 2; iCharge++) {
810  int crystal_idx = crysIDMax[iCharge];
811  int eclCalDigitIndex = m_eclCalDigitID[crystal_idx];
812  int eclDigitIndex = m_eclDigitID[crystal_idx];
813 
814  ECLDigit* ecl_dig = m_eclDigitArray[eclDigitIndex];
815  ECLCalDigit* ecl_cal = m_eclCalDigitArray[eclCalDigitIndex];
816 
817  //== Check whether specific ECLDigits should be excluded.
818 
819  auto en = ecl_cal->getEnergy();
820  auto amplitude = ecl_dig->getAmp();
821  crystalEnergies[iCharge] = en;
822 
823  cid = ecl_dig->getCellId();
824  time = ecl_dig->getTimeFit() * TICKS_TO_NS - evt_t0;
825 
826  // Offset time by electronics calibration and flight time calibration.
827  time -= m_ElectronicsTime[cid - 1] * TICKS_TO_NS;
828  time -= m_FlightTime[cid - 1];
829 
830 
831  // Apply the time walk correction: time shift as a function of the amplitude corrected by the electronics calibration.
832  // The electronics calibration also accounts for crystals that have a dead pre-amp and thus half the normal amplitude.
833  double energyTimeShift = m_ECLTimeUtil->energyDependentTimeOffsetElectronic(amplitude * m_Electronics[cid - 1]) * TICKS_TO_NS;
834 
835  B2DEBUG(29, "cellid = " << cid << ", amplitude = " << amplitude << ", time before t(E) shift = " << time <<
836  ", t(E) shift = " << energyTimeShift << " ns");
837  time -= energyTimeShift;
838 
839 
840  // Cell ID should be within specified range.
841  if (cid < m_minCrystal || cid > m_maxCrystal) continue;
842 
843  // Absolute time should be in specified range condition.
844  if (fabs(time) > m_timeAbsMax) continue;
845 
846  // Fit quality flag -- choose only events with best fit quality
847  if (ecl_dig->getQuality() != 0) continue;
848 
849  //== Save time and crystal information. Fill plot after both electrons are tested
850  crystalIDs[iCharge] = cid;
851  crateIDs[iCharge] = crystalMapper->getCrateID(ecl_cal->getCellId());
852 
853 
854  ts_prevCalib[iCharge] = m_PreviousCrystalTime[cid - 1] * TICKS_TO_NS;
855  tcrate_prevCalib[iCharge] = m_CrateTime[cid - 1] * TICKS_TO_NS;
856  times_noPreviousCalibrations[iCharge] = time;
857 
858 
859  B2DEBUG(26, "iCharge = " << iCharge);
860  B2DEBUG(26, "crateIDs[iCharge] = " << crateIDs[iCharge]);
861  B2DEBUG(26, "times_noPreviousCalibrations[iCharge] = " << times_noPreviousCalibrations[iCharge]);
862  B2DEBUG(26, "tcrate_prevCalib[iCharge] = " << tcrate_prevCalib[iCharge]);
863  B2DEBUG(26, "ts_prevCalib[iCharge] = " << ts_prevCalib[iCharge]);
864 
865 
866  crystalCutsPassed[iCharge] = true;
867 
868 
869  // For second most energetic energy crystal
870  crystalEnergies2[iCharge] = crysE2Max[iCharge];
871 
872 
873 // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Tree saving
874  //== Save debug TTree with detailed information if necessary.
875  StoreObjPtr<EventMetaData> evtMetaData;
876 
877  m_tree_cid = ecl_dig->getCellId();
878  m_tree_amp = ecl_dig->getAmp();
879  m_tree_en = en;
880  m_tree_E1Etot = en / trkEClustLab[iCharge];
881  m_tree_E1E2 = en / crystalEnergies2[iCharge];
882  m_tree_E1p = en / trkpLab[iCharge];
883  m_tree_timetsPreviousTimeCalibs = time - ts_prevCalib[iCharge] - tcrate_prevCalib[iCharge];
884  m_tree_timeF = ecl_dig->getTimeFit() * TICKS_TO_NS;
885  m_tree_time = time;
886  m_tree_quality = ecl_dig->getQuality();
887  m_tree_t0 = evt_t0;
888  m_tree_t0_unc = evt_t0_unc;
889  m_E_DIV_p = E_DIV_p[iCharge];
890  m_tree_evtNum = evtMetaData->getEvent();
891  m_crystalCrate = crystalMapper->getCrateID(ecl_cal->getCellId());
892  m_runNum = evtMetaData->getRun();
893 
894  if (m_saveTree) {
895  m_dbgTree_electrons->Fill();
896  }
897 // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Tree saving
898 
899  // Fill histogram with information about maximum energy crystal energy fraction
900  getObjectPtr<TH1F>("maxEcrsytalEnergyFraction")->Fill(en / trkEClustLab[iCharge]);
901 
902 
903  }
904 
905 
906 
907  // Check both electrons to see if their cluster energy / track momentum is good.
908  // The Belle II physics book shows that this is the main way of separating electrons from other particles
909  // Done in the centre of mass reference frame although I believe E/p is invariant under a boost.
910  bool E_DIV_p_instance_passed[2] = {false, false};
911  double E_DIV_p_CUT = 0.7;
912  for (int icharge = 0; icharge < 2; icharge++) {
913  E_DIV_p_instance_passed[icharge] = E_DIV_p[icharge] > E_DIV_p_CUT;
914  }
915  if (!E_DIV_p_instance_passed[0] || !E_DIV_p_instance_passed[1]) {
916  return;
917  }
918  // E/p sufficiently large
919  cutIndexPassed++;
920  getObjectPtr<TH1F>("cutflow")->Fill(cutIndexPassed);
921  B2DEBUG(22, "Cutflow: E_i/p_i > " << E_DIV_p_CUT << ": index = " << cutIndexPassed);
922 
923 
924 
925  // Start of cuts on both the combined system of tracks and energy clusters
926 
927  double invMassTrk = (trkp4Lab[0] + trkp4Lab[1]).M();
928  double invMass_CUT = 0.9;
929  m_massInvTracks = invMassTrk; // invariant mass of the two tracks
930 
931 // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Tree saving
932  if (m_saveTree) {
933  m_dbgTree_event->Fill();
934  }
935 // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Tree saving
936 
937  bool invMassCutsPassed = invMassTrk > (invMass_CUT * boostrotate.getCMSEnergy());
938  if (!invMassCutsPassed) {
939  return;
940  }
941  // Invariable mass of the two tracks are above the minimum
942  cutIndexPassed++;
943  getObjectPtr<TH1F>("cutflow")->Fill(cutIndexPassed);
944  B2DEBUG(22, "Cutflow: m(track 1+2) > " << invMass_CUT << "*E_COM = " << invMass_CUT << " * " << boostrotate.getCMSEnergy() <<
945  " : index = " << cutIndexPassed);
946 
947 
948 
949  //== Fill output histogram.
950  for (int iCharge = 0; iCharge < 2; iCharge++) {
951  if (crystalCutsPassed[iCharge]) {
952  getObjectPtr<TH2F>("TimevsCrysPrevCrateCalibPrevCrystCalib")->Fill((crystalIDs[iCharge]) + 0.001,
953  times_noPreviousCalibrations[iCharge] - ts_prevCalib[iCharge] - tcrate_prevCalib[iCharge] , 1);
954  getObjectPtr<TH2F>("TimevsCratePrevCrateCalibPrevCrystCalib")->Fill((crateIDs[iCharge]) + 0.001,
955  times_noPreviousCalibrations[iCharge] - ts_prevCalib[iCharge] - tcrate_prevCalib[iCharge], 1);
956  getObjectPtr<TH2F>("TimevsCrysNoCalibrations")->Fill((crystalIDs[iCharge]) + 0.001, times_noPreviousCalibrations[iCharge], 1);
957  getObjectPtr<TH2F>("TimevsCrateNoCalibrations")->Fill((crateIDs[iCharge]) + 0.001, times_noPreviousCalibrations[iCharge], 1);
958  getObjectPtr<TH2F>("TimevsCrysPrevCrateCalibNoCrystCalib")->Fill((crystalIDs[iCharge]) + 0.001,
959  times_noPreviousCalibrations[iCharge] - tcrate_prevCalib[iCharge], 1);
960  getObjectPtr<TH2F>("TimevsCrateNoCrateCalibPrevCrystCalib")->Fill((crateIDs[iCharge]) + 0.001,
961  times_noPreviousCalibrations[iCharge] - ts_prevCalib[iCharge] , 1);
962 
963  // Record number of crystals used from the event. Should be exactly two.
964  numCrystalsPassingCuts++;
965 
966  }
967  }
968 
969 
970  // Change cutflow method for this bit ... don't call return because we used to call the hadron cluster stuff afterwards
971  //
972  if (crystalCutsPassed[0] || crystalCutsPassed[1]) {
973  // At least one ECL crystal time and quality cuts passed
974  cutIndexPassed++;
975  getObjectPtr<TH1F>("cutflow")->Fill(cutIndexPassed);
976  B2DEBUG(22, "Cutflow: At least one crystal time and quality cuts passed: index = " << cutIndexPassed);
977 
978  getObjectPtr<TH1F>("numCrystalEntriesPerEvent")->Fill(numCrystalsPassingCuts);
979  }
980 
981 
982  // Save final information to the tree after all cuts are applied
983  for (int iCharge = 0; iCharge < 2; iCharge++) {
984  if (crystalCutsPassed[iCharge]) {
985  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Tree saving
986  StoreObjPtr<EventMetaData> evtMetaData;
987  m_tree_evtNum = evtMetaData->getEvent();
988  m_tree_cid = crystalIDs[iCharge];
989  //m_tree_time = times[iCharge];
990  m_tree_time = times_noPreviousCalibrations[iCharge];
991  m_crystalCrate = crateIDs[iCharge];
992  m_runNum = evtMetaData->getRun();
993  m_tree_en = crystalEnergies[iCharge]; // for studies of ts as a function of energy
994  m_tree_E1Etot = crystalEnergies[iCharge] / trkEClustLab[iCharge];
995  m_tree_E1E2 = crystalEnergies[iCharge] / crystalEnergies2[iCharge];
996  m_tree_E1p = crystalEnergies[iCharge] / trkpLab[iCharge];
997  m_tree_timetsPreviousTimeCalibs = times_noPreviousCalibrations[iCharge] - ts_prevCalib[iCharge] - tcrate_prevCalib[iCharge];
998  m_tree_t0 = evt_t0;
999  m_tree_t0_ECLclosestCDC = evt_t0_ECL_closestCDC;
1000  m_tree_t0_ECL_minChi2 = evt_t0_ECL_minChi2;
1001  m_tree_tClust = clusterTime[iCharge];
1002 
1003  m_massInvTracks = invMassTrk; // This is probably already set but I'll set it again anyways just so that it is clear
1004 
1005  if (m_saveTree) {
1006  m_dbgTree_allCuts->Fill();
1007  }
1008  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Tree saving
1009  }
1010  }
1011 
1012 
1013 
1014 
1015  if (crystalCutsPassed[0] && crystalCutsPassed[1] &&
1016  numClustersPerTrack[0] == 1 && numClustersPerTrack[1] == 1) {
1017  m_tree_enNeg = trkEClustLab[0];
1018  m_tree_enPlus = trkEClustLab[1];
1019  m_tree_tClustNeg = clusterTime[0];
1020  m_tree_tClustPos = clusterTime[1];
1021  m_tree_maxEcrystPosClust = times_noPreviousCalibrations[0] - ts_prevCalib[0] - tcrate_prevCalib[0];
1022  m_tree_maxEcrystNegClust = times_noPreviousCalibrations[1] - ts_prevCalib[1] - tcrate_prevCalib[1];
1023  m_tree_t0 = evt_t0;
1024  m_tree_t0_ECLclosestCDC = evt_t0_ECL_closestCDC;
1025  m_tree_t0_ECL_minChi2 = evt_t0_ECL_minChi2;
1026 
1027  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Tree saving
1028  if (m_saveTree) {
1029  m_dbgTree_evt_allCuts->Fill();
1030  }
1031  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Tree saving
1032  }
1033 
1034 
1035  B2DEBUG(26, "m_tree_maxEcrystPosClust + evt_t0 = " << m_tree_maxEcrystPosClust + evt_t0);
1036  B2DEBUG(26, "m_tree_maxEcrystNegClust + evt_t0 = " << m_tree_maxEcrystNegClust + evt_t0);
1037  B2DEBUG(26, "CDC evt_t0 = " << evt_t0);
1038  B2DEBUG(26, "ECL min chi2 even t0, m_tree_t0_ECL_minChi2 = " << m_tree_t0_ECL_minChi2);
1039 
1040 
1041 
1042  for (long unsigned int digit_i = 0; digit_i < time_ECLCaldigits_bothClusters.size(); digit_i++) {
1043  StoreObjPtr<EventMetaData> evtMetaData;
1044  m_runNum = evtMetaData->getRun();
1045  m_tree_evtNum = evtMetaData->getEvent();
1046  m_tree_ECLCalDigitTime = time_ECLCaldigits_bothClusters[digit_i];
1047  m_tree_ECLCalDigitE = E_ECLCaldigits_bothClusters[digit_i];
1048  m_tree_ECLDigitAmplitude = amp_ECLDigits_bothClusters[digit_i];
1049  m_tree_t0 = evt_t0;
1050  m_tree_t0_ECLclosestCDC = evt_t0_ECL_closestCDC;
1051  m_tree_t0_ECL_minChi2 = evt_t0_ECL_minChi2;
1052  m_tree_timetsPreviousTimeCalibs = times_noPreviousCalibrations[chargeID_ECLCaldigits_bothClusters[digit_i]] -
1053  ts_prevCalib[chargeID_ECLCaldigits_bothClusters[digit_i]] -
1054  tcrate_prevCalib[chargeID_ECLCaldigits_bothClusters[digit_i]];
1055  m_tree_cid = cid_ECLCaldigits_bothClusters[digit_i];
1056 
1057  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Tree saving
1058  if (m_saveTree) {
1059  m_dbgTree_crys_allCuts->Fill();
1060  }
1061  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Tree saving
1062 
1063  }
1064 
1065 
1066  B2DEBUG(26, "This was for event number = " << m_tree_evtNum);
1067 
1068 }

◆ def_endRun()

virtual void def_endRun ( )
inlineprotectedvirtualinherited

This method can receive that the current run ends as a call from the Python side.

For regular C++-Modules that forwards the call to the regular endRun() method.

Reimplemented in PyModule.

Definition at line 441 of file Module.h.

◆ def_initialize()

virtual void def_initialize ( )
inlineprotectedvirtualinherited

Wrappers to make the methods without "def_" prefix callable from Python.

Overridden in PyModule. Wrapper method for the virtual function initialize() that has the implementation to be used in a call from Python.

Reimplemented in PyModule.

Definition at line 422 of file Module.h.

◆ evalCondition()

bool evalCondition ( ) const
inherited

If at least one condition was set, it is evaluated and true returned if at least one condition returns true.

If no condition or result value was defined, the method returns false. Otherwise, the condition is evaluated and true returned, if at least one condition returns true. To speed up the evaluation, the condition strings were already parsed in the method if_value().

Returns
True if at least one condition and return value exists and at least one condition expression was evaluated to true.

Definition at line 98 of file Module.cc.

◆ getAfterConditionPath()

Module::EAfterConditionPath getAfterConditionPath ( ) const
inherited

What to do after the conditional path is finished.

(defaults to c_End if no condition is set)

Definition at line 135 of file Module.cc.

◆ getConditionPath()

std::shared_ptr< Path > getConditionPath ( ) const
inherited

Returns the path of the last true condition (if there is at least one, else reaturn a null pointer).


Definition at line 115 of file Module.cc.

◆ getFileNames()

virtual std::vector<std::string> getFileNames ( __attribute__((unused)) bool  outputFiles)
inlinevirtualinherited

Return a list of output filenames for this modules.

This will be called when basf2 is run with "--dry-run" if the module has set either the c_Input or c_Output properties.

If the parameter outputFiles is false (for modules with c_Input) the list of input filenames should be returned (if any). If outputFiles is true (for modules with c_Output) the list of output files should be returned (if any).

If a module has sat both properties this member is called twice, once for each property.

The module should return the actual list of requested input or produced output filenames (including handling of input/output overrides) so that the grid system can handle input/output files correctly.

This function should return the same value when called multiple times. This is especially important when taking the input/output overrides from Environment as they get consumed when obtained so the finalized list of output files should be stored for subsequent calls.

Definition at line 136 of file Module.h.

◆ getName()

const std::string& getName ( ) const
inlineinherited

Returns the name of the module.

This can be changed via e.g. set_name() in the steering file to give more useful names if there is more than one module of the same type.

For identifying the type of a module, using getType() (or type() in Python) is recommended.

Definition at line 189 of file Module.h.

◆ getParamInfoListPython()

std::shared_ptr< boost::python::list > getParamInfoListPython ( ) const
inherited

Returns a python list of all parameters.

Each item in the list consists of the name of the parameter, a string describing its type, a python list of all default values and the description of the parameter.

Returns
A python list containing the parameters of this parameter list.

Definition at line 281 of file Module.cc.

◆ getPreScaleChoice()

bool getPreScaleChoice ( )
inlineprivateinherited

I'm a little worried about floating point precision when comparing to 0.0 and 1.0 as special values.

But since a user will have set them (or left them as default) as exactly equal to 0.0 or 1.0 rather than calculating them in almost every case, I think we can assume that the equalities hold.

Definition at line 134 of file CalibrationCollectorModule.h.

◆ getReturnValue()

int getReturnValue ( ) const
inlineinherited

Return the return value set by this module.

This value is only meaningful if hasReturnValue() is true

Definition at line 383 of file Module.h.

◆ getType()

const std::string & getType ( ) const
inherited

Returns the type of the module (i.e.

class name minus 'Module')

Definition at line 43 of file Module.cc.

◆ hasProperties()

bool hasProperties ( unsigned int  propertyFlags) const
inherited

Returns true if all specified property flags are available in this module.

Parameters
propertyFlagsOred EModulePropFlags which should be compared with the module flags.

Definition at line 162 of file Module.cc.

◆ if_false()

void if_false ( const std::shared_ptr< Path > &  path,
EAfterConditionPath  afterConditionPath = EAfterConditionPath::c_End 
)
inherited

A simplified version to add a condition to the module.

Please note that successive calls of this function will add more than one condition to the module. If more than one condition results in true, only the last of them will be used.

Please be careful: Avoid creating cyclic paths, e.g. by linking a condition to a path which is processed before the path where this module is located in.

It is equivalent to the if_value() method, using the expression "<1". This method is meant to be used together with the setReturnValue(bool value) method.

Parameters
pathShared pointer to the Path which will be executed if the return value is false.
afterConditionPathWhat to do after executing 'path'.

Definition at line 87 of file Module.cc.

◆ if_true()

void if_true ( const std::shared_ptr< Path > &  path,
EAfterConditionPath  afterConditionPath = EAfterConditionPath::c_End 
)
inherited

A simplified version to set the condition of the module.

Please note that successive calls of this function will add more than one condition to the module. If more than one condition results in true, only the last of them will be used.

Please be careful: Avoid creating cyclic paths, e.g. by linking a condition to a path which is processed before the path where this module is located in.

It is equivalent to the if_value() method, using the expression ">=1". This method is meant to be used together with the setReturnValue(bool value) method.

Parameters
pathShared pointer to the Path which will be executed if the return value is true.
afterConditionPathWhat to do after executing 'path'.

Definition at line 92 of file Module.cc.

◆ if_value()

void if_value ( const std::string &  expression,
const std::shared_ptr< Path > &  path,
EAfterConditionPath  afterConditionPath = EAfterConditionPath::c_End 
)
inherited

Add a condition to the module.

Please note that successive calls of this function will add more than one condition to the module. If more than one condition results in true, only the last of them will be used.

See https://confluence.desy.de/display/BI/Software+ModCondTut or ModuleCondition for a description of the syntax.

Please be careful: Avoid creating cyclic paths, e.g. by linking a condition to a path which is processed before the path where this module is located in.

Parameters
expressionThe expression of the condition.
pathShared pointer to the Path which will be executed if the condition is evaluated to true.
afterConditionPathWhat to do after executing 'path'.

Definition at line 81 of file Module.cc.

◆ setDescription()

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

Sets the description of the module.

Parameters
descriptionA description of the module.

Definition at line 216 of file Module.cc.

◆ setLogInfo()

void setLogInfo ( int  logLevel,
unsigned int  logInfo 
)
inherited

Configure the printed log information for the given level.

Parameters
logLevelThe log level (one of LogConfig::ELogLevel)
logInfoWhat kind of info should be printed? ORed combination of LogConfig::ELogInfo flags.

Definition at line 75 of file Module.cc.

◆ setName()

void setName ( const std::string &  name)
inlineinherited

Set the name of the module.

Note
The module name is set when using the REG_MODULE macro, but the module can be renamed before calling process() using the set_name() function in your steering file.
Parameters
nameThe name of the module

Definition at line 216 of file Module.h.

◆ setParamPython()

void setParamPython ( const std::string &  name,
const boost::python::object &  pyObj 
)
privateinherited

Implements a method for setting boost::python objects.

The method supports the following types: list, dict, int, double, string, bool The conversion of the python object to the C++ type and the final storage of the parameter value is done in the ModuleParam class.

Parameters
nameThe unique name of the parameter.
pyObjThe object which should be converted and stored as the parameter value.

Definition at line 236 of file Module.cc.

◆ setParamPythonDict()

void setParamPythonDict ( const boost::python::dict &  dictionary)
privateinherited

Implements a method for reading the parameter values from a boost::python dictionary.

The key of the dictionary has to be the name of the parameter and the value has to be of one of the supported parameter types.

Parameters
dictionaryThe python dictionary from which the parameter values are read.

Definition at line 251 of file Module.cc.

◆ setPropertyFlags()

void setPropertyFlags ( unsigned int  propertyFlags)
inherited

Sets the flags for the module properties.

Parameters
propertyFlagsbitwise OR of EModulePropFlags

Definition at line 210 of file Module.cc.

◆ setReturnValue() [1/2]

void setReturnValue ( bool  value)
protectedinherited

Sets the return value for this module as bool.

The bool value is saved as an integer with the convention 1 meaning true and 0 meaning false. The value can be used in the steering file to divide the analysis chain into several paths.

Parameters
valueThe value of the return value.

Definition at line 229 of file Module.cc.

◆ setReturnValue() [2/2]

void setReturnValue ( int  value)
protectedinherited

Sets the return value for this module as integer.

The value can be used in the steering file to divide the analysis chain into several paths.

Parameters
valueThe value of the return value.

Definition at line 222 of file Module.cc.

◆ setType()

void setType ( const std::string &  type)
protectedinherited

Set the module type.

Only for use by internal modules (which don't use the normal REG_MODULE mechanism).

Definition at line 50 of file Module.cc.

Member Data Documentation

◆ m_CrateTimeDB

DBObjPtr<ECLCrystalCalib> m_CrateTimeDB
private

Time offset from crate time calibration (also this calibration) from database.

database object

Definition at line 106 of file ECLBhabhaTCollectorModule.h.

◆ m_dbgTree_electrons

TTree* m_dbgTree_electrons = nullptr
private

Output tree with detailed event data.

Debug TTree output per electron

Definition at line 117 of file ECLBhabhaTCollectorModule.h.

◆ m_ECLTimeUtil

std::unique_ptr< Belle2::ECL::ECLTimingUtilities > m_ECLTimeUtil
private
Initial value:
=
std::make_unique<Belle2::ECL::ECLTimingUtilities>()

ECL timing tools.

Definition at line 220 of file ECLBhabhaTCollectorModule.h.

◆ m_ElectronicsDB

DBObjPtr<ECLCrystalCalib> m_ElectronicsDB
private

electronics amplitude calibration from database Scale amplitudefor each crystal and for dead pre-amps

database object

Definition at line 89 of file ECLBhabhaTCollectorModule.h.

◆ m_ElectronicsTimeDB

DBObjPtr<ECLCrystalCalib> m_ElectronicsTimeDB
private

Time offset from electronics calibration from database.

database object

Definition at line 93 of file ECLBhabhaTCollectorModule.h.

◆ m_eventT0

StoreObjPtr<EventT0> m_eventT0
private

StoreObjPtr for T0.

The event t0 class has an overall event t0

Definition at line 82 of file ECLBhabhaTCollectorModule.h.

◆ m_FlightTimeDB

DBObjPtr<ECLCrystalCalib> m_FlightTimeDB
private

Time offset from flight time b/w IP and crystal from database.

database object

Definition at line 97 of file ECLBhabhaTCollectorModule.h.

◆ m_PreviousCrystalTimeDB

DBObjPtr<ECLCrystalCalib> m_PreviousCrystalTimeDB
private

Time offset from previous crystal time calibration (this calibration) from database.

database object

Definition at line 101 of file ECLBhabhaTCollectorModule.h.

◆ m_RefCrystalsCalibDB

DBObjPtr<ECLReferenceCrystalPerCrateCalib> m_RefCrystalsCalibDB
private

Crystal IDs of the one reference crystal per crate from database.

database object

Definition at line 111 of file ECLBhabhaTCollectorModule.h.


The documentation for this class was generated from the following files:
Belle2::ECLBhabhaTCollectorModule::m_timeAbsMax
short m_timeAbsMax
Events with abs(time) > m_timeAbsMax are excluded, mostly for histogram x-range purposes.
Definition: ECLBhabhaTCollectorModule.h:200
Belle2::EvtPDLUtil::charge
double charge(int pdgCode)
Returns electric charge of a particle with given pdg code.
Definition: EvtPDLUtil.cc:46
Belle2::ECLCalDigit::getEnergy
double getEnergy() const
Get Calibrated Energy.
Definition: ECLCalDigit.h:134
Belle2::ECLBhabhaTCollectorModule::m_eventT0
StoreObjPtr< EventT0 > m_eventT0
StoreObjPtr for T0.
Definition: ECLBhabhaTCollectorModule.h:82
Belle2::ECLBhabhaTCollectorModule::m_EventMetaData
StoreObjPtr< EventMetaData > m_EventMetaData
Event metadata.
Definition: ECLBhabhaTCollectorModule.h:85
Belle2::ECLBhabhaTCollectorModule::m_looseTrkD0
double m_looseTrkD0
Loose track d0 minimum cut.
Definition: ECLBhabhaTCollectorModule.h:208
Belle2::ECLBhabhaTCollectorModule::m_tightTrkD0
double m_tightTrkD0
Tight track d0 minimum cut.
Definition: ECLBhabhaTCollectorModule.h:209
Belle2::ECLBhabhaTCollectorModule::m_tree_amp
int m_tree_amp
Fitting amplitude from ECL for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:131
Belle2::ECLCalDigit
Class to store calibrated ECLDigits: ECLCalDigits.
Definition: ECLCalDigit.h:38
Belle2::ECLBhabhaTCollectorModule::m_tree_ECLCalDigitTime
double m_tree_ECLCalDigitTime
Time of an ECLCalDigit within a cluster, ns for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:174
Belle2::ECLDigit::getQuality
int getQuality() const
Get Fitting Quality.
Definition: ECLDigit.h:90
Belle2::ECLBhabhaTCollectorModule::m_tree_E1p
double m_tree_E1p
Energy of crystal with maximum energy within ECL cluster divided by total cluster energy divided by t...
Definition: ECLBhabhaTCollectorModule.h:139
Belle2::ECLBhabhaTCollectorModule::m_runNum
int m_runNum
run number
Definition: ECLBhabhaTCollectorModule.h:212
Belle2::ECLBhabhaTCollectorModule::m_dbgTree_tracks
TTree * m_dbgTree_tracks
Debug TTree output per track.
Definition: ECLBhabhaTCollectorModule.h:118
Belle2::ECLBhabhaTCollectorModule::m_tree_maxEcrystPosClust
double m_tree_maxEcrystPosClust
Time of the highest energy crystal in the cluster associated to positively charged track,...
Definition: ECLBhabhaTCollectorModule.h:167
Belle2::ECLBhabhaTCollectorModule::m_maxCrystal
int m_maxCrystal
Last CellId to handle.
Definition: ECLBhabhaTCollectorModule.h:203
Belle2::ECLCluster
ECL cluster data.
Definition: ECLCluster.h:39
Belle2::ECLCalDigit::getCellId
int getCellId() const
Get Cell ID.
Definition: ECLCalDigit.h:129
Belle2::ECLBhabhaTCollectorModule::m_tree_maxEcrystNegClust
double m_tree_maxEcrystNegClust
Time of the highest energy crystal in the cluster associated to negatively charged track,...
Definition: ECLBhabhaTCollectorModule.h:169
Belle2::ECLBhabhaTCollectorModule::m_tree_z0
double m_tree_z0
Track z0 for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:153
Belle2::ECLBhabhaTCollectorModule::m_CrateTimeUnc
std::vector< float > m_CrateTimeUnc
uncertainty vector obtained from DB object
Definition: ECLBhabhaTCollectorModule.h:108
Belle2::PCmsLabTransform::getCMSEnergy
double getCMSEnergy() const
Returns CMS energy of e+e- (aka.
Definition: PCmsLabTransform.h:57
Belle2::ECLBhabhaTCollectorModule::m_tree_E1E2
double m_tree_E1E2
Energy of crystal with maximum energy within ECL cluster divided by second most energetic crystal in ...
Definition: ECLBhabhaTCollectorModule.h:136
Belle2::ECLBhabhaTCollectorModule::m_massInvTracks
double m_massInvTracks
invariant mass of the two tracks, for debug TTree output
Definition: ECLBhabhaTCollectorModule.h:182
Belle2::ECLBhabhaTCollectorModule::m_tree_quality
int m_tree_quality
ECL fit quality for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:142
Belle2::ECLCluster::EHypothesisBit::c_nPhotons
@ c_nPhotons
CR is split into n photons (N1)
Belle2::ECLBhabhaTCollectorModule::m_tree_tClustPos
double m_tree_tClustPos
Cluster time of cluster associated to positively charged track, ns for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:165
Belle2::ECLBhabhaTCollectorModule::m_RefCrystalsCalib
std::vector< short > m_RefCrystalsCalib
vector obtained from DB object
Definition: ECLBhabhaTCollectorModule.h:112
Belle2::ECLBhabhaTCollectorModule::m_PreviousCrystalTimeDB
DBObjPtr< ECLCrystalCalib > m_PreviousCrystalTimeDB
Time offset from previous crystal time calibration (this calibration) from database.
Definition: ECLBhabhaTCollectorModule.h:101
Belle2::ECLBhabhaTCollectorModule::m_FlightTimeDB
DBObjPtr< ECLCrystalCalib > m_FlightTimeDB
Time offset from flight time b/w IP and crystal from database.
Definition: ECLBhabhaTCollectorModule.h:97
Belle2::ECLBhabhaTCollectorModule::m_RefCrystalsCalibDB
DBObjPtr< ECLReferenceCrystalPerCrateCalib > m_RefCrystalsCalibDB
Crystal IDs of the one reference crystal per crate from database.
Definition: ECLBhabhaTCollectorModule.h:111
Belle2::ECLBhabhaTCollectorModule::m_ElectronicsDB
DBObjPtr< ECLCrystalCalib > m_ElectronicsDB
electronics amplitude calibration from database Scale amplitudefor each crystal and for dead pre-amps
Definition: ECLBhabhaTCollectorModule.h:89
Belle2::ECLBhabhaTCollectorModule::m_eclDigitID
std::vector< int > m_eclDigitID
ECL digit id sorter.
Definition: ECLBhabhaTCollectorModule.h:194
Belle2::TrackFitResult
Values of the result of a track fit with a given particle hypothesis.
Definition: TrackFitResult.h:59
Belle2::ECLBhabhaTCollectorModule::m_eclCalDigitID
std::vector< int > m_eclCalDigitID
ECL cal digit id sorter.
Definition: ECLBhabhaTCollectorModule.h:193
Belle2::ECLBhabhaTCollectorModule::m_ElectronicsTimeDB
DBObjPtr< ECLCrystalCalib > m_ElectronicsTimeDB
Time offset from electronics calibration from database.
Definition: ECLBhabhaTCollectorModule.h:93
Belle2::ClusterUtils::GetIPPosition
const TVector3 GetIPPosition()
Returns default IP position from beam parameters.
Definition: ClusterUtils.cc:182
Belle2::ECLBhabhaTCollectorModule::m_storeCalib
bool m_storeCalib
Boolean for whether or not to store the previous calibration calibration constants.
Definition: ECLBhabhaTCollectorModule.h:214
Belle2::ECLBhabhaTCollectorModule::m_tree_time
double m_tree_time
Time for Ts distribution for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:144
Belle2::ECLBhabhaTCollectorModule::m_tree_timetsPreviousTimeCalibs
double m_tree_timetsPreviousTimeCalibs
Time for Ts distribution after application of previous time calibrations for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:145
Belle2::ECLBhabhaTCollectorModule::m_tree_nCDChits
double m_tree_nCDChits
Number of CDC hits along the track for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:155
Belle2::ECLBhabhaTCollectorModule::m_tree_tClust
double m_tree_tClust
Cluster time of a cluster, ns for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:172
Belle2::Const::pion
static const ChargedStable pion
charged pion particle
Definition: Const.h:535
Belle2::ECLBhabhaTCollectorModule::m_hadronEventT0_TO_bhabhaEventT0_correction
double m_hadronEventT0_TO_bhabhaEventT0_correction
correction to apply to CDC event t0 values in bhabha events to correct for CDC event t0 bias compared...
Definition: ECLBhabhaTCollectorModule.h:225
Belle2::ECL::ECLChannelMapper
This class provides access to ECL channel map that is either a) Loaded from the database (see ecl/dbo...
Definition: ECLChannelMapper.h:36
Belle2::ECLBhabhaTCollectorModule::tracks
StoreArray< Track > tracks
StoreArray for tracks.
Definition: ECLBhabhaTCollectorModule.h:78
Belle2::ECLBhabhaTCollectorModule::m_charge
int m_charge
particle charge, for debug TTree output
Definition: ECLBhabhaTCollectorModule.h:180
Belle2::ECLBhabhaTCollectorModule::m_tree_ECLCalDigitE
double m_tree_ECLCalDigitE
Energy of an ECLCalDigit within a cluster, GeV for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:175
Belle2::ClusterUtils
Class to provide momentum-related information from ECLClusters.
Definition: ClusterUtils.h:44
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: ParticleList.h:33
Belle2::ECLBhabhaTCollectorModule::m_tree_cid
int m_tree_cid
ECL Cell ID (1..8736) for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:128
Belle2::ECLBhabhaTCollectorModule::m_looseTrkZ0
double m_looseTrkZ0
Loose track z0 minimum cut.
Definition: ECLBhabhaTCollectorModule.h:206
Belle2::ECLBhabhaTCollectorModule::m_E_DIV_p
double m_E_DIV_p
Energy divided by momentum, for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:181
Belle2::ECLBhabhaTCollectorModule::m_CrateTimeDB
DBObjPtr< ECLCrystalCalib > m_CrateTimeDB
Time offset from crate time calibration (also this calibration) from database.
Definition: ECLBhabhaTCollectorModule.h:106
Belle2::ECLDigit::getCellId
int getCellId() const
Get Cell ID.
Definition: ECLDigit.h:74
Belle2::ECLBhabhaTCollectorModule::m_eclCalDigitArray
StoreArray< ECLCalDigit > m_eclCalDigitArray
Required input array of ECLCalDigits.
Definition: ECLBhabhaTCollectorModule.h:189
Belle2::ECLBhabhaTCollectorModule::m_tree_E1Etot
double m_tree_E1Etot
Energy of crystal with maximum energy within ECL cluster divided by total cluster energy,...
Definition: ECLBhabhaTCollectorModule.h:133
Belle2::ECLBhabhaTCollectorModule::m_tree_p
double m_tree_p
Track momentum for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:154
LogVar
Class to store variables with their name which were sent to the logging service.
Definition: LogVariableStream.h:24
Belle2::ECLBhabhaTCollectorModule::m_Electronics
std::vector< float > m_Electronics
vector obtained from DB object
Definition: ECLBhabhaTCollectorModule.h:90
Belle2::ECLBhabhaTCollectorModule::m_dbgTree_electrons
TTree * m_dbgTree_electrons
Output tree with detailed event data.
Definition: ECLBhabhaTCollectorModule.h:117
Belle2::ECLBhabhaTCollectorModule::m_tree_t0_ECLclosestCDC
double m_tree_t0_ECLclosestCDC
EventT0 (from ECL) closest to CDC for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:150
Belle2::ECLBhabhaTCollectorModule::m_dbgTree_crys_allCuts
TTree * m_dbgTree_crys_allCuts
Debug TTree output per crystal after all cuts.
Definition: ECLBhabhaTCollectorModule.h:123
Belle2::ECL::EclConfiguration::m_rf
static constexpr double m_rf
accelerating RF, http://ptep.oxfordjournals.org/content/2013/3/03A006.full.pdf
Definition: EclConfiguration.h:45
Belle2::ECLBhabhaTCollectorModule::m_PreviousCrystalTimeUnc
std::vector< float > m_PreviousCrystalTimeUnc
vector obtained from DB object
Definition: ECLBhabhaTCollectorModule.h:103
Belle2::ECLDigit
Class to store ECL digitized hits (output of ECLDigi) relation to ECLHit filled in ecl/modules/eclDig...
Definition: ECLDigit.h:34
Belle2::ECLBhabhaTCollectorModule::m_tree_enPlus
double m_tree_enPlus
Energy of cluster associated to positively charged track, GeV for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:163
Belle2::ECLBhabhaTCollectorModule::m_dbgTree_allCuts
TTree * m_dbgTree_allCuts
Debug TTree output after all cuts.
Definition: ECLBhabhaTCollectorModule.h:121
Belle2::ECLBhabhaTCollectorModule::m_FlightTime
std::vector< float > m_FlightTime
vector obtained from DB object
Definition: ECLBhabhaTCollectorModule.h:98
Belle2::ECLDigit::getTimeFit
int getTimeFit() const
Get Fitting Time.
Definition: ECLDigit.h:85
Belle2::ECLBhabhaTCollectorModule::m_PreviousCrystalTime
std::vector< float > m_PreviousCrystalTime
vector obtained from DB object
Definition: ECLBhabhaTCollectorModule.h:102
Belle2::ECLBhabhaTCollectorModule::m_tree_tClustNeg
double m_tree_tClustNeg
Cluster time of cluster associated to negatively charged track, ns for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:166
Belle2::PCmsLabTransform
Class to hold Lorentz transformations from/to CMS and boost vector.
Definition: PCmsLabTransform.h:37
Belle2::ECLBhabhaTCollectorModule::m_tree_t0
double m_tree_t0
EventT0 (not from ECL) for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:148
Belle2::PCmsLabTransform::rotateLabToCms
const TLorentzRotation rotateLabToCms() const
Returns Lorentz transformation from Lab to CMS.
Definition: PCmsLabTransform.h:74
Belle2::ECLBhabhaTCollectorModule::m_saveTree
bool m_saveTree
If true, save TTree with more detailed event info.
Definition: ECLBhabhaTCollectorModule.h:73
Belle2::ECLBhabhaTCollectorModule::m_tree_timeF
double m_tree_timeF
ECL fitting time for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:143
Belle2::ECLDigit::getAmp
int getAmp() const
Get Fitting Amplitude.
Definition: ECLDigit.h:80
Belle2::ECLBhabhaTCollectorModule::m_tree_ECLDigitAmplitude
double m_tree_ECLDigitAmplitude
Amplitude (used to calculate energy) of an ECLDigit within a cluster, for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:176
Belle2::ECLBhabhaTCollectorModule::m_CrateTime
std::vector< float > m_CrateTime
vector obtained from DB object
Definition: ECLBhabhaTCollectorModule.h:107
Belle2::ECLBhabhaTCollectorModule::m_tree_evtNum
int m_tree_evtNum
Event number for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:127
Belle2::ECLBhabhaTCollectorModule::m_tree_t0_unc
double m_tree_t0_unc
EventT0 uncertainty for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:149
Belle2::ECLBhabhaTCollectorModule::m_dbgTree_event
TTree * m_dbgTree_event
Debug TTree output per event.
Definition: ECLBhabhaTCollectorModule.h:120
Belle2::ECLBhabhaTCollectorModule::m_dbgTree_evt_allCuts
TTree * m_dbgTree_evt_allCuts
Debug TTree output per event after all cuts.
Definition: ECLBhabhaTCollectorModule.h:122
Belle2::ECLBhabhaTCollectorModule::m_crystalCrate
int m_crystalCrate
Crate id for the crystal.
Definition: ECLBhabhaTCollectorModule.h:211
Belle2::ECLBhabhaTCollectorModule::m_tree_enNeg
double m_tree_enNeg
Energy of cluster associated to negatively charged track, GeV for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:164
Belle2::ECLBhabhaTCollectorModule::m_ElectronicsTime
std::vector< float > m_ElectronicsTime
vector obtained from DB object
Definition: ECLBhabhaTCollectorModule.h:94
Belle2::ECLBhabhaTCollectorModule::m_tree_d0
double m_tree_d0
Track d0 for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:152
Belle2::ECLBhabhaTCollectorModule::m_ECLTimeUtil
std::unique_ptr< Belle2::ECL::ECLTimingUtilities > m_ECLTimeUtil
ECL timing tools.
Definition: ECLBhabhaTCollectorModule.h:220
Belle2::ECLBhabhaTCollectorModule::m_tightTrkZ0
double m_tightTrkZ0
Tight track z0 minimum cut.
Definition: ECLBhabhaTCollectorModule.h:207
Belle2::ECLBhabhaTCollectorModule::m_tree_t0_ECL_minChi2
double m_tree_t0_ECL_minChi2
EventT0 (from ECL) min chi2 for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:151
Belle2::ECLBhabhaTCollectorModule::m_tree_en
double m_tree_en
Energy of crystal with maximum energy within ECL cluster, GeV for debug TTree output.
Definition: ECLBhabhaTCollectorModule.h:132
Belle2::ECLBhabhaTCollectorModule::m_eclDigitArray
StoreArray< ECLDigit > m_eclDigitArray
Required input array of ECLDigits.
Definition: ECLBhabhaTCollectorModule.h:188
Belle2::ECLBhabhaTCollectorModule::m_EperCrys
std::vector< float > m_EperCrys
ECL cal digit energy for each crystal.
Definition: ECLBhabhaTCollectorModule.h:192