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();
 
      ~ChannelMapper();
 
      void initialize(const GearDir& channelMapping);
 
      void initialize();
 
      bool isValid() const {return m_valid;}
 
      void import(const IntervalOfValidity& iov) const;
 
      EType getType() const {return m_type;}
 
      std::string getName() const {return m_typeName;}
 
      bool isPixelIDValid(int pixel) const
      {
        unsigned pix = pixel - 1;
        return pix < c_numPixels;
      }
 
      bool isChannelValid(unsigned channel) const
      {
        return channel < c_numPixels;
      }
 
      unsigned getChannel(int pixel) const;
 
      unsigned getChannel(unsigned boardstack,
                          unsigned carrier,
                          unsigned asic,
                          unsigned chan) const
      {
        return chan + c_numChannels * (asic + c_numAsics *
                                       (carrier + c_numCarrierBoards * boardstack));
      }
 
      void splitChannelNumber(unsigned channel,
                              unsigned& boardstack,
                              unsigned& carrier,
                              unsigned& asic,
                              unsigned& chan) const;
 
      int getPixelID(unsigned channel) const;
 
      int getPmtID(int pixel) const;
 
      void print() const;
 
      void test() const;
 
    private:
 
      ChannelMapper(const ChannelMapper&)
      {}
 
      ChannelMapper& operator=(const ChannelMapper&)
      {return *this;}
 
 
      void clear();
 
      void update();
 
      EType m_type = c_unknown;                
      std::string m_typeName;                  
      std::vector<TOPChannelMap> m_mapping;    
      DBArray<TOPChannelMap>* m_mappingDB = 0; 
      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