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"
#include "pflib/packing/SingleECONDRocErxMapping.h"
 
namespace pflib {
 
class OptoLink;
class TRIG;
 
class Target {
 public:
  virtual ~Target() = default;
 
  virtual int nrocs() = 0;
 
  virtual int necons() = 0;
 
  virtual bool have_roc(int iroc) const = 0;
 
  virtual bool have_econ(int iecon) const = 0;
 
  virtual std::vector<int> roc_ids() const = 0;
 
  virtual std::vector<int> econ_ids() const = 0;
 
  virtual ROC& roc(int which) = 0;
 
  virtual ECON& econ(int which) = 0;
 
  virtual void hardResetROCs() = 0;
 
  virtual void hardResetECONs() = 0;
 
  virtual uint32_t getFirmwareVersion() { return -1; }
 
  virtual void softResetROC(int which = -1) = 0;
 
  virtual void softResetECON(int which = -1) = 0;
 
  virtual Elinks& elinks() = 0;
 
  virtual FastControl& fc() = 0;
 
  virtual DAQ& daq() = 0;
 
  virtual TRIG* trig(int itrig = 0) { return 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>>&
  getHardwareRocErxMappingDAQ() = 0;
 
  virtual const std::vector<std::pair<int, std::vector<int>>>&
  getHardwareRocErxMappingTRG() = 0;
 
  const packing::SingleECONDRocErxMapping& getRocErxMapping();
 
  enum class DaqFormat {
    SIMPLEROC = 1,
    ECOND_SW_HEADERS = 2
  };
 
  virtual void setup_run(int irun, DaqFormat format, int contrib_id = -1) = 0;
  virtual std::vector<uint32_t> read_event() = 0;
  virtual bool has_event() { return daq().getEventOccupancy() > 0; }
 
  class TempParametersAllROCs {
   public:
    TempParametersAllROCs(
        Target* tgt,
        const std::map<std::string, std::map<std::string, uint64_t>>&
            parameters);
    TempParametersAllROCs(
        Target* tgt,
        const std::map<int,
                       std::map<std::string, std::map<std::string, uint64_t>>>&
            parameters);
    TempParametersAllROCs(const TempParametersAllROCs&) = delete;
    TempParametersAllROCs& operator=(const TempParametersAllROCs&) = delete;
    ~TempParametersAllROCs();
 
   private:
    Target* tgt_;
    std::map<int, std::map<int, std::map<int, uint8_t>>> prior_registers_;
  };
 
  TempParametersAllROCs tempApplyAllROCs(
      const std::map<std::string, std::map<std::string, uint64_t>>& parameters);
 
  TempParametersAllROCs tempApplyAllROCs(
      const std::map<int,
                     std::map<std::string, std::map<std::string, uint64_t>>>&
          parameters);
 
 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:
  std::unique_ptr<packing::SingleECONDRocErxMapping> mapping_;
};
 
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