ScdGeoParams.h

Go to the documentation of this file.

/*
 * ScdGeoParams.h
 *
 *  Created on: 14 Nov 2018
 *      Author: Nicola Mori
 */
 
#ifndef HERD_SCDGEOPARAMS_H_
#define HERD_SCDGEOPARAMS_H_
 
// HERD headers
#include "herd/analysis/common/AxesArray.h"
#include "herd/analysis/common/DefaultValues.h"
#include "herd/analysis/common/SidesArray.h"
#include "herd/analysis/common/TypeUtils.h"
#include "herd/analysis/dataobjects/Parallelepiped.h"
#include "herd/analysis/dataobjects/Point.h"
#include "herd/analysis/dataobjects/Rectangle.h"
#include "herd/analysis/dataobjects/TrackingDetectorGeoParams.h"
 
#ifdef HS_USE_ROOT
#include "Rtypes.h"
#endif
 
// C++ headers
#include <vector>
 
namespace Herd {
 
class ScdGeoParams : public TrackingDetectorGeoParams {
public:
  ScdGeoParams();
 
  ScdGeoParams(RefFrame::Side dside, size_t layerNumber, RefFrame::Direction stripMainSegm);
 
  ~ScdGeoParams() override = default;
 
  const Parallelepiped &BoundingBox() const;
 
  [[nodiscard]] size_t NWafers() const { return _waferPos.size(); }
 
  [[nodiscard]] size_t NTotElements() const;
 
  float StripPitch() const { return ElementPitch(); }
 
  int NStripsPerWafer() const { return _nStripsPerWafer; }
 
  int NStripsPerBondedLadder() const {
    if (m_ladderNormalToStrips) {
      return _nStripsPerWafer * _nWafersPerBondedLadder[RefFrame::ToAxis(WaferSegmentationDirections().first)];
    } else {
      return _nStripsPerWafer;
    }
  }
 
  int NStripsPerPhysLadder() const {
    if (m_ladderNormalToStrips) {
      return _nStripsPerWafer * _nWafersPerPhysLadder[RefFrame::ToAxis(WaferSegmentationDirections().first)];
    } else {
      return _nStripsPerWafer;
    }
  }
 
  float FirstStripPosition() const { return _firstStripPos; }
 
  const AxesArray<int> &NWafersPerBondedLadder() const { return _nWafersPerBondedLadder; };
 
  const AxesArray<int> &NBondedLadders() const { return _nBondedLadders; }
 
  const AxesArray<int> &NWafersPerPhysLadder() const { return _nWafersPerPhysLadder; }
 
  const AxesArray<int> &NPhysLadders() const { return _nPhysLadders; }
 
  const AxesArray<float> &WaferSize() const { return _waferSize; }
 
  Point ElementPosition(unsigned int volID) const override;
 
  Point StripPosition(unsigned int volID) const { return ElementPosition(volID); };
 
  const Point &WaferPosition(unsigned int volID) const { return _waferPos.at(volID); }
 
  Point LadderPosition(unsigned int ladderID) const;
 
  std::pair<RefFrame::Direction, RefFrame::Direction> StripSegmentationDirections() const {
    return SegmentationDirections();
  };
 
  std::pair<RefFrame::Direction, RefFrame::Direction> WaferSegmentationDirections() const;
 
  std::pair<RefFrame::Direction, RefFrame::Direction> LadderSegmentationDirections() const;
 
  unsigned int LadderIDFromStripID(unsigned int stripID) const;
 
  unsigned int LadderIDFromWaferID(unsigned int waferID) const;
 
  std::pair<unsigned int, unsigned int> WaferIDsFromLadderID(unsigned int ladderID) const;
 
  unsigned int WaferIDFromStripID(unsigned int stripID) const;
 
  std::pair<unsigned int, unsigned int> StripIDsFromLadderID(unsigned int ladderID) const;
 
  unsigned int StripIDOnLadder(unsigned int stripID) const;
 
  [[nodiscard]] std::optional<unsigned int> WaferID(const Point &position) const;
 
  [[nodiscard]] std::optional<unsigned int> ElementID(const Point &position) const override;
 
  [[nodiscard]] std::optional<unsigned int> StripID(const Point &position) const { return ElementID(position); };
 
  [[nodiscard]] Parallelepiped ElementShape(size_t volID) const;
 
  enum class BondingType {
    NONE,     
    STRAIGHT, 
    ZIGZAG    
  };
 
  [[nodiscard]] BondingType LadderBonding() const { return m_ladderBonding; }
 
  void SetSideAndStripMainSegmDir(RefFrame::Side dside, RefFrame::Direction segmDir) {
    SetSideAndMainSegmDir(dside, segmDir);
  };
 
  void SetSideAndMainSegmDir(RefFrame::Side dside, RefFrame::Direction segmDir) override;
 
  void SetStripPitch(float pitch);
 
  void SetNStripsPerWafer(int nStrips);
 
  void SetBondedLadders(const AxesArray<int> &nLadders, const AxesArray<int> &nWafersPerLadder, BondingType bType);
 
  void SetPhysLadders(const AxesArray<int> &nLadders, const AxesArray<int> &nWafersPerLadder) {
    SetLaddersHelper(nLadders, nWafersPerLadder, 0);
  };
 
  void SetWaferSize(const AxesArray<float> &sizes) {
    _waferSize = sizes;
    m_waferLUT.isValid = false;
  }
 
  void SetWaferPosition(size_t waferID, Point position) {
    _waferPos.at(waferID) = position;
    m_waferLUT.isValid = false;
  }
 
  void SetLadderNormalToStrips(bool value = true) { m_ladderNormalToStrips = value; };
 
private:
  float _firstStripPos;                   
  int _nStripsPerWafer;                   
  AxesArray<float> _waferSize;            
  AxesArray<int> _nWafersPerBondedLadder; 
  AxesArray<int> _nBondedLadders;         
  std::vector<Point> _waferPos;           
  bool mutable _bbIsValid{false};         
  Parallelepiped mutable _boundingBox;    
  BondingType m_ladderBonding;            
  bool m_ladderNormalToStrips;            
  AxesArray<int> _nWafersPerPhysLadder;   
  AxesArray<int> _nPhysLadders;           
 
  void ComputeBoundingBox() const;
  void SetLaddersHelper(const AxesArray<int> &nLadders, const AxesArray<int> &nWafersPerLadder,
                        int type); // 0->physical, 1->bonded
 
protected:
  void UpdateLUT() const;
 
  struct WaferLookupTable {
    bool isValid = false;
    std::array<size_t, 2>
        ncells; 
    std::array<float, 2> sizes; 
    std::array<float, 2> cellDimension; 
 
    Rectangle surface;
 
    std::vector<std::vector<unsigned int>> waferIDs; 
 
    WaferLookupTable() : DEFAULT_INIT(ncells), DEFAULT_INIT(cellDimension) {}
 
    const std::vector<unsigned int> &WaferIDsAtPos(std::array<float, 2> position);
 
    size_t PosToCellID(std::array<float, 2> position);
 
    void UpdateNCells(std::array<size_t, 2> newNcells);
    void UpdateSurface(std::array<float, 2> newOrigin, std::array<float, 2> newSizes);
    void UpdateInternals(std::vector<Point> waferPositions, std::array<float, 2> waferSizes,
                         std::pair<RefFrame::Direction, RefFrame::Direction> segmDirections);
  } mutable m_waferLUT; 
 
#ifdef HS_USE_ROOT
  ClassDefOverride(ScdGeoParams, 2)
#endif
};
 
} // namespace Herd
 
#endif /* HERD_SCDGEOPARAMS_H_ */