Geometry.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_PHOS_GEOMETRY_H_
#define ALICEO2_PHOS_GEOMETRY_H_
 
#include <string>
#include <array>
 
#include <Rtypes.h>
#include <RStringView.h>
#include <TGeoMatrix.h>
#include <TVector3.h>
#include <TMath.h>
#include <array>
 
namespace o2
{
namespace phos
{
class Geometry
{
 public:
  Geometry() = default;
 
  Geometry(const std::string_view name);
 
  Geometry(const Geometry& geom);
 
  ~Geometry() = default;
 
  Geometry& operator=(const Geometry& rvalue);
 
  static Geometry* GetInstance() { return sGeom; }
 
  //  \param mcname: Geant3/4, Fluka, needed for settings of transport (check) \param mctitle: Geant4 physics list
  //  (check)
  static Geometry* GetInstance(const std::string_view name)
  {
    if (sGeom) {
      if (sGeom->GetName() == name) {
        return sGeom;
      } else {
        delete sGeom;
      }
    }
    sGeom = new Geometry(name);
    return sGeom;
  }
 
  //         = 1 are neighbour
  //         = 2 are not neighbour but do not continue searching
  //         =-1 are not neighbour, continue searching, but do not look before d2 next time
  static int areNeighbours(short absId1, short absId2);
 
  //  \param cell: cell in strip number
  static short relToAbsId(char moduleNumber, int strip, int cell);
  // Converts the absolute numbering into the following array
  //  relid[0] = PHOS Module number 1:module
  //  relid[1] = Row number inside a PHOS module (Phi coordinate)
  //  relid[2] = Column number inside a PHOS module (Z coordinate)
  static bool absToRelNumbering(short absId, char* relid);
  static char absIdToModule(short absId);
  static void absIdToRelPosInModule(short absId, float& x, float& z);
  static void relPosToRelId(short module, float x, float z, char* relId);
  static bool relToAbsNumbering(const char* RelId, short& AbsId);
 
  // Converters for TRU tiles
  static bool truAbsToRelNumbering(short truId, short trigType, char* relid);
  static short truRelToAbsNumbering(const char* relId, short trigType);
  static short relPosToTruId(char mod, float x, float z, short trigType);
 
  // local position to absId
  static void relPosToAbsId(char module, float x, float z, short& absId);
 
  // convert local position in module to global position in ALICE
  void local2Global(char module, float x, float z, TVector3& globaPos) const;
 
  // calculate impact position on PHOS
  bool impactOnPHOS(const TVector3& vtx, const TVector3& p,
                    short& module, float& z, float& x) const;
 
  static int getTotalNCells() { return 56 * 64 * 4; } // TODO: evaluate from real geometry
  static bool isCellExists(short absId)
  {
    return absId >= 0 && absId <= getTotalNCells();
  } // TODO: evaluate from real geometry
 
  const std::string& GetName() const { return mGeoName; }
 
  const TGeoHMatrix* getAlignmentMatrix(int mod) const { return &(mPHOS[mod]); }
 
 private:
  static constexpr float CELLSTEP = 2.25;
 
  static Geometry* sGeom;           // Pointer to the unique instance of the singleton
  std::array<TGeoHMatrix, 5> mPHOS; // Rotation/shift matrices
 
  std::string mGeoName; 
 
  ClassDefNV(Geometry, 1);
};
} // namespace phos
} // namespace o2
#endif