GeometryManager.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef ALICEO2_BASE_GEOMETRYMANAGER_H_
#define ALICEO2_BASE_GEOMETRYMANAGER_H_
 
#include <TGeoManager.h> // for TGeoManager
#include <TGeoMaterial.h>
#include <TGeoPhysicalNode.h> // for TGeoPNEntry
#include <TGeoShape.h>
#include <TMath.h>
#include <TObject.h> // for TObject
#include <string_view>
#include "DetectorsCommonDataFormats/DetID.h"
#include "GPUCommonLogger.h" // for LOG
#include "MathUtils/Cartesian.h"
#include "DetectorsBase/MatCell.h"
#include <mutex>
#include <vector>
class TGeoHMatrix; // lines 11-11
class TGeoManager; // lines 9-9
class TGeoNavigator;
 
namespace o2
{
namespace detectors
{
class AlignParam;
}
 
namespace base
{
enum class MatbudGeomBackend : int { ROOT = 0,
                                     VECGEOM = 1 };
 
class GeometryManager : public TObject
{
 public:
  static void loadGeometry(std::string_view geomFilePath = "", bool applyMisalignment = false, bool preferAlignedFile = true);
  static bool isGeometryLoaded() { return gGeoManager != nullptr; }
  static void applyMisalignent(bool applyMisalignment = true);
 
  static Bool_t getOriginalMatrix(o2::detectors::DetID detid, int sensid, TGeoHMatrix& m);
  static Bool_t getOriginalMatrix(const char* symname, TGeoHMatrix& m);
  static TGeoHMatrix* getMatrix(const char* symname);
  static const char* getSymbolicName(o2::detectors::DetID detid, int sensid);
  static TGeoPNEntry* getPNEntry(o2::detectors::DetID detid, Int_t sensid);
  static TGeoHMatrix* getMatrix(o2::detectors::DetID detid, Int_t sensid);
 
  static int getSensID(o2::detectors::DetID detid, int sensid)
  {
    return detid <= o2::detectors::DetID::FOC ? ((detid << sDetOffset) | (sensid & sSensorMask)) : ((detid << sDetOffsetLarge) | (sensid & sSensorMaskLarge));
  }
 
  ~GeometryManager() override = default;
 
  static bool applyAlignment(const std::vector<o2::detectors::AlignParam>& algPars);
  static bool applyAlignment(const std::vector<const std::vector<o2::detectors::AlignParam>*> algPars);
 
  struct MatBudgetExt {
    double meanRho = 0.;  // mean density: sum(x_i*rho_i)/sum(x_i) [g/cm3]
    double meanX2X0 = 0.; // equivalent rad length fraction: sum(x_i/X0_i) [adimensional]
    double meanA = 0.;    // mean A: sum(x_i*A_i)/sum(x_i) [adimensional]
    double meanZ = 0.;    // mean Z: sum(x_i*Z_i)/sum(x_i) [adimensional]
    double meanZ2A = 0.;  // Z/A mean: sum(x_i*Z_i/A_i)/sum(x_i) [adimensional]
    double length = -1.;  // length: sum(x_i) [cm]
    int nCross = 0;       // number of boundary crosses
 
    MatBudgetExt() = default;
    ~MatBudgetExt() = default;
    MatBudgetExt(const MatBudgetExt& src) = default;
    MatBudgetExt& operator=(const MatBudgetExt& src) = default;
    void normalize(double nrm);
    ClassDefNV(MatBudgetExt, 1);
  };
 
  static o2::base::MatBudget meanMaterialBudget(float x0, float y0, float z0, float x1, float y1, float z1,
                                                TGeoNavigator* nav = nullptr);
  static o2::base::MatBudget meanMaterialBudget(const math_utils::Point3D<float>& start, const math_utils::Point3D<float>& end, TGeoNavigator* nav = nullptr)
  {
    return meanMaterialBudget(start.X(), start.Y(), start.Z(), end.X(), end.Y(), end.Z(), nav);
  }
  static o2::base::MatBudget meanMaterialBudget(const math_utils::Point3D<double>& start, const math_utils::Point3D<double>& end, TGeoNavigator* nav = nullptr)
  {
    return meanMaterialBudget(start.X(), start.Y(), start.Z(), end.X(), end.Y(), end.Z(), nav);
  }
 
  static MatBudgetExt meanMaterialBudgetExt(float x0, float y0, float z0, float x1, float y1, float z1);
  static MatBudgetExt meanMaterialBudgetExt(const math_utils::Point3D<float>& start, const math_utils::Point3D<float>& end)
  {
    return meanMaterialBudgetExt(start.X(), start.Y(), start.Z(), end.X(), end.Y(), end.Z());
  }
  static MatBudgetExt meanMaterialBudgetExt(const math_utils::Point3D<double>& start, const math_utils::Point3D<double>& end)
  {
    return meanMaterialBudgetExt(start.X(), start.Y(), start.Z(), end.X(), end.Y(), end.Z());
  }
 
#ifdef O2_WITH_VECGEOM
  static constexpr bool isVecGeomAvailable() { return true; }
  static o2::base::MatBudget vecGeomMaterialBudget(float x0, float y0, float z0, float x1, float y1, float z1);
#else
  static constexpr bool isVecGeomAvailable() { return false; }
#endif
 
  static bool ensureVecGeomWorld();
 
  static bool vecGeomLocate(double x, double y, double z, std::vector<TGeoNode*>& chain);
 
 private:
  GeometryManager() = default;
  static TGeoHMatrix* getMatrix(TGeoPNEntry* pne);
  static void accountMaterial(const TGeoMaterial* material, MatBudgetExt& bd);
  static void accountMaterial(const TGeoMaterial* material, o2::base::MatBudget& bd)
  {
    bd.meanRho = material->GetDensity();
    bd.meanX2X0 = material->GetRadLen();
  }
 
  static Bool_t getOriginalMatrixFromPath(const char* path, TGeoHMatrix& m);
 
 private:
  static constexpr UInt_t sDetOffset = 15; 
  static constexpr UInt_t sSensorMask = (0x1 << sDetOffset) - 1;           
  static constexpr UInt_t sDetOffsetLarge = 17;                            
  static constexpr UInt_t sSensorMaskLarge = (0x1 << sDetOffsetLarge) - 1; 
  static std::mutex sTGMutex;
 
  ClassDefOverride(GeometryManager, 0); // Manager of geometry information for alignment
};
} // namespace base
} // namespace o2
 
#endif