Convenient class to automatically create payloads from allowed time depedence of parameter, load their value from database, update te constants one by one usually from Millepde result) and output the final payloads (including EventDependencies) such that one can store them (updated) in the database. More...

#include <GlobalTimeLine.h>

Public Member Functions
	GlobalParamTimeLine (const std::vector< EventMetaData > &events, GlobalLabel &label, const GlobalParamVector &vector)
	Constructor.

void	loadFromDB ()
	Load every single payload with the content in database at its corresponding event (when it should start to be valid) WARNING: This is potentionally a very expensive operation with lots of HTTP communication TODO: make the loading from DB slightly more optimized -> needs change in GlobalParamSet<...>

void	updateGlobalParam (GlobalLabel label, double correction, bool resetParam=false)
	Add a correction to any payload's parameter in the timeline.

std::vector< std::pair< IntervalOfValidity, TObject * > >	releaseObjects ()
	Release all the objects (you become the owner!) for DB storage.

Private Attributes
TimeTable	timeTable {}
	The final TimeTable with payload indices.

PayloadsTable	payloadsTable {}
	Table with payloads.

Detailed Description

Convenient class to automatically create payloads from allowed time depedence of parameter, load their value from database, update te constants one by one usually from Millepde result) and output the final payloads (including EventDependencies) such that one can store them (updated) in the database.

Definition at line 146 of file GlobalTimeLine.h.

Constructor & Destructor Documentation

◆ GlobalParamTimeLine()

GlobalParamTimeLine	(	const std::vector< EventMetaData > &	events,
		GlobalLabel &	label,
		const GlobalParamVector &	vector
	)

Constructor.

Parameters

events	vector of events to interpret time ids from GlobalLabel
label	(only for style) - static functions called to read the mapping of parameters and time intervals
vector	the global vector initialized with DB objects for which payloads shoudl be generated WARNING: do not construct() or loadFromDB() the vector - use it "raw" - the internal object handlers are copied into the payloads table constructing the internal DB objects would result in copiyng them around, too

Definition at line 220 of file GlobalTimeLine.cc.

                                                                                : timeTable(makeInitialTimeTable(events, label))
      {
        finalizeTimeTable(timeTable);
        payloadsTable = TimeIdsTable2PayloadsTable(timeTable, vector);
 
      }

Member Function Documentation

◆ loadFromDB()

void loadFromDB ( )

Load every single payload with the content in database at its corresponding event (when it should start to be valid) WARNING: This is potentionally a very expensive operation with lots of HTTP communication TODO: make the loading from DB slightly more optimized -> needs change in GlobalParamSet<...>

Definition at line 228 of file GlobalTimeLine.cc.

      {
        std::map<std::tuple<int, int, int>, std::vector<std::shared_ptr<GlobalParamSetAccess>>> eventPayloads{};
        for (auto& row : payloadsTable) {
          for (auto& iovBlock : row.second) {
            for (auto& payload : iovBlock.second) {
              auto eventTuple = std::make_tuple((int)payload.first.getExperiment(), (int)payload.first.getRun(), (int)payload.first.getEvent());
              auto iter_and_inserted = eventPayloads.insert(
              {eventTuple, std::vector<std::shared_ptr<GlobalParamSetAccess>>()}
              );
              iter_and_inserted.first->second.push_back(payload.second);
            }
          }
        }
        for (auto event_payloads : eventPayloads) {
          auto event = EventMetaData(std::get<2>(event_payloads.first), std::get<1>(event_payloads.first), std::get<0>(event_payloads.first));
          DBStore::Instance().update(event);
          DBStore::Instance().updateEvent(event.getEvent());
          for (auto& payload : event_payloads.second) {
            payload->loadFromDBObjPtr();
          }
        }
      }

◆ releaseObjects()

std::vector< std::pair< IntervalOfValidity, TObject * > > releaseObjects ( )

Release all the objects (you become the owner!) for DB storage.

Returns: vector of pairs. First is the IoV to store this in DB. Second is the object (payload) itself. Note that this might be EventDependencies in case objects can change inside runs

Definition at line 279 of file GlobalTimeLine.cc.

      {
        std::vector<std::pair<IntervalOfValidity, TObject*>> result;
 
        for (auto& row : payloadsTable) {
          for (auto& iovBlock : row.second) {
            auto iov = iovBlock.first;
            auto obj = iovBlock.second.at(0).second->releaseObject();
 
            // non-intra-run
            if (iovBlock.second.size() == 1) {
              if (obj)
                result.push_back({iov, obj});
 
              continue;
            }
 
            // First obj in event dependency
            //TODO: how the lifetime of EventDependency is handled?
            // both work now -> have to check data storage in DB in real life scenario
            auto payloads = new EventDependency(obj);
            //auto payloads = EventDependency(obj);
            // Add others
            for (long unsigned int iObj = 1; iObj < iovBlock.second.size(); ++iObj) {
              auto nextEvent = iovBlock.second.at(iObj).first.getEvent();
              auto nextObj = iovBlock.second.at(iObj).second->releaseObject();
 
              if (nextObj)
                payloads->add(nextEvent, nextObj);
              //payloads.add(nextEvent, nextObj);
            }
            result.push_back({iov, payloads});
            //result.push_back({iov, &payloads});
          }
        }
        return result;
      }

◆ updateGlobalParam()

void updateGlobalParam	(	GlobalLabel	label,
		double	correction,
		bool	resetParam = `false`
	)

Add a correction to any payload's parameter in the timeline.

Parameters

label	the label any global parameter constructed from integer after Millepede calibration The mapping of time intervals has to be loaded for the label to provide correct infortmation about its validity in time intervals -> all payloads are updated until the end of validity of this parameter
correction	the value to be added to the given constant
resetParam	if True, the parameters is not updated with correction, but set to 'correction' value This has special use-case when filling the objects with errors/corrections data instead of absolute parameter values

Definition at line 252 of file GlobalTimeLine.cc.

      {
        auto timeid = label.getTimeId();
        auto eov = label.getEndOfValidity();
        auto uid = label.getUniqueId();
 
        std::set<int> payloadIndices;
        // this is probably dangerous if we do not impose additional invariant
        //TODO: better to always loop over whole event header?
        for (int i = timeid; i < std::min(eov + 1, int(std::get<EventHeader>(timeTable).size())); ++i) {
          payloadIndices.insert(getContinuousIndexByTimeID(timeTable, uid, i));
        }
 
        for (auto payloadIndex : payloadIndices) {
          auto payload = getPayloadByContinuousIndex(payloadsTable, label.getUniqueId(), payloadIndex).second;
          // If not found, we get an empty payload shared ptr
          if (payload) {
            if (resetParam) {
              payload->setGlobalParam(correction, label.getElementId(), label.getParameterId());
            } else {
              payload->updateGlobalParam(correction, label.getElementId(), label.getParameterId());
            }
          }
        }
 
      }

Member Data Documentation

◆ payloadsTable

PayloadsTable payloadsTable {}

private

Table with payloads.

Definition at line 152 of file GlobalTimeLine.h.

◆ timeTable

TimeTable timeTable {}

private

The final TimeTable with payload indices.

Definition at line 150 of file GlobalTimeLine.h.

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

alignment/include/GlobalTimeLine.h
alignment/src/GlobalTimeLine.cc

Public Member Functions

Private Attributes