GlobalParam.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 <framework/logging/Logger.h>
#include <framework/database/Database.h>
#include <framework/database/DBObjPtr.h>
#include <mdst/dbobjects/BeamSpot.h>
 
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
namespace Belle2 {
  namespace alignment {
    class GlobalParamVector;
    class GlobalDerivativesHierarchy;

    class EmptyGlobalParamSet : public TObject {
    public:
      // ------------- Interface to global Millepede calibration ----------------
      static unsigned short getGlobalUniqueID() {return 0;}
      double getGlobalParam(unsigned short, unsigned short) {return 0.;}
      void setGlobalParam(double, unsigned short, unsigned short) {}
      std::vector<std::pair<unsigned short, unsigned short>> listGlobalParams() {return {};}
      // ------------------------------------------------------------------------
    };
 

    class IGlobalParamInterface {
    public:
      virtual ~IGlobalParamInterface() {}
      virtual void readFromResult(std::vector<std::tuple<unsigned short, unsigned short, unsigned short, double>>&,
                                  GlobalParamVector&) {};

      virtual void setupAlignmentHierarchy(GlobalDerivativesHierarchy&) {}
    };

    class CDCGlobalParamInterface : public IGlobalParamInterface {
    public:
 
    };

    class VXDGlobalParamInterface : public IGlobalParamInterface {
    public:
      enum E_VXDHierarchyType {
        c_None = 0,
        c_Flat = 1,
        c_HalfShells = 2,
        c_Full = 3
      };

      static E_VXDHierarchyType s_hierarchyType;
      static bool s_enablePXD;
      static bool s_enableSVD;

      virtual void setupAlignmentHierarchy(GlobalDerivativesHierarchy& hierarchy) override final;
    };

    class GlobalParamSetAccess {
    public:
      GlobalParamSetAccess() {}
      virtual ~GlobalParamSetAccess() {}
      virtual unsigned short getGlobalUniqueID() const = 0;
      virtual double getGlobalParam(unsigned short, unsigned short) = 0;
      virtual void setGlobalParam(double, unsigned short, unsigned short) = 0;
      virtual std::vector<std::pair<unsigned short, unsigned short>> listGlobalParams() = 0;

      virtual void updateGlobalParam(double correction, unsigned short element, unsigned short param) {setGlobalParam(getGlobalParam(element, param) + correction, element, param);}
      virtual TObject* getDBObj() = 0;
      virtual std::string getDefaultName() const = 0;
      virtual TObject* releaseObject() = 0;
      virtual GlobalParamSetAccess* clone() = 0;

      virtual void loadFromDB(EventMetaData emd) = 0;
      virtual void loadFromDBObjPtr() = 0;

      virtual void construct() = 0;
      virtual bool isConstructed() const = 0;

      virtual bool hasBeenChangedInDB(bool resetChangedState = true) final {auto tmp = m_hasBeenChangedInDB; if (resetChangedState) m_hasBeenChangedInDB = false; return tmp;}
      virtual void callbackDB() {m_hasBeenChangedInDB = true;}

      template<class DBObjType>
      bool is() const {return DBObjType::getGlobalUniqueID() == getGlobalUniqueID();}

      bool empty()
      {
        // We consider this to be the definition of empty
        if (is<EmptyGlobalParamSet>())
          return true;
        // This is by convention (also used in hierarchy)
        if (getGlobalUniqueID() == 0)
          return true;
        // This actually constructs the object using Default constructor if not
        // previously loaded from DB (or using construct)
        // TODO this is still not fully impelemnted by DB objects
        if (listGlobalParams().empty())
          return true;
        return false;
      }

      operator bool()
      {
        return not empty() and isConstructed();
      }
 
    protected:
      bool m_hasBeenChangedInDB {false};
    };

    template<class DBObjType>
    class GlobalParamSet : public GlobalParamSetAccess {
    public:
      //       explicit GlobalParamSet(bool autoConstruct = false) {
      GlobalParamSet()
      {
        //TODO: re-enable
        //DBObjPtr<DBObjType> dbObject;
        //dbObject.addCallback(this, &GlobalParamSet<DBObjType>::callbackDB);
        // if (autoConstruct)
        //  construct();
      }

      ~GlobalParamSet() {m_object.reset();}

      virtual unsigned short getGlobalUniqueID() const override final {return DBObjType::getGlobalUniqueID();}
      virtual double getGlobalParam(unsigned short element, unsigned short param) override final {ensureConstructed(); return m_object->getGlobalParam(element, param);}
      virtual void setGlobalParam(double value, unsigned short element, unsigned short param) override final {ensureConstructed(); m_object->setGlobalParam(value, element, param);}
      virtual std::vector<std::pair<unsigned short, unsigned short>> listGlobalParams() override final {ensureConstructed(); return m_object->listGlobalParams();}
      virtual std::string getDefaultName() const override final {return DataStore::objectName<DBObjType>("");}

      virtual TObject* getDBObj() override final
      {
        if (!m_object)
          return nullptr;
 
        return m_object.get();
      }

      GlobalParamSet(const GlobalParamSet<DBObjType>& other)
      {
        m_hasBeenChangedInDB = other.m_hasBeenChangedInDB;
        // Make new unique ptr to a copy of the other internal object
        if (other.m_object)
          m_object.reset(new DBObjType(*(static_cast<DBObjType*>(other.m_object.get()))));
      }

      GlobalParamSet<DBObjType>& operator=(const GlobalParamSet<DBObjType>& other)
      {
        // check for self-assignment
        if (&other == this)
          return *this;
        m_hasBeenChangedInDB = other.m_hasBeenChangedInDB;
        // Make new unique ptr to a copy of the other internal object
        if (other.m_object)
          m_object.reset(new DBObjType(*(static_cast<DBObjType*>(other.m_object.get()))));
        return *this;
      }

      virtual TObject* releaseObject() override final
      {
        //ensureConstructed();
        return m_object.release();
      }

      virtual GlobalParamSetAccess* clone() override final
      {
        return new GlobalParamSet<DBObjType>(*this);
      }

      virtual void loadFromDBObjPtr() override final
      {
        DBObjPtr<DBObjType> dbObject;
        if (dbObject) {
          m_object.reset(new DBObjType(*dbObject));
          hasBeenChangedInDB();  // will set m_hasBeenChangedInDB to false, ignore return value;
        }
      }

      virtual void loadFromDB(EventMetaData event) override final
      {
        auto info = Database::Instance().getData(event, getDefaultName());
        DBObjType* ptr = dynamic_cast<DBObjType*>(info.first);
        if (!ptr) {
          B2ERROR("Could not fetch object " << getDefaultName() << " from DB.");
          return;
        }
        // don't make a copy, you own the object.
        m_object.reset(ptr);
        hasBeenChangedInDB();  // will set m_hasBeenChangedInDB to false, ignore return value;
      }

      virtual void construct() override final {m_object.reset(new DBObjType());}
      virtual bool isConstructed() const override final {return !!m_object;}

      virtual void callbackDB() override final {GlobalParamSetAccess::callbackDB();}
 
 
    private:
      std::unique_ptr<DBObjType> m_object {};
      void ensureConstructed() {if (!m_object) construct();}
    };

    template <>
    unsigned short GlobalParamSet<BeamSpot>::getGlobalUniqueID() const;
    template <>
    double GlobalParamSet<BeamSpot>::getGlobalParam(unsigned short element, unsigned short param);
    template <>
    void GlobalParamSet<BeamSpot>::setGlobalParam(double value, unsigned short element, unsigned short param);
    template <>
    std::vector<std::pair<unsigned short, unsigned short>> GlobalParamSet<BeamSpot>::listGlobalParams();
 
 
 

    class GlobalParamVector {
    public:
      GlobalParamSet<EmptyGlobalParamSet> c_emptyGlobalParamSet {};

      explicit GlobalParamVector(const std::vector<std::string>& components = {});

      ~GlobalParamVector() {}

      void construct();

      GlobalParamVector& operator+=(GlobalParamVector& rhs)
      {
        // this += rhs
        // TODO: needs full implementation of listing in DBObjects
        for (auto uid_element_param : listGlobalParams()) {
          double delta = rhs.getGlobalParam(std::get<0>(uid_element_param), std::get<1>(uid_element_param), std::get<2>(uid_element_param));
          updateGlobalParam(delta, std::get<0>(uid_element_param), std::get<1>(uid_element_param), std::get<2>(uid_element_param));
        }
        return *this;
      }

      void addSubDetectorInterface(std::shared_ptr<IGlobalParamInterface> interface = {})
      {
        if (interface) {
          if (std::find(m_subDetectorInterfacesVector.begin(), m_subDetectorInterfacesVector.end(),
                        interface) == m_subDetectorInterfacesVector.end())
            m_subDetectorInterfacesVector.push_back(interface);
        }
      }

      template <class DBObjType>
      void addDBObj(std::shared_ptr<IGlobalParamInterface> interface = {})
      {
        if (m_components.empty()
            or std::find(m_components.begin(), m_components.end(), DataStore::objectName<DBObjType>("")) != m_components.end()) {
          m_vector.insert(std::make_pair(DBObjType::getGlobalUniqueID(),
                                         std::unique_ptr<GlobalParamSet<DBObjType>>(new GlobalParamSet<DBObjType>)
                                        ));
          // NOTE: Components disabled this way also disable added interfaces (e.g. if geometry would be needed to load)
          // NOTE: add generic interfaces only once by addSubDetectorInterface(...)
          addSubDetectorInterface(interface);
        }
      }

      bool hasBeenChangedInDB(const std::set<unsigned short>& subset, bool resetChangedState = true)
      {
        bool changed = false;
 
        for (auto& uID_DBObj : m_vector) {
          if (!subset.empty() and subset.find(uID_DBObj.first) != subset.end())
            continue;
          if (uID_DBObj.second->hasBeenChangedInDB(resetChangedState)) {
            changed = true;
            break;
          }
        }
 
        return changed;
      }

      bool hasBeenChangedInDB(const std::set<unsigned short>& subset = {}) {return hasBeenChangedInDB(subset, false);}

      void updateGlobalParam(double difference, unsigned short uniqueID, unsigned short element, unsigned short param);

      void setGlobalParam(double value, unsigned short uniqueID, unsigned short element, unsigned short param);

      double getGlobalParam(unsigned short uniqueID, unsigned short element, unsigned short param);

      std::vector<std::tuple<unsigned short, unsigned short, unsigned short>> listGlobalParams();

      std::vector<TObject*> releaseObjects(bool onlyConstructed = true);

      void loadFromDB();
      void loadFromDB(const EventMetaData& event);

      void postReadFromResult(std::vector<std::tuple<unsigned short, unsigned short, unsigned short, double>>& result);
      void postHierarchyChanged(GlobalDerivativesHierarchy& hierarchy);

      template<class DBObjType>
      DBObjType* getDBObj()
      {
        if (m_vector.find(DBObjType::getGlobalUniqueID()) == m_vector.end())
          return nullptr;
 
        return static_cast<DBObjType*>(m_vector[DBObjType::getGlobalUniqueID()]->getDBObj());
      }

      template<class DBObjType>
      GlobalParamSetAccess& getGlobalParamSet()
      {
        if (m_vector.find(DBObjType::getGlobalUniqueID()) == m_vector.end())
          return c_emptyGlobalParamSet;
 
        return static_cast<GlobalParamSet<DBObjType>&>(*m_vector[DBObjType::getGlobalUniqueID()]);
      }

      const std::map<unsigned short, std::unique_ptr<GlobalParamSetAccess>>& getGlobalParamSets() const
      {
        return m_vector;
      }

      const std::vector<std::shared_ptr<IGlobalParamInterface>>& getSubDetectorInterfaces() const
      {
        return m_subDetectorInterfacesVector;
      }

      std::set<unsigned short> getComponentsIDs() const
      {
        std::set<unsigned short> result;
        for (auto& id_obj : m_vector)
          result.insert(id_obj.first);
        return result;
      }
    private:
      std::map<unsigned short, std::unique_ptr<GlobalParamSetAccess>> m_vector {};
      std::vector<std::shared_ptr<IGlobalParamInterface>> m_subDetectorInterfacesVector {};
      std::vector<std::string> m_components {};
      std::set<unsigned short> m_componentsIDs {};
    };
  }
}