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 "common/AxesArray.h"
#include "common/DefaultValues.h"
#include "common/DirectionsArray.h"
#include "dataobjects/Line.h"
#include "dataobjects/Point.h"
#include "dataobjects/Rectangle.h"

#ifdef HS_USE_ROOT
// Root headers
#include "Rtypes.h"
#endif

// C/C++ headers
#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 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; }
    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; };

  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(); };

  unsigned int VolumeID(const Indexes &cooIndex) const;

  unsigned int VolumeID(const Point &point) const;

  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);
    float Volume() const;
  };

  const EllipsoidalEnvelope &SphericalCaloEnvelope() const;

  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 SetLYSODensity(float density) { _lysoDensity = density; };

  void SetSphericalRadius(float radius);

private:
  void FillCooId2VolIDMatrix();
  std::vector<Point> _positions; 
  std::vector<Indexes> _indexes; 
  std::vector<bool> _mask;       
  float _cubeSize;               
  float _cubeSlotSize;           
  float _lysoDensity;            
  AxesArray<float> _gaps;        
  AxesArray<float> _wells;       
  float _sphericalRadius;        
  mutable EllipsoidalEnvelope
      _ellipsoidalEnvelopeParams;                     
  mutable PrismaticEnvelope _prismaticEnvelopeParams; 

  std::vector<std::vector<std::vector<unsigned short>>>
      _cooId2VolIDMatrix;         
  unsigned int _nMaxCubesPerSide; 

#ifdef HS_USE_ROOT
  ClassDef(CaloGeoParams, 5)
#endif
};

} // namespace Herd

#endif /* HERD_PSDGEOPARAMS_H_ */