Manager.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <string>
#include <vector>
#include <map>
#include <Geant4/G4Transform3D.hh>
#include <root/TMatrixD.h>
#include <genfit/StateOnPlane.h>
#include <root/TGeoMatrix.h>
#include <set>
 
#include <framework/logging/Logger.h>
 
#include <mdst/dbobjects/BeamSpot.h>
#include <alignment/dbobjects/VXDAlignment.h>
#include <alignment/dbobjects/CDCCalibration.h>
#include <klm/dbobjects/bklm/BKLMAlignment.h>
#include <klm/dbobjects/eklm/EKLMAlignment.h>
#include <klm/dbobjects/eklm/EKLMSegmentAlignment.h>
 
#include <cdc/dbobjects/CDCTimeZeros.h>
#include <cdc/dbobjects/CDCTimeWalks.h>
#include <cdc/dbobjects/CDCAlignment.h>
#include <cdc/dbobjects/CDCXtRelations.h>
 
#include <alignment/GlobalParam.h>
#include <alignment/GlobalTimeLine.h>
#include <alignment/Hierarchy.h>
 
#include <map>
#include <string>
#include <vector>
 
namespace Belle2 {
  namespace alignment {
 
    class GlobalCalibrationManager {
 
    public:
 
 
 
      std::function<bool(const EventMetaData&, const EventMetaData&)> cmpEventMetaData = [](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;
      };
 
      ~GlobalCalibrationManager() {}
      static GlobalCalibrationManager& getInstance();
 
 
      static void initGlobalVector(GlobalParamVector& vector);
 
      void sortUniqueVector(std::vector<EventMetaData>& vec);
 
 
      void initialize(const std::vector<std::string>& components = {}, const std::vector<EventMetaData>& timeSlices = {});
 
      void preCollect(const EventMetaData& emd);
 
    public:
      RigidBodyHierarchy& getAlignmentHierarchy() const { return *m_alignment; }
      LorentShiftHierarchy& getLorentzShiftHierarchy() const { return *m_lorentzShift; }
      Constraints& getConstraints() { return m_constraints; }
 
      void writeConstraints(std::string txtFilename);
 
    private:
      GlobalCalibrationManager() {};
      GlobalCalibrationManager(const GlobalCalibrationManager&);
      GlobalCalibrationManager& operator=(const GlobalCalibrationManager&);
 
      int updateTimeDepGlobalLabels(const EventMetaData& event);
 
 
      bool m_initialized {false};
 
      std::unique_ptr<RigidBodyHierarchy> m_alignment {new RigidBodyHierarchy()};
      std::unique_ptr<LorentShiftHierarchy> m_lorentzShift {new LorentShiftHierarchy()};
      std::unique_ptr<GlobalParamVector> m_globalVector {new GlobalParamVector()};
      std::map<long, Constraint> m_constraints {};
 
      std::vector<EventMetaData> m_dbTimeSlicing {};
 
      alignment::timeline::TimeTable m_iniTimeTable{};
    };
 
  }
}