TOPGeoPrism.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <top/dbobjects/TOPGeoBarSegment.h>
#include <string>
#include <vector>
#include <utility>
#include <math.h>
#include <Math/Vector2D.h>
 
namespace Belle2 {
  class TOPGeoPrism: public TOPGeoBarSegment {
  public:
 
    struct PeelOffRegion {
      unsigned ID; 
      float fraction; 
      float angle;    
    };
 
 
    struct UnfoldedWindow {
      double y0 = 0; 
      double z0 = 0; 
      double sy = 0; 
      double sz = 0; 
      double ny = 0; 
      double nz = 0; 
      double nsy[2] = {0, 0}; 
      double nsz[2] = {0, 0}; 
      UnfoldedWindow(const ROOT::Math::XYVector& orig, const ROOT::Math::XYVector& dir,
                     const ROOT::Math::XYVector& norm, const ROOT::Math::XYVector& slanted);
    };
 
 
    TOPGeoPrism()
    {}
 
    TOPGeoPrism(double width, double thickness, double length,
                double exitThickness, double flatLength,
                const std::string& material,
                const std::string& name = "TOPPrism_"):
      TOPGeoBarSegment(width, thickness, length, material, name),
      m_exitThickness(exitThickness), m_flatLength(flatLength)
    {}
 
    void setAngle(double angle)
    {
      m_flatLength = m_length - (m_exitThickness - m_thickness) / tan(angle);
    }
 
    void setPeelOffRegions(double size, double offset, double thickness,
                           const std::string& material)
    {
      m_peelOffSize = size;
      m_peelOffOffset = offset;
      m_peelOffThickness = thickness;
      m_peelOffMaterial = material;
    }
 
    void appendPeelOffRegion(unsigned ID, double fraction, double angle);
 
    double getExitThickness() const {return m_exitThickness / s_unit;}
 
    double getFlatLength() const {return m_flatLength / s_unit;}
 
    double getFullFlatLength() const {return (m_flatLength + m_glueThickness) / s_unit;}
 
    double getAngle() const
    {
      return atan((m_exitThickness - m_thickness) / (m_length - m_flatLength));
    }
 
    double getFilterThickness() const {return m_glueThickness / s_unit;}
 
    const std::string& getFilterMaterial() const {return m_glueMaterial;}
 
    double getGlueThickness() const override {return 0;}
 
    double getPeelOffSize() const {return m_peelOffSize / s_unit;}
 
    double getPeelOffThickness() const {return m_peelOffThickness / s_unit;}
 
    const std::string& getPeelOffMaterial() const {return m_peelOffMaterial;}
 
    const std::vector<PeelOffRegion>& getPeelOffRegions() const {return m_peelOffRegions;}
 
    double getPeelOffCenter(const PeelOffRegion& region) const
    {
      return (m_peelOffOffset - (region.ID - 1) * m_peelOffSize) / s_unit;
    }
 
    std::vector<std::pair<double, double> > getPeelOffContour(const PeelOffRegion& region) const;
 
    const std::vector<UnfoldedWindow>& getUnfoldedWindows() const
    {
      if (m_unfoldedWindows.empty()) unfold();
      return m_unfoldedWindows;
    }
 
    int getK0() const
    {
      if (m_unfoldedWindows.empty()) unfold();
      return m_k0;
    }
 
    bool isConsistent() const override;
 
    void print(const std::string& title = "Prism geometry parameters") const override;
 
 
  private:
 
    void setGlue(double, const std::string&) override {}
 
    void setGlueDelamination(double, double, const std::string&) override {}
 
    void unfold() const;
 
    void reflect(const ROOT::Math::XYVector* points, const ROOT::Math::XYVector* normals,
                 const ROOT::Math::XYVector& orig, const ROOT::Math::XYVector& surf,
                 const ROOT::Math::XYVector& norm, const ROOT::Math::XYVector& slanted, int k,
                 std::vector<UnfoldedWindow>& result) const;
 
    float m_exitThickness = 0; 
    float m_flatLength = 0; 
    float m_peelOffSize = 0;       
    float m_peelOffOffset = 0;     
    float m_peelOffThickness = 0;  
    std::string m_peelOffMaterial; 
    std::vector<PeelOffRegion> m_peelOffRegions; 
    mutable std::vector<UnfoldedWindow> m_unfoldedWindows; 
    mutable int m_k0 = 0; 
 
    ClassDefOverride(TOPGeoPrism, 2); 
  };
 
} // end namespace Belle2