FitGeoParams.h

Go to the documentation of this file.

/*
 * FitGeoParams.h
 *
 *  Created on: 20 Feb 2020
 *      Author: Valerio Formato
 */

#ifndef HERD_FITGEOPARAMS_H_
#define HERD_FITGEOPARAMS_H_

#ifdef HS_USE_ROOT
#include "Rtypes.h"
#endif

// C++ headers
#include <sstream>
#include <vector>

// HERD headers
#include "common/AxesArray.h"
#include "common/SidesArray.h"
#include "dataobjects/Point.h"
#include "dataobjects/TrackingDetectorGeoParams.h"

namespace Herd {

// clang-format off
  // sipm setup parameters

  //  Default Mat and SiPMs
  //  -----------------------------------------------------------
  //  |---------------|    |---------------|    |---------------|
  //  |               |    |               |    |               |
  //  |    SiPM0      |0.09|    SiPM1      |0.09|    SiPM2      |
  //  |   32.54mm     | mm |   32.54mm     | mm |   32.54mm     |
  //  |               |    |               |    |               |
  //  |---------------|    |---------------|    |---------------|
  //  -----------------------------------------------------------
  //  \_________________________97.8mm__________________________/
  //
  //
  // SiPM structure
  //
  //  ==================================================
  //  |    |                |    |                 |    |
  //  |    |                |    |                 |    |
  //  |    |  active die0   |    |  active die0    |    |
  //  |0.16|                |0.22|                 |0.16|
  //  | mm |  0.25mm*64     | mm |  0.25mm*64      | mm |
  //  |    |                |    |                 |    |
  //  |    |                |    |                 |    |
  //  |    |                |    |                 |    |
  //  ==================================================
  //  \__________________32.54mm_______________________/
  //
// clang-format on

class FitGeoParams : public TrackingDetectorGeoParams {
public:
  FitGeoParams();

  FitGeoParams(RefFrame::Side dside, size_t layerNumber, RefFrame::Direction mainSegm);

  virtual ~FitGeoParams() = default;

  unsigned int NSipmPerMat() const { return _nSipmsPerMat; }

  int NChannelsPerSipm() const { return _sipmDieChannels * _sipmNDies; }

  int NChannelsPerMat() const { return _nSipmsPerMat * NChannelsPerSipm(); }

  const AxesArray<int> &NMats() const { return _nMats; }

  unsigned int NTotElements() const {
    return _nMats[RefFrame::Axis::X] * _nMats[RefFrame::Axis::Y] * _nMats[RefFrame::Axis::Z];
  };

  const AxesArray<float> &MatSize() const { return _matSize; }

  float GetSipmAirGap() const { return _sipmAirGap; };

  Point ElementPosition(unsigned int elementID) const override;

  Point SipmPosition(unsigned int sipmID) const;

  Point MatPosition(unsigned int matID) const { return _matPos.at(matID); };

  unsigned int MatID(const Point &position) const;

  unsigned int MatIDFromChannelID(unsigned int channelID) const;

  unsigned int SipmIDFromChannelID(unsigned int channelID) const;

  unsigned int ElementID(const Point &position) const override;

  unsigned int SipmIDOnMat(float relativePosition) const;

  unsigned int ChannelIDOnMat(float relativePosition) const;

  float ChannelPositionOnMat(unsigned int channelIDOnMat) const;

  void SetSideAndMainSegmDir(RefFrame::Side dside, RefFrame::Direction segmDir) override;

  void SetNSipmPerMat(int nSipms) { _nSipmsPerMat = nSipms; };

  void SetMatSize(const AxesArray<float> &sizes);

  void SetNMats(AxesArray<int> nMats);

  void SetMatPosition(size_t matID, Point position) { _matPos.at(matID) = position; }

  struct PointOnDeadZone : public std::exception {
    Point _point;
    std::string _deadZoneType;
    bool _isLocalPoint;

  public:
    PointOnDeadZone(Point point, std::string deadZoneType, bool isLocalPoint = false)
        : _point(std::move(point)), _deadZoneType(std::move(deadZoneType)), _isLocalPoint(isLocalPoint){};

    void SetPoint(Point point) { _point = point; }

    const char *what() const throw() {
      // Use a static return string to let the embedded const char* survive after exiting this function
      static std::string returnStr;
      returnStr = "FitGeoParams: Point (" +                        //
                  std::to_string(_point[RefFrame::Coo::X]) + "," + //
                  std::to_string(_point[RefFrame::Coo::Y]) + "," + //
                  std::to_string(_point[RefFrame::Coo::X]) + ") is on dead zone (" + _deadZoneType + ")";
      return returnStr.c_str();
    }
  };

  class LayerZone {
  public:
    LayerZone(float minSegm, float maxSegm) : _min{minSegm}, _max{maxSegm} {}

    float MinSegm() const { return _min; }

    float MaxSegm() const { return _max; }

  private:
    float _min, _max;
  };

  using LayerZones = std::vector<LayerZone>;

  const LayerZones &ActiveZones();

  const LayerZones &DeadZones();

private:
  unsigned int _nSipmsPerMat; 
  AxesArray<int> _nMats;      
  AxesArray<float> _matSize;  
  std::vector<Point> _matPos; 

  LayerZones _activeZones, _deadZones; 

  void ComputeActiveDeadZones();

protected:
  float _sipmAirGap = 0.009;       
  float _sipmDieGap = 0.022;       
  float _sipmDeadRegion = 0.016;   
  float _sipmChannelPitch = 0.025; 
  size_t _sipmDieChannels = 64;    
  size_t _sipmNDies = 2;           
  float _sipmWidth =
      2 * _sipmDieChannels * _sipmChannelPitch + 2 * _sipmDeadRegion + _sipmDieGap; 
  std::vector<std::pair<float, float>> _sipmRelativePositions; 

#ifdef HS_USE_ROOT
  ClassDefOverride(FitGeoParams, 1)
#endif
};

} // namespace Herd

#endif /* HERD_FITGEOPARAMS_H_ */