SVDOnlineToOfflineMap.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.                  *
 **************************************************************************/
 
#ifndef FADC_APV_MAPPER_H_
#define FADC_APV_MAPPER_H_
 
#include <vxd/dataobjects/VxdID.h>
#include <svd/dataobjects/SVDShaperDigit.h>
#include <boost/property_tree/ptree.hpp>
#include <unordered_map>
#include <unordered_set>
#include <string>
 
namespace Belle2 {
  class SVDOnlineToOfflineMap {
  public:
 
    void setErrorRate(int errorRate) {m_errorRate = errorRate;}
 
    class ChipID {
    public:
      typedef unsigned short baseType; // id
      typedef unsigned char chipNumberType; // FADC/APV number
 
 
      explicit ChipID(baseType id = 0) { m_id.id = id; }
      ChipID(chipNumberType FADC, chipNumberType APV25)
      { m_id.parts.FADC = FADC; m_id.parts.APV25 = APV25; }
      ChipID(const ChipID& other): m_id(other.m_id) {}
 
      ChipID& operator=(ChipID other) { m_id.id = other.m_id.id; return *this; }
      ChipID& operator=(baseType id) { m_id.id = id; return *this; }
      operator baseType() { return m_id.id; }
      bool operator==(const ChipID& other) const { return (m_id.id == other.m_id.id); }
      bool operator<(const ChipID& other) const { return (m_id.id < other.m_id.id); }
 
 
      baseType getID() const { return m_id.id; }
      chipNumberType getFADC() const {return m_id.parts.FADC; }
      chipNumberType getAPV25() const {return m_id.parts.APV25; }
      void setID(baseType id) {  m_id.id = id; }
      void setFADC(chipNumberType FADC) { m_id.parts.FADC = FADC; }
      void setAPV25(chipNumberType APV25) { m_id.parts.APV25 = APV25; }
 
    private:
      union {
        baseType id : 8 * sizeof(baseType);
        struct {
          chipNumberType FADC : 8 * sizeof(chipNumberType);
          chipNumberType APV25: 8 * sizeof(chipNumberType);
        } parts;
      } m_id;
    }; //ChipID class
 
    class SensorID {
    public:
      typedef unsigned short baseType;
      typedef unsigned short sensorNumberType;
 
 
      explicit SensorID(baseType id = 0) { m_ID.id = id; }
      SensorID(sensorNumberType layer,  sensorNumberType ladder, sensorNumberType dssd, bool side)
      { m_ID.PARTS.layer = layer; m_ID.PARTS.ladder = ladder; m_ID.PARTS.dssd = dssd; m_ID.PARTS.side = side; }
 
      SensorID& operator=(baseType id) { m_ID.id = id; return *this; }
 
      operator baseType() { return m_ID.id; }
 
    private:
 
      union {
        baseType id : 10;
        struct {
          sensorNumberType layer  : 2;
          sensorNumberType ladder : 4;
          sensorNumberType dssd   : 3;
          bool side           : 1;
        } PARTS;
      } m_ID;
    }; //SensorID class
 
    struct SensorInfo {
      VxdID m_sensorID;           
      bool m_uSide;               
      bool m_parallel;            
      unsigned short m_channel0;   
      unsigned short m_channel127; 
    }; // SensorInfo struct
 
    struct ChipInfo {
      unsigned short fadc; 
      unsigned char apv; 
      unsigned short stripFirst; 
      unsigned short stripLast; 
      unsigned char apvChannel; 
    }; // ChipInfo struct
 
    // SVDOnlineOffLineMap
 
    explicit SVDOnlineToOfflineMap(const std::string& xml_filename);
 
    SVDOnlineToOfflineMap() = delete;
 
 
    SVDShaperDigit* NewShaperDigit(unsigned char FADC, unsigned char APV25,
                                   unsigned char channel, short samples[6], float time = 0.0);
 
    const SensorInfo& getSensorInfo(unsigned char FADC, unsigned char APV25);
 
    bool isAPVinMap(unsigned short layer,  unsigned short ladder, unsigned short dssd, bool side, unsigned short strip);
 
    bool isAPVinMap(VxdID sensorID, bool side, unsigned short strip);
 
    void prepareListOfMissingAPVs();
    struct missingAPV {
      VxdID m_sensorID;           
      bool m_isUSide;               
      float m_halfStrip;          
    };
 
    std::vector< missingAPV > m_missingAPVs;
 
    int getNumberOfMissingAPVs()
    {
      return m_missingAPVs.size();
    }
 
    const ChipInfo& getChipInfo(unsigned short layer,  unsigned short ladder, unsigned short dssd, bool side, unsigned short strip);
 
    short getStripNumber(unsigned char channel, const SensorInfo& info) const
    { return (info.m_channel0 + ((unsigned short)channel) * (info.m_parallel ? 1 : -1)); }
 
 
    std::unordered_set<unsigned char> FADCnumbers;
 
    std::unordered_multimap<unsigned char, unsigned char> APVforFADCmap;
 
 
    typedef std::unordered_map<unsigned short, unsigned short> FADCmap; 
    void prepFADCmaps(FADCmap&, FADCmap&);
 
    unsigned short getFADCboardsNumber()
    {
      return FADCnumbers.size();
    }
 
  private:
 
    void ReadLayer(int nLayer,  boost::property_tree::ptree const& xml_layer);
 
    void ReadLadder(int nLayer, int nLadder, boost::property_tree::ptree const& xml_ladder);
 
    void ReadSensor(int nLayer, int nLadder, int nSensor, boost::property_tree::ptree const& xml_sensor);
 
    void ReadSensorSide(int nLayer, int nLadder, int nSensor, bool isU, boost::property_tree::ptree const& xml_side);
 
    std::string m_MapUniqueName;
 
    std::unordered_map< ChipID::baseType, SensorInfo > m_sensors; 
    std::unordered_map< SensorID::baseType, std::vector<ChipInfo> > m_chips; 
    unsigned int nBadMappingErrors = 0;
 
    int m_errorRate{1000};
 
    void addChip(unsigned char  chipN,
                 unsigned char  FADCn,
                 int nlayer, int nladder, int nsensor, bool isU,
                 unsigned short stripNumberCh0,
                 bool           isParallel);
 
    void addChip(unsigned char  chipN,
                 unsigned char  FADCn,
                 unsigned short stripNumberCh0,
                 bool           isParallel
                );
 
    ChipInfo m_currentChipInfo; 
    SensorInfo m_currentSensorInfo; 
  };
 
} // namespace Belle2
#endif