GlobalLArCellContainer.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef GLOBALSIM_GLOBALLARCELLCONTAINER_H
#define GLOBALSIM_GLOBALLARCELLCONTAINER_H
 
#include "AthContainers/DataVector.h"
#include "AthenaKernel/CLASS_DEF.h"
#include "CaloEvent/CaloCell.h"
#include "GlobalLArCell.h"
 
#include "Identifier/IdentifierHash.h"
 
#include <map>
 
namespace GlobalSim {

  struct Feb2MuxInfo {
      std::string muxName;
      int indexOnMux{};
  };
 
  class GlobalLArCellContainer : public DataVector<GlobalSim::GlobalLArCell> {
 
  public:
 
    using DataVector<GlobalLArCell>::DataVector;

    GlobalLArCellContainer() = default;

    struct StatusFlags {
        bool overflow{false};
        bool error{false};
    };

    struct LocSize {
        double eta{0.0};
        double phi{0.0};
        float deta{0.0};
        float dphi{0.0};
 
        bool operator<(const LocSize& ls) const {
        return (eta < ls.eta || (eta==ls.eta && phi < ls.phi));
        } 
    };

    GlobalLArCellContainer(const std::map<std::string, Feb2MuxInfo>& febMap);

    GlobalLArCellContainer(const GlobalLArCellContainer& other);

    void push_back(const GlobalLArCell& theCell, IdentifierHash hashId);

    const std::unordered_set<std::string>& getFeb2Keys() const { return m_feb2Keys; };

    const std::unordered_set<std::string>& getMuxKeys() const { return m_muxKeys; };

    const std::vector<std::shared_ptr<GlobalLArCell>>& getCellsForFeb2(const std::string& feb2) const;

    const std::shared_ptr<GlobalLArCell> getCellFromHash(IdentifierHash hashId) const;

    Identifier getIDFromLoc(float eta, float phi) const;
    
    const std::vector<std::string>& getOrderedFeb2sForMux(const std::string& mux) const;

    void setMaxCellsPerFeb2 (int n) { m_maxCellsPerFeb2 = n; }

    void setFeb2Flags(const std::string& feb2Key, bool overflow, bool error);

    void fillLocToIDMap(Identifier ID, const CaloCell*& cell);
    
    std::size_t getMaxCellsPerFeb2() const { return m_maxCellsPerFeb2; }

    const std::string& getMuxForFeb2(const std::string& feb2Key) const;

    bool feb2InOverflow(const std::string& feb2Key) const;

    bool feb2InError(const std::string& feb2Key) const;

    bool muxInOverflow(const std::string& muxKey) const;

    bool muxInError(const std::string& muxKey) const;
 
  private:

    std::map<std::string, StatusFlags> m_feb2Flags;
    std::map<std::string, StatusFlags> m_muxFlags;
    std::unordered_set<std::string> m_feb2Keys;
    std::unordered_set<std::string> m_muxKeys;
    std::map<std::string, std::vector<std::shared_ptr<GlobalLArCell>>> m_feb2ToCells;
    std::map<std::string, std::vector<std::string>> m_muxToFeb2Ordered;
    std::map<std::string, std::string> m_feb2ToMux;
    std::size_t m_maxCellsPerFeb2 = 0;
    std::map<IdentifierHash, std::shared_ptr<GlobalLArCell>> m_hashToCells;
    std::map<LocSize,Identifier> m_cellLocationToID;
  };
 
} //namespace GlobalSim
 
CLASS_DEF(GlobalSim::GlobalLArCellContainer, 1117669828, 1)
SG_BASE(GlobalSim::GlobalLArCellContainer, DataVector<GlobalSim::GlobalLArCell> );
 
#endif