ChannelMapper.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/TOPChannelMap.h>
#include <framework/gearbox/GearDir.h>
#include <framework/database/DBArray.h>
#include <framework/database/IntervalOfValidity.h>
 
 
namespace Belle2 {
  namespace TOP {

    class ChannelMapper {
 
    public:
      enum {c_numBoardstacks = 4,   
            c_numCarrierBoards = 4, 
            c_numAsics = 4,         
            c_numChannels = 8,      
            c_numRows = 2,          
            c_numColumns = 16,      
            c_numPixelRows = c_numRows * c_numCarrierBoards, 
            c_numPixelColumns = c_numColumns * c_numBoardstacks, 
            c_numPixels = c_numPixelRows * c_numPixelColumns, 
            c_invalidChannel = c_numPixels, 
            c_invalidPixelID = 0 
           };

      enum EType {c_unknown = 0,
                  c_default = 1,
                  c_IRS3B   = 2,
                  c_IRSX    = 3
                 };

      ChannelMapper();

      void initialize(const GearDir& channelMapping);

      void initialize();

      bool isValid() const {return m_valid;}

      void importPayload(const IntervalOfValidity& iov) const;

      EType getType() const {return m_type;}

      const std::string& getName() const {return m_typeName;}

      static bool isPixelIDValid(int pixel)
      {
        unsigned pix = pixel - 1;
        return pix < c_numPixels; // cppcheck-suppress knownConditionTrueFalse
      }

      static bool isChannelValid(unsigned channel)
      {
        return channel < c_numPixels;
      }

      unsigned getChannel(int pixel) const;

      static unsigned getChannel(unsigned boardstack,
                                 unsigned carrier,
                                 unsigned asic,
                                 unsigned chan)
      {
        return chan + c_numChannels * (asic + c_numAsics *
                                       (carrier + c_numCarrierBoards * boardstack));
      }

      static void splitChannelNumber(unsigned channel,
                                     unsigned& boardstack,
                                     unsigned& carrier,
                                     unsigned& asic,
                                     unsigned& chan);

      int getPixelID(unsigned channel) const;

      static int getPmtID(int pixel);

      void print() const;

      void test() const;
 
    private:

      void clear();

      void update();
 
      EType m_type = c_unknown;                
      std::string m_typeName;                  
      std::vector<TOPChannelMap> m_mapping;    
      DBArray<TOPChannelMap> m_mappingDB;      
      bool m_valid = false;                    
      bool m_fromDB = false;                   
 
      const TOPChannelMap* m_channels[c_numRows][c_numColumns] = {{0}}; 
      const TOPChannelMap* m_pixels[c_numAsics][c_numChannels] = {{0}}; 
 
    };
 
  } // TOP namespace
} // Belle2 namespace