GlobalCalibrationManager Class Reference

Class to hold hierarchy of whole Belle2. More...

#include <Manager.h>

Public Member Functions
	~GlobalCalibrationManager ()
	Destructor.
void	sortUniqueVector (std::vector< EventMetaData > &vec)
	Sort vector of EventMetaData and make it unique to process user defined time splittings of the constants.
void	initialize (const std::vector< std::string > &components={}, const std::vector< EventMetaData > &timeSlices={})
	Initialize the manager with given configuration (from MillepedeCollector)
void	preCollect (const EventMetaData &emd)
	Notice manager of a coming event (from MillepedeCollector)
RigidBodyHierarchy &	getAlignmentHierarchy () const
	Get the rigid body alignment hierarchy.
LorentShiftHierarchy &	getLorentzShiftHierarchy () const
	Get the Lorentz shift hierarchy.
Constraints &	getConstraints ()
	Get the constraints collected so far.
void	writeConstraints (std::string txtFilename)
	Write-out complete hierarchy to a text file.

Static Public Member Functions
static GlobalCalibrationManager &	getInstance ()
	Get instance of the Manager auto& gcm = GlobalCalibrationManager::getInstance();.
static void	initGlobalVector (GlobalParamVector &vector)
	Initialize a given GlobalParamVector with all DB objects and interfaces.

Public Attributes
std::function< bool(const EventMetaData &, const EventMetaData &)>	cmpEventMetaData
	Comparison function for EventMetaData.

Private Member Functions
	GlobalCalibrationManager ()
	Singleton class, hidden constructor.
	GlobalCalibrationManager (const GlobalCalibrationManager &)
	Singleton class, hidden copy constructor.
GlobalCalibrationManager &	operator= (const GlobalCalibrationManager &)
	Singleton class, hidden assignment operator.
int	updateTimeDepGlobalLabels (const EventMetaData &event)
	Update the current time ID in the GlobalLabel.

Private Attributes
bool	m_initialized {false}
	Finished initialization?
std::unique_ptr< RigidBodyHierarchy >	m_alignment {new RigidBodyHierarchy()}
	The alignment hierarchy.
std::unique_ptr< LorentShiftHierarchy >	m_lorentzShift {new LorentShiftHierarchy()}
	Hierarchy for Lorentz shift corrections.
std::unique_ptr< GlobalParamVector >	m_globalVector {new GlobalParamVector()}
	The global vector for unified access to DB constants.
std::map< long, Constraint >	m_constraints {}
	Map of constraints {unique label, labels and coefficients}.
std::vector< EventMetaData >	m_dbTimeSlicing {}
	Vector of EventMetaData containing the time slicing of the calibration job.
alignment::timeline::TimeTable	m_iniTimeTable {}
	The initial time table generated from time intervals in GlobalLabel used to check if payload (labels) can change and update the hierarchy if so.

Detailed Description

Class to hold hierarchy of whole Belle2.

Definition at line 50 of file Manager.h.

Constructor & Destructor Documentation

~GlobalCalibrationManager()

~GlobalCalibrationManager ( )

inline

Destructor.

Definition at line 70 of file Manager.h.

{}

GlobalCalibrationManager()

GlobalCalibrationManager ( )

inlineprivate

Singleton class, hidden constructor.

Definition at line 117 of file Manager.h.

{};

Member Function Documentation

getAlignmentHierarchy()

RigidBodyHierarchy & getAlignmentHierarchy ( ) const

inline

Get the rigid body alignment hierarchy.

---

Definition at line 106 of file Manager.h.

{ return *m_alignment; }

getConstraints()

Constraints & getConstraints ( )

inline

Get the constraints collected so far.

Definition at line 110 of file Manager.h.

{ return m_constraints; }

getInstance()

GlobalCalibrationManager & getInstance ( )

static

Get instance of the Manager auto& gcm = GlobalCalibrationManager::getInstance();.

Note you actually initialize the Manager with your specific selection of DB objects to calibrate (or select all for global calibration -default) and other options.

Definition at line 27 of file Manager.cc.

    {
      static std::unique_ptr<GlobalCalibrationManager> instance(new GlobalCalibrationManager());
      return *instance;
    }

getLorentzShiftHierarchy()

LorentShiftHierarchy & getLorentzShiftHierarchy ( ) const

inline

Get the Lorentz shift hierarchy.

Definition at line 108 of file Manager.h.

{ return *m_lorentzShift; }

initGlobalVector()

void initGlobalVector ( GlobalParamVector & vector )

static

Initialize a given GlobalParamVector with all DB objects and interfaces.

  auto gpv = GlobalParamVector({"BeamSpot"});
  GlobalCalibrationManager::initGlobalVector(gpv);

This one central function should be used to prepare the global vectors even for local calibrations using Millepede. By setting the components argument of GlobalParamVector one can limit which addDBObj<>() calls are actually executed

Definition at line 33 of file Manager.cc.

    {
      // Interfaces for sub-detectors
      auto cdcInterface = std::shared_ptr<IGlobalParamInterface>(new CDCGlobalParamInterface());
      auto vxdInterface = std::shared_ptr<IGlobalParamInterface>(new VXDGlobalParamInterface());
 
      // Try add all supported DB objects
      // - will be not added if not in selected components of the 'vector'
      vector.addDBObj<BeamSpot>();
      vector.addDBObj<VXDAlignment>(vxdInterface);
      vector.addDBObj<CDCAlignment>(cdcInterface);
      vector.addDBObj<CDCTimeZeros>(cdcInterface);
      vector.addDBObj<CDCTimeWalks>(cdcInterface);
      vector.addDBObj<CDCXtRelations>(cdcInterface);
      vector.addDBObj<BKLMAlignment>();
      vector.addDBObj<EKLMAlignment>();
      vector.addDBObj<EKLMSegmentAlignment>();
    }

initialize()

void initialize	(	const std::vector< std::string > &	components = {},
		const std::vector< EventMetaData > &	timeSlices = {} )

Initialize the manager with given configuration (from MillepedeCollector)

---

To be used by MillepedeCollector

Definition at line 52 of file Manager.cc.

    {
      // Reset the config of global vector to restrict components if needed
      m_globalVector.reset(new GlobalParamVector(components));
      // Fill with DB objects and interfaces according to components
      initGlobalVector(*m_globalVector);
      // Set the components for global label system
      GlobalLabel::setComponents(m_globalVector->getComponentsIDs());
 
      // Reset time intervals and add pre-defined times where
      // constants can change (in addition of what is already in DB)
      m_dbTimeSlicing = timeSlices;
      sortUniqueVector(m_dbTimeSlicing);
 
      GlobalLabel label;
      m_iniTimeTable = alignment::timeline::makeInitialTimeTable(m_dbTimeSlicing, label);
 
      StoreObjPtr<EventMetaData> emd;
      if (emd.isValid()) updateTimeDepGlobalLabels(*emd);
 
      // already during initialization (due to geometry) we know the first event
      // to be processed, so we can actually load the consts here - and construct the vector
      //
      // m_globalVector->loadFromDB();
      // m_globalVector->listGlobalParams().size();
 
      // event data loaded
      // gearbox loaded
      // geometry loaded
      // extrapolation setup
 
      // Try to build hierarchy now by interfaces
      //TODO by restricting components you stop to observe some hierarchy changes!
      m_globalVector->postHierarchyChanged(getAlignmentHierarchy());
      m_globalVector->postHierarchyChanged(getLorentzShiftHierarchy());
      getAlignmentHierarchy().buildConstraints(m_constraints);
      getLorentzShiftHierarchy().buildConstraints(m_constraints);
 
      // Try to init as much as possible before event processing
      // geometry, reconstruction config -> recohits & derivatives
 
      m_initialized = true;
 
    }

preCollect()

void preCollect

(

const EventMetaData &

emd

)

Notice manager of a coming event (from MillepedeCollector)

Definition at line 98 of file Manager.cc.

    {
      // TODO Really?? Move elsewhere
      // Add time slices when objects change automatically
      /*
      if (m_globalVector->hasBeenChangedInDB({}, false)) {
        // Add time slices
        m_dbTimeSlicing.push_back(EventMetaData(emd));
        sortUniqueVector(m_dbTimeSlicing);
 
        for (auto& handler : m_globalVector->getGlobalParamSets()) {
          if (not handler.second->hasBeenChangedInDB(false))
            continue;
          //TODO listGlobalParams not fully implemented by DB objects
          for (auto& params : handler.second->listGlobalParams()) {
            GlobalLabel label;
            label.construct(handler.second->getGlobalUniqueID(), params.first, params.second);
            label.registerTimeDependent(GlobalLabel::getCurrentTimeInterval());
          }
        }
      }
      */
 
      // Generate time id from current EventMetaData
      // range for time dependent calibration consts
      auto subrun = updateTimeDepGlobalLabels(emd);
 
      // WARNING: TODO: This is actually a bug, but as we loop exactly over all timeline events
      // to generate constraints in practice (separately from collection), it does not reveal itself
      // usually (needs to have more runs in one job + also timdep cal. has be in effect)
      // -> can't think of easy fix now -> rebuild constraints
      // after each subrun change?
      bool alignmentHierarchyChanged = false;
      bool lorentzHierarchyChanged = false;
      for (auto& uid : getAlignmentHierarchy().getUsedDBObjUniqueIDs()) {
        if (alignment::timeline::getContinuousIndexByTimeID(m_iniTimeTable, uid, subrun) == 1) {
          alignmentHierarchyChanged = true;
          break;
        }
      }
      for (auto& uid : getLorentzShiftHierarchy().getUsedDBObjUniqueIDs()) {
        if (alignment::timeline::getContinuousIndexByTimeID(m_iniTimeTable, uid, subrun) == 1) {
          lorentzHierarchyChanged = true;
          break;
        }
      }
 
      //TODO: this is now probably redundant. If time-dependence is not set, constraints coefficients will
      // be just overridden...
      if (m_globalVector->hasBeenChangedInDB(getAlignmentHierarchy().getUsedDBObjUniqueIDs(), false)) {
        lorentzHierarchyChanged = true;
      }
      if (m_globalVector->hasBeenChangedInDB(getLorentzShiftHierarchy().getUsedDBObjUniqueIDs(), false)) {
        lorentzHierarchyChanged = true;
      }
 
      // Update hierarchy and constraints if DB objects changed
      if (alignmentHierarchyChanged) {
        m_globalVector->postHierarchyChanged(getAlignmentHierarchy());
        getAlignmentHierarchy().buildConstraints(m_constraints);
      }
      if (lorentzHierarchyChanged) {
        m_globalVector->postHierarchyChanged(getLorentzShiftHierarchy());
        getLorentzShiftHierarchy().buildConstraints(m_constraints);
      }
 
      // reset the hasBeenChanged state, ignore return value
      // TODO move to postCollect()?
      m_globalVector->hasBeenChangedInDB();
    }

sortUniqueVector()

void sortUniqueVector

(

std::vector< EventMetaData > &

vec

)

Sort vector of EventMetaData and make it unique to process user defined time splittings of the constants.

Definition at line 190 of file Manager.cc.

    {
      std::sort(vec.begin(), vec.end(), cmpEventMetaData);
      vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
    }

updateTimeDepGlobalLabels()

int updateTimeDepGlobalLabels ( const EventMetaData & event )

private

Update the current time ID in the GlobalLabel.

Parameters

event

current event EventMetaData - generated time ID will be the index of the smallest slice larger than (or. equal) to EventMetaData

Definition at line 196 of file Manager.cc.

    {
      //sortUniqueVector(m_dbTimeSlicing);
 
      if (m_dbTimeSlicing.empty()) {
        GlobalLabel::setCurrentTimeInterval(0);
        return 0;
      }
 
      for (unsigned int index = 0; index < m_dbTimeSlicing.size() - 1; ++index) {
        if (event == m_dbTimeSlicing[index + 1]) {
          GlobalLabel::setCurrentTimeInterval(index + 1);
          return index + 1;
        }
        if (cmpEventMetaData(event, m_dbTimeSlicing[index + 1])) {
          GlobalLabel::setCurrentTimeInterval(index);
          return index;
        }
      }
 
      GlobalLabel::setCurrentTimeInterval(m_dbTimeSlicing.size() - 1);
      return m_dbTimeSlicing.size() - 1;
    }

writeConstraints()

void writeConstraints

(

std::string

txtFilename

)

Write-out complete hierarchy to a text file.

Definition at line 169 of file Manager.cc.

    {
      std::ofstream txt(txtFilename);
      // Last update before write-out
      m_alignment->buildConstraints(m_constraints);
      m_lorentzShift->buildConstraints(m_constraints);
      for (auto& name_elements : m_constraints) {
        auto name = name_elements.first;
        if (!name) continue;
 
        txt << "Constraint 0. ! Constraint for global label: " << name << std::endl;
        auto& elements = name_elements.second;
        for (auto& label_coefficient : elements) {
          auto label = label_coefficient.first;
          auto coeff = label_coefficient.second;
          txt << label << " " << coeff << std::endl;
        }
        txt << std::endl << std::endl;
      }
    }

Member Data Documentation

cmpEventMetaData

std::function<bool(const EventMetaData&, const EventMetaData&)> cmpEventMetaData

Initial value:

= [](const EventMetaData& lhs,
      const EventMetaData& rhs) -> bool {
        if (lhs.getExperiment() < rhs.getExperiment()) return true;
        if (lhs.getExperiment() > rhs.getExperiment()) return false;
 
        if (lhs.getRun() < rhs.getRun()) return true;
        if (lhs.getRun() > rhs.getRun()) return false;
 
        if (lhs.getEvent() < rhs.getEvent()) return true;
        return false;
      }

Comparison function for EventMetaData.

Definition at line 57 of file Manager.h.

                                        {
        if (lhs.getExperiment() < rhs.getExperiment()) return true;
        if (lhs.getExperiment() > rhs.getExperiment()) return false;
 
        if (lhs.getRun() < rhs.getRun()) return true;
        if (lhs.getRun() > rhs.getRun()) return false;
 
        if (lhs.getEvent() < rhs.getEvent()) return true;
        return false;
      };

m_alignment

std::unique_ptr<RigidBodyHierarchy> m_alignment {new RigidBodyHierarchy()}

private

The alignment hierarchy.

Definition at line 133 of file Manager.h.

{new RigidBodyHierarchy()};

m_constraints

std::map<long, Constraint> m_constraints {}

private

Map of constraints {unique label, labels and coefficients}.

Definition at line 139 of file Manager.h.

{};

m_dbTimeSlicing

std::vector<EventMetaData> m_dbTimeSlicing {}

private

Vector of EventMetaData containing the time slicing of the calibration job.

Definition at line 142 of file Manager.h.

{};

m_globalVector

std::unique_ptr<GlobalParamVector> m_globalVector {new GlobalParamVector()}

private

The global vector for unified access to DB constants.

Definition at line 137 of file Manager.h.

{new GlobalParamVector()};

m_initialized

bool m_initialized {false}

private

Finished initialization?

Definition at line 130 of file Manager.h.

{false};

m_iniTimeTable

alignment::timeline::TimeTable m_iniTimeTable {}

private

The initial time table generated from time intervals in GlobalLabel used to check if payload (labels) can change and update the hierarchy if so.

Definition at line 146 of file Manager.h.

{};

m_lorentzShift

std::unique_ptr<LorentShiftHierarchy> m_lorentzShift {new LorentShiftHierarchy()}

private

Hierarchy for Lorentz shift corrections.

Definition at line 135 of file Manager.h.

{new LorentShiftHierarchy()};

---

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

• alignment/include/Manager.h
• alignment/src/Manager.cc