CaloGeoParams.h

Go to the documentation of this file.

/*
 * CaloGeoParams.h
 *
 *  Created on: 19 Set 2019
 *      Author: Lorenzo Pacini
 */
 
#ifndef HERD_CALOGEOPARAMS_H_
#define HERD_CALOGEOPARAMS_H_
 
// HerdSoftware headers
#include "herd/analysis/common/AxesArray.h"
#include "herd/analysis/common/DefaultValues.h"
#include "herd/analysis/common/DirectionsArray.h"
#include "herd/analysis/dataobjects/Line.h"
#include "herd/analysis/dataobjects/Point.h"
#include "herd/analysis/dataobjects/Rectangle.h"
 
#ifdef HS_USE_ROOT
// Root headers
#include "Rtypes.h"
#endif
 
// C/C++ headers
#include <optional>
#include <vector>
 
namespace Herd {
 
class CaloGeoParams {
public:
  CaloGeoParams();
 
  virtual ~CaloGeoParams() = default;
 
  const Point &Position(unsigned int volID) const { return _positions[volID]; };
 
  using Indexes = CooArray<unsigned char>;
 
  const Point LPDPosition(unsigned int volID) const { return _positions[volID] + _lpdOffset; };
 
  const Point SPDPosition(unsigned int volID) const { return _positions[volID] + _spdOffset; };
 
  const Indexes &CooIndexes(unsigned int volID) const { return _indexes[volID]; };
 
  struct CooIndexRange {
    unsigned char begin = defaultValue<unsigned char>;
    unsigned char end = defaultValue<unsigned char>;
 
    bool operator==(const CooIndexRange &other) const { return begin == other.begin && end == other.end; }
    [[nodiscard]] unsigned char Size() const { return end - begin + 1; }
  };
 
  CooIndexRange CooIndexesRange(RefFrame::Axis axis, unsigned char index1, unsigned char index2);
 
  bool IsEmpty(unsigned int volID) const { return (_mask.size() == 0 ? false : _mask[volID]); };
 
  const float &CubeSize() const { return _cubeSize; };
 
  const AxesArray<float> LPDSize() const { return _lpdSize; };
 
  const AxesArray<float> SPDSize() const { return _spdSize; };
 
  float LYSODensity() const { return _lysoDensity; };
 
  float LYSORadiationLength() const { return 8.6728 / _lysoDensity; }; // 8.6728 = 1.172 * 7.4
 
  float LYSONuclearInteractionLength() const { return 152.3586 / _lysoDensity; }; // 152.3586 = 20.589 * 7.4
 
  const float &CubeSlotSize() const { return _cubeSlotSize; };
 
  unsigned int NCubes() const { return _positions.size(); };
 
  std::optional<unsigned int> VolumeID(const Indexes &cooIndex) const;
 
  std::optional<unsigned int> VolumeID(const Point &point) const;
 
  std::optional<std::pair<Point, Point>>
  CubeIntersections(const Line &track, const unsigned int volID,
                    const Herd::RefFrame::Coo sort_by_coo = Herd::RefFrame::Coo::NONE) const;
 
  float SphericalRadius() const { return _sphericalRadius; }
 
  struct EllipsoidalEnvelope {
    Point center;               
    AxesArray<float> halfAxes;  
    AxesArray<float> halfSizes; 
    EllipsoidalEnvelope();
    bool operator==(const EllipsoidalEnvelope &rhs);
    [[nodiscard]] float Volume() const;
  };
 
  const EllipsoidalEnvelope &SphericalCaloEnvelope() const;
 
  std::string FillerMaterial() const { return _fillerMaterial; };
 
  class PrismaticEnvelope {
  public:
    PrismaticEnvelope();
 
    PrismaticEnvelope(Point center, AxesArray<float> sizes, float xFaceYSize, float yFaceXSize);
 
    const Point &Center() const { return m_center; }
 
    const DirectionsArray<Rectangle> &LateralFaces() const;
 
    const std::array<Herd::Plane, 2> &ZPlanes() const;
 
    bool operator==(const PrismaticEnvelope &rhs);
 
    float Volume() const;
 
  private:
    Point m_center;                                    
    AxesArray<float> m_sizes;                          
    float m_xFaceYSize;                                
    float m_yFaceXSize;                                
    mutable DirectionsArray<Rectangle> m_lateralFaces; 
    mutable std::array<Herd::Plane, 2> m_zPlanes;      
  };
 
  const PrismaticEnvelope &PrismaticCaloEnvelope() const;
 
  const AxesArray<float> &Gaps() const { return _gaps; };
 
  const AxesArray<float> &Wells() const { return _wells; };
 
  void SetCubes(std::vector<Point> positions, std::vector<Indexes> indexes, float cubeSize,
                float cubeSlotSize = defaultValue<float>, std::vector<bool> mask = {});
 
  void SetPDs(Vec3D lpdOffset, Vec3D spdOffset, Herd::AxesArray<float> lpdSize, Herd::AxesArray<float> spdSize);
 
  void SetLYSODensity(float density) { _lysoDensity = density; };
 
  void SetSphericalRadius(float radius);
 
  void SetLPDSize(Herd::AxesArray<float> lpdSize) { _lpdSize = lpdSize; };
 
  void SetSPDSize(Herd::AxesArray<float> spdSize) { _spdSize = spdSize; };
 
  void SetFillerMaterial(std::string fillerMaterial) { _fillerMaterial = fillerMaterial; };
 
private:
  void FillCooId2VolIDMatrix();
  std::vector<Point> _positions; 
  std::vector<Indexes> _indexes; 
  std::vector<bool> _mask;       
  Vec3D _lpdOffset;              
  Vec3D _spdOffset;              
  float _cubeSize;               
  float _cubeSlotSize;           
  float _lysoDensity;            
  AxesArray<float> _gaps;        
  AxesArray<float> _wells;       
  float _sphericalRadius;        
  mutable EllipsoidalEnvelope
      _ellipsoidalEnvelopeParams;                     
  mutable PrismaticEnvelope _prismaticEnvelopeParams; 
  AxesArray<float> _lpdSize;                          
  AxesArray<float> _spdSize;                          
  std::vector<std::vector<std::vector<unsigned short>>>
      _cooId2VolIDMatrix;         
  unsigned int _nMaxCubesPerSide; 
  std::string _fillerMaterial; // name of the filler material: material inside the calo envelope where there's no LYSO
 
#ifdef HS_USE_ROOT
  ClassDef(CaloGeoParams, 7)
#endif
};
 
} // namespace Herd
 
#endif /* HERD_PSDGEOPARAMS_H_ */