GeoCache.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 <vxd/dataobjects/VxdID.h>
#include <vxd/geometry/SensorInfoBase.h>
#include <vxd/geometry/GeoTools.h>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <memory>
#include <framework/database/DBObjPtr.h>
#include <alignment/dbobjects/VXDAlignment.h>
 
class G4VPhysicalVolume;
// forward declaring G4Transform3D is a pain
namespace HepGeom { class Transform3D; }
typedef HepGeom::Transform3D G4Transform3D;
 
namespace Belle2 {
  namespace VXD {
    class GeoCache {
    public:
      ~GeoCache() { clear(); };
 

      void clear();

      void findVolumes(G4VPhysicalVolume* envelope);

      void addSensor(SensorInfoBase* sensorinfo);

      const std::set<Belle2::VxdID>  getLayers(SensorInfoBase::SensorType sensortype = SensorInfoBase::VXD);
      const std::set<Belle2::VxdID>& getLadders(Belle2::VxdID layer) const;
      const std::set<Belle2::VxdID>& getSensors(Belle2::VxdID ladder) const;

      bool validSensorID(Belle2::VxdID id) const;

      const std::vector<VxdID> getListOfSensors() const;

      /* If sensor not found, it returns a warning and the first sensor!*/
      const SensorInfoBase& getSensorInfo(Belle2::VxdID id) const;
 
      // ------------------ Alignment constants in reconstruction + hierarchy ------------------------------

      const std::map<VxdID, TGeoHMatrix>& getHalfShellPlacements() const;

      const std::vector<std::pair<VxdID, TGeoHMatrix>>& getLadderPlacements(VxdID halfShell) const;

      const std::vector<std::pair<VxdID, TGeoHMatrix>>& getSensorPlacements(VxdID ladder) const;

      void addHalfShellPlacement(VxdID halfShell, const G4Transform3D& placement);

      void addLadderPlacement(VxdID halfShell, VxdID ladder, const G4Transform3D& placement);

      void addSensorPlacement(VxdID ladder, VxdID sensor, const G4Transform3D& placement);

      void setupReconstructionTransformations();

      static TGeoHMatrix g4Transform3DToTGeo(const G4Transform3D& g4);

      static TGeoHMatrix getTGeoFromRigidBodyParams(double dU, double dV, double dW, double dAlpha, double dBeta, double dGamma);
 
      // --------------------------------------------------------------------------------------------------

      static GeoCache& getInstance();

      const GeoTools* getGeoTools()
      {
        if (!m_geoToolsPtr)
          m_geoToolsPtr = std::unique_ptr<GeoTools>(new GeoTools());
        return m_geoToolsPtr.get();
      }
 
    private:
      typedef std::unordered_map<VxdID::baseType, SensorInfoBase*> SensorInfoMap;
      typedef std::map<Belle2::VxdID, std::set<Belle2::VxdID> > SensorHierachy;

      GeoCache();
      GeoCache(const GeoCache&) = delete;
      GeoCache& operator=(const GeoCache&) = delete;

      std::set<Belle2::VxdID> m_pxdLayers;
      std::set<Belle2::VxdID> m_svdLayers;
      std::set<Belle2::VxdID> m_telLayers;
      SensorHierachy m_ladders;
      SensorHierachy m_sensors;

      std::map<VxdID, TGeoHMatrix> m_halfShellPlacements {};
      std::map<VxdID, std::vector<std::pair<VxdID, TGeoHMatrix>>> m_ladderPlacements {};
      std::map<VxdID, std::vector<std::pair<VxdID, TGeoHMatrix>>> m_sensorPlacements {};
      SensorInfoMap m_sensorInfo;

      std::unique_ptr<GeoTools> m_geoToolsPtr;

      DBObjPtr<VXDAlignment> m_vxdAlignments;
    };
  }

} //Belle2 namespace