Target.h

#ifndef PFLIB_TARGET_H_INCLUDED
#define PFLIB_TARGET_H_INCLUDED
 
#include "pflib/DAQ.h"
#include "pflib/ECON.h"
#include "pflib/Elinks.h"
#include "pflib/FastControl.h"
#include "pflib/I2C.h"
#include "pflib/ROC.h"
#include "pflib/lpGBT.h"
 
namespace pflib {
 
class OptoLink;
 
class Target {
 public:
  virtual ~Target() = default;
 
  virtual int nrocs() { return -1; }
 
  virtual int necons() { return -1; }
 
  virtual bool have_roc(int iroc) const { return false; }
 
  virtual bool have_econ(int iecon) const { return false; }
 
  virtual std::vector<int> roc_ids() const { return {}; }
 
  virtual std::vector<int> econ_ids() const { return {}; }
 
  virtual ROC& roc(int which) {
    PFEXCEPTION_RAISE(
        "NoImp", "ROC Access has not been implemented for the current target.");
  }
 
  virtual ECON& econ(int which) {
    PFEXCEPTION_RAISE(
        "NoImp",
        "ECON Access has not been implemented for the current target.");
  }
 
  virtual void hardResetROCs() {}
 
  virtual void hardResetECONs() {}
 
  virtual uint32_t getFirmwareVersion() { return -1; }
 
  virtual void softResetROC(int which = -1) {}
 
  virtual void softResetECON(int which = -1) {}
 
  virtual Elinks& elinks() = 0;
 
  virtual FastControl& fc() = 0;
 
  virtual DAQ& daq() = 0;
 
  std::vector<std::string> i2c_bus_names();
 
  I2C& get_i2c_bus(const std::string& name);
 
  std::vector<std::string> opto_link_names() const;
 
  OptoLink& get_opto_link(const std::string& name) const;
 
  virtual const std::vector<std::pair<int, int>>& getRocErxMapping() = 0;
 
  enum class DaqFormat {
    SIMPLEROC = 1,
    ECOND_NO_ZS = 2,
    ECOND_SW_HEADERS = 3
  };
 
  virtual void setup_run(int irun, DaqFormat format, int contrib_id = -1) {}
  virtual std::vector<uint32_t> read_event() = 0;
  virtual bool has_event() { return daq().getEventOccupancy() > 0; }
 
 protected:
  std::map<std::string, std::shared_ptr<I2C>> i2c_;
  std::map<std::string, std::shared_ptr<OptoLink>> opto_;
  mutable logging::logger the_log_{logging::get("Target")};
  // private:
  // Mapping ROC channel → eRx channel
  std::vector<std::pair<int, int>> roc_to_erx_map_;
};
 
Target* makeTargetFiberless();
Target* makeTargetHcalBackplaneZCU(int ilink, uint8_t board_mask);
Target* makeTargetHcalBackplaneBittware(int ilink, uint8_t board_mask,
                                        const char* dev);
Target* makeTargetEcalSMMZCU(int ilink, uint8_t roc_mask);
Target* makeTargetEcalSMMBittware(int ilink, uint8_t rocmask, const char* dev);
 
}  // namespace pflib
 
#endif  // PFLIB_TARGET_H_INCLUDED