HcalBackplane.h

#ifndef pflib_hcal_inc_
#define pflib_hcal_inc_
 
#include <memory>
 
#include "pflib/Bias.h"
#include "pflib/GPIO.h"
#include "pflib/HcalTarget.h"
#include "pflib/TRIG.h"
 
namespace pflib {
 
class HcalBackplane : public HcalTarget {
 public:
  virtual ~HcalBackplane() = default;
 
  HcalBackplane();
 
  void init(lpGBT& daq_lpgbt, lpGBT& trig_lpgbt, int hgcroc_boards,
            bool use_bias_cache);
 
  virtual int nrocs() override { return nhgcroc_; }
 
  virtual int necons() override { return necon_; }
 
  virtual bool have_roc(int iroc) const override;
 
  virtual bool have_econ(int iecon) const override;
 
  virtual std::vector<int> roc_ids() const override;
 
  virtual std::vector<int> econ_ids() const override;
 
  virtual ROC& roc(int which) override;
 
  virtual ECON& econ(int which) override;
 
  Bias& bias(int which) override;
 
  virtual GPIO& gpio() { return *gpio_; }
 
  virtual Elinks& elinks() = 0;
 
  virtual DAQ& daq() = 0;
 
  virtual TRIG* trig(int itrig) { return (itrig == 0) ? (trig_.get()) : (0); }
 
  const std::vector<std::pair<int, int>>& getHardwareRocErxMappingDAQ()
      override;
  const std::vector<std::pair<int, std::vector<int>>>&
  getHardwareRocErxMappingTRG() override;
 
  static const std::vector<std::pair<int, int>> ROC_ERX_MAPPING_DAQ;
  static const std::vector<std::pair<int, std::vector<int>>>
      ROC_ERX_MAPPING_TRG;
 
 protected:
  int nhgcroc_;
 
  int necon_;
 
  std::unique_ptr<GPIO> gpio_;
 
  struct HGCROCBoard {
    ROC roc;
    Bias bias;
    HGCROCBoard(std::shared_ptr<I2C> roc_i2c, uint8_t roc_addr,
                const std::string& roc_typename, std::shared_ptr<I2C> bias_i2c,
                std::shared_ptr<I2C> board_i2c, bool bias_use_cache);
  };
 
  std::array<std::unique_ptr<HGCROCBoard>, 4> rocs_;
 
  std::array<std::unique_ptr<ECON>, 3> econs_;
 
  std::unique_ptr<pflib::TRIG> trig_;
};
 
}  // namespace pflib
 
#endif  // pflib_hcal_inc_