FrontEndMapper.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/TOPFrontEndMap.h>
#include <framework/gearbox/GearDir.h>
#include <framework/database/DBArray.h>
#include <framework/database/IntervalOfValidity.h>
 
#include <map>
#include <unordered_set>
 
 
namespace Belle2 {
  namespace TOP {
 
    class FrontEndMapper {
 
    public:
 
      FrontEndMapper();
 
      ~FrontEndMapper();
 
      void initialize(const GearDir& frontEndMapping);
 
      void initialize();
 
      bool isValid() const {return m_valid;}
 
      void importPayload(const IntervalOfValidity& iov) const;
 
      const TOPFrontEndMap* getMap(int moduleID, int bs) const
      {
        moduleID--;
        if (moduleID >= 0 and moduleID < c_numModules and bs >= 0 and bs < c_numColumns)
          return m_fromModule[moduleID][bs];
        return 0;
      }
 
      const TOPFrontEndMap* getMap(unsigned short scrodID) const
      {
        std::map<unsigned short, const TOPFrontEndMap*>::const_iterator it =
          m_fromScrod.find(scrodID);
        if (it == m_fromScrod.end()) return 0;
        return it->second;
      }
 
      const TOPFrontEndMap* getMapFromCopper(unsigned copperID, int finesse) const
      {
        std::map<unsigned int, const TOPFrontEndMap*>::const_iterator it =
          m_fromCopper.find(copperID * 4 + finesse);
        if (it == m_fromCopper.end()) return 0;
        return it->second;
      }
 
      int getMapSize() const
      {
        if (m_fromDB) {
          return m_mappingDB->getEntries();
        } else {
          return m_mapping.size();
        }
      }
 
      const std::unordered_set<unsigned int>& getCopperIDs() const
      {
        return m_copperIDs;
      }
 
      int getModuleCNumber(int moduleID) const
      {
        for (int bs = 0; bs < c_numColumns; bs++) {
          const auto* map = getMap(moduleID, bs);
          if (map) return map->getModuleCNumber();
        }
        return 0;
      }
 
      void print() const;
 
    private:
 
      enum {c_numModules = 16, c_numColumns = 4};
 
      FrontEndMapper(const FrontEndMapper&)
      {}
 
      FrontEndMapper& operator=(const FrontEndMapper&)
      {return *this;}
 
      void clear();
 
      void update();
 
      std::vector<TOPFrontEndMap> m_mapping;      
      DBArray<TOPFrontEndMap>* m_mappingDB = 0;   
      bool m_valid = false;                       
      bool m_fromDB = false;                      
      std::unordered_set<unsigned int> m_copperIDs; 
      const TOPFrontEndMap* m_fromModule[c_numModules][c_numColumns] = {{0}}; 
      std::map<unsigned short, const TOPFrontEndMap*> m_fromScrod; 
      std::map<unsigned int, const TOPFrontEndMap*> m_fromCopper;  
    };
 
  } // TOP namespace
} // Belle2 namespace