GlobalLArCell.h

Go to the documentation of this file.

/*
 *   Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */
 
#ifndef GLOBALSIM_GLOBALLARCELL_H
#define GLOBALSIM_GLOBALLARCELL_H
 
#include <vector>
#include <string>
#include <boost/dynamic_bitset.hpp>
 
namespace GlobalSim{
  class GlobalLArCell
  {
 
  public:
 
    GlobalLArCell();
 
    GlobalLArCell(uint32_t ID, 
                  std::string FEB2, 
                  int channel);
 
    GlobalLArCell(const GlobalLArCell&) = default;
 
    GlobalLArCell& operator=(const GlobalLArCell&) = default;
 
    ~GlobalLArCell() { };
 
    // ----- setter functions -----
 
    void setEnergy (float energy);
    void setEnergy (float energy, boost::dynamic_bitset<>&& energy_bitset);
    void setPosition (float eta, float phi);
    void setSampling (int sampling);
    void setLayer (int layer);
    void setSigma (float sigma);
    void setMUX(std::string muxname);
    void setLASP(std::string laspname);
    void setBoardConnector(std::string connector, std::string type, int number, int fiber);
 
    // ----- getter functions -----
 
    float getEnergy () const;
    const boost::dynamic_bitset<>& getEnergyBitstring() const;
    uint32_t getID () const;
    int getChannel () const;
    float getSigma () const;
    float eta () const;
    float phi () const;
    int getSampling() const;
    int getLayer() const;
    const std::string& getFEB2 () const;
    const std::string& getMUX() const;
    const std::string& getLASP() const;
    const std::string& getConnector() const;
    const std::string& getConnectorType() const;
 
 
  protected:
 
    uint32_t m_id = -1;
 
    float m_eta = -99.9;
 
    float m_phi = -99.9;
 
    int m_sampling = -1;
 
    int m_layer = -1;
 
    std::string m_feb2 = "";
 
    int m_channel = -1;
 
    float m_energy = -1;
 
    boost::dynamic_bitset<> m_energy_bitset;
 
    float m_sigma = -99.9;
 
    std::string m_mux = "";
 
    std::string m_lasp = "";
 
    std::string m_connector = "";
 
    std::string m_connectorType = "";
 
    int m_connectorNumber = -1;
 
    int m_fiber = -1;
 
  };
 
  // inline functions
 
  inline GlobalLArCell::GlobalLArCell() :
    m_id(0),
    m_feb2("NONE"),
    m_channel(0),
    m_energy(0),
    m_sigma(0)
  {}
 
  inline GlobalLArCell::GlobalLArCell(uint32_t ID,
          std::string FEB2,
          int channel) :
    m_id(ID),
    m_feb2(FEB2),
    m_channel(channel),
    m_energy(0),
    m_sigma(0)
  {}
 
  // Setter functions
  inline void GlobalLArCell::setEnergy (float energy) { m_energy = energy; }
  inline void GlobalLArCell::setEnergy (float energy, boost::dynamic_bitset<>&& energy_bitset) { 
      m_energy = energy;
      m_energy_bitset = std::move(energy_bitset);
  }
  inline void GlobalLArCell::setPosition (float eta, float phi) { 
      m_eta = eta;
      m_phi = phi;
  }
  inline void GlobalLArCell::setSampling (int sampling) { m_sampling = sampling; }
  inline void GlobalLArCell::setLayer (int layer) { m_layer = layer; }
  inline void GlobalLArCell::setSigma (float sigma) { m_sigma = sigma; }
  inline void GlobalLArCell::setMUX (std::string muxname) { m_mux = std::move(muxname); };
  inline void GlobalLArCell::setLASP (std::string laspname) { m_lasp = std::move(laspname); };
  inline void GlobalLArCell::setBoardConnector (std::string connector, std::string type, int number, int fiber) { 
      m_connector = std::move(connector);
      m_connectorType = std::move(type);
      m_connectorNumber = number;
      m_fiber = fiber;
  };
 
  // Getter functions
  inline float GlobalLArCell::getEnergy () const { return m_energy; }
  inline const boost::dynamic_bitset<>& GlobalLArCell::getEnergyBitstring() const { return m_energy_bitset; }
  inline uint32_t GlobalLArCell::getID () const { return m_id; }
  inline int GlobalLArCell::getChannel () const { return m_channel; }
  inline float GlobalLArCell::getSigma () const { return m_sigma; }
  inline float GlobalLArCell::eta () const { return m_eta; }
  inline float GlobalLArCell::phi () const { return m_phi; }
  inline int GlobalLArCell::getSampling () const { return m_sampling; }
  inline int GlobalLArCell::getLayer () const { return m_layer; }
  inline const std::string& GlobalLArCell::getFEB2 () const { return m_feb2; }
  inline const std::string& GlobalLArCell::getMUX() const { return m_mux; }
  inline const std::string& GlobalLArCell::getLASP() const { return m_lasp; }
  inline const std::string& GlobalLArCell::getConnector() const { return m_connector; }
  inline const std::string& GlobalLArCell::getConnectorType() const { return m_connectorType; }
 
}
 
#endif //GLOBALSIM_GLOBALLARCELL_H