GeoTools.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 <vxd/dataobjects/VxdID.h>
#include <vector>
#include <algorithm>
 
namespace Belle2 {
  namespace VXD {
 
    class GeoTools {
 
    public:
      GeoTools();
 
      /*********************************************************************
       * General geometry parameters
       ********************************************************************/
 
      unsigned short getNumberOfLayers() const { return m_listOfLayers.size(); }
 
      unsigned short getNumberOfPXDLayers() const { return m_firstSVDLayer; }
 
      unsigned short getNumberOfSVDLayers() const
      { return m_listOfLayers.size() - m_firstSVDLayer; }
 
      std::vector<unsigned short> getLayers() const { return m_listOfLayers; }
 
      std::vector<unsigned short> getPXDLayers() const
      {
        std::vector<unsigned short> pxdLayers;
        std::copy_if(m_listOfLayers.begin(), m_listOfLayers.end(),
                     std::back_inserter(pxdLayers),
                     [](unsigned short l)->bool {return l < 3;});
        return pxdLayers;
      }
 
      std::vector<unsigned short> getSVDLayers() const
      {
        std::vector<unsigned short> svdLayers;
        std::copy_if(m_listOfLayers.begin(), m_listOfLayers.end(),
                     std::back_inserter(svdLayers),
                     [](unsigned short l)->bool {return l > 2;});
        return svdLayers;
      }
 
      unsigned short getFirstLayer() const { return *m_listOfLayers.begin(); }
 
      unsigned short getLastLayer() const { return *m_listOfLayers.rbegin(); }
 
      short getFirstPXDLayer() const
      {
        return (m_firstSVDLayer > 0 ? *m_listOfLayers.begin() : -1);
      }
 
      short getLastPXDLayer() const
      {
        return (m_firstSVDLayer > 0 ? m_listOfLayers[m_firstSVDLayer - 1] : -1);
      }
 
      short getFirstSVDLayer() const
      {
        return (m_firstSVDLayer < m_listOfLayers.size() ? m_listOfLayers[m_firstSVDLayer] : -1);
      }
 
      short getLastSVDLayer() const
      {
        return (m_firstSVDLayer < m_listOfLayers.size() ? *m_listOfLayers.rbegin() : -1);
      }
 
      unsigned short getNumberOfSensors() const { return m_listOfSensors.size(); }
 
      unsigned short getNumberOfPXDSensors() const { return m_firstSVDIndex; }
 
      unsigned short getNumberOfSVDSensors() const
      { return m_listOfSensors.size() - m_firstSVDIndex; }
 
      /*********************************************************************
       * Chip-related parameters
       *********************************************************************/
      size_t getTotalPXDChips() const { return m_listOfPXDChips.size(); }
 
      unsigned short getNumberOfPXDUSideChips() const
      { return c_nPXDChipsU; }
 
      unsigned short getNumberOfPXDVSideChips() const
      { return c_nPXDChipsV; }
 
      unsigned short getNumberOfPXDReadoutGates() const
      { return c_nPXDReadoutGates; }
 
      size_t getTotalSVDChips() const { return m_listOfSVDChips.size(); }
 
      unsigned short getNumberOfSVDUSideChips() const
      { return c_nSVDChipsLu; }
 
      unsigned short getNumberOfSVDVSideChips(unsigned short layer) const
      { return (layer == 3 ? c_nSVDChipsL3 : c_nSVDChipsLv); }
 
      unsigned short getSVDChannelsPerChip() const
      { return c_nSVDChannelsPerChip; }
 
      /*********************************************************************
       * General sensor indexing
       *********************************************************************/
      int getSensorIndex(VxdID sensorID) const
      {
        return std::distance(
                 m_listOfSensors.begin(),
                 find(m_listOfSensors.begin(), m_listOfSensors.end(), sensorID)
               );
      }
 
      VxdID getSensorIDFromIndex(int vxdIndex) const
      {
        return m_listOfSensors[vxdIndex];
      }
 
      /*********************************************************************
       * PXD sensor indexing
       *********************************************************************/
      int getPXDSensorIndex(VxdID sensorID) const
      {
        return getSensorIndex(sensorID);
      }
      int getPXDSensorIndex(int layer, int ladder, int sensor) const
      {
        return getSensorIndex(VxdID(layer, ladder, sensor));
      }
 
      VxdID getSensorIDFromPXDIndex(int pxdIndex) const
      {
        return m_listOfSensors[pxdIndex];
      }
 
      /*********************************************************************
       * PXD chip indexing
       ********************************************************************/
      int getPXDChipIndex(VxdID sensorID, bool isU, int chip) const
      {
        VxdID chipID(sensorID);
        chip = isU ? chip - 1 : chip - 1 + c_nPXDChipsU;
        chipID.setSegmentNumber(static_cast<unsigned short>(chip));
        return std::distance(
                 m_listOfPXDChips.begin(),
                 std::find(m_listOfPXDChips.begin(), m_listOfPXDChips.end(), chipID));
      }
 
      int getPXDChipIndex(int layer, int ladder, int sensor, bool isU, int chip) const
      {
        return getPXDChipIndex(VxdID(layer, ladder, sensor), isU, chip);
      }
 
      VxdID getChipIDFromPXDIndex(int pxdChipIndex) const
      {
        return m_listOfPXDChips[pxdChipIndex];
      }
 
      bool isPXDSideU(VxdID chipID) const
      {
        return (chipID.getSegmentNumber() < c_nPXDChipsU);
      }
 
      unsigned short getPXDChipNumber(VxdID chipID) const
      {
        unsigned short chipNo = chipID.getSegmentNumber();
        return (chipNo < c_nPXDChipsU ? chipNo + 1 : (chipNo + 1 - c_nPXDChipsU));
      }
 
      /*********************************************************************
       * SVD sensor indexing
       *********************************************************************/
      int getSVDSensorIndex(VxdID sensorID) const
      {
        return (getSensorIndex(sensorID) - m_firstSVDIndex);
      }
 
      int getSVDSensorIndex(int layer, int ladder, int sensor) const
      {
        return getSVDSensorIndex(VxdID(layer, ladder, sensor));
      }
 
      VxdID getSensorIDFromSVDIndex(int svdIndex) const
      {
        return m_listOfSensors[m_firstSVDIndex + svdIndex];
      }
 
      /*********************************************************************
       * SVD chip indexing
       ********************************************************************/
 
      int getSVDChipIndex(VxdID sensorID, bool isU, int chip) const
      {
        VxdID chipID(sensorID);
        if (sensorID.getLayerNumber() == 3)
          chip = isU ? chip - 1 : chip - 1 + c_nSVDChipsL3;
        else
          chip = isU ? chip - 1 : chip - 1 + c_nSVDChipsLu;
        chipID.setSegmentNumber(static_cast<unsigned short>(chip));
        return std::distance(
                 m_listOfSVDChips.begin(),
                 std::find(m_listOfSVDChips.begin(), m_listOfSVDChips.end(), chipID));
      }
 
      int getSVDChipIndex(int layer, int ladder, int sensor, bool isU, int chip) const
      {
        return getSVDChipIndex(VxdID(layer, ladder, sensor), isU, chip);
      }
 
      VxdID getChipIDFromSVDIndex(int svdChipIndex) const
      {
        return m_listOfSVDChips[svdChipIndex];
      }
 
      bool isSVDSideU(VxdID chipID) const
      {
        /* cppcheck-suppress duplicateExpressionTernary */
        return (chipID.getLayerNumber() == 3 ? chipID.getSegmentNumber() < c_nSVDChipsL3 : chipID.getSegmentNumber() < c_nSVDChipsLu);
      }
 
      unsigned short getSVDChipNumber(VxdID chipID) const
      {
        unsigned short chipNo = chipID.getSegmentNumber();
        if (chipID.getLayerNumber() == 3) {
          if (chipNo < c_nSVDChipsL3)
            return chipNo + 1;
          else
            return (chipNo + 1 - c_nSVDChipsL3);
        } else {
          if (chipNo < c_nSVDChipsLu)
            return chipNo + 1;
          else
            return (chipNo + 1 - c_nSVDChipsLu);
        }
      }
 
      /*********************************************************************
       * Layer indexing
       ********************************************************************/
      int getLayerIndex(unsigned short layer) const
      {
        return std::distance(
                 m_listOfLayers.begin(),
                 std::find(m_listOfLayers.begin(), m_listOfLayers.end(), layer)
               );
      }
 
      unsigned short getLayerNumberFromLayerIndex(int index) const
      {
        return m_listOfLayers[index];
      }
 
 
    private:
 
      void createListOfLayers();
 
      void createListOfPXDChips();
 
      void createListOfSVDChips();
 
      std::vector<VxdID> m_listOfSensors;
 
      size_t m_firstSVDIndex;
 
      std::vector<unsigned short> m_listOfLayers;
 
      unsigned short m_firstSVDLayer;
 
      std::vector<VxdID> m_listOfPXDChips;
 
      std::vector<VxdID> m_listOfSVDChips;
 
      const unsigned short c_nPXDChipsU = 4;
      const unsigned short c_nPXDChipsV = 6;
      const unsigned short c_nPXDReadoutGates = 192;
      const unsigned short c_nSVDChipsL3 = 6;
      const unsigned short c_nSVDChipsLu = 6;
      const unsigned short c_nSVDChipsLv = 4;
      const unsigned short c_nSVDChannelsPerChip = 128;
    };
  } // VXD namespace
} // Belle2 namespace