HgcrocEmulator.h

 
#ifndef TOOLS_HGCROCEMULATOR_H
#define TOOLS_HGCROCEMULATOR_H
 
#include "Conditions/SimpleTableCondition.h"
#include "Framework/Configure/Parameters.h"
#include "Framework/Logger.h"
#include "Recon/Event/HgcrocDigiCollection.h"
#include "Recon/Event/HgcrocPulseTruth.h"
 
//----------//
//   ROOT   //
//----------//
#include "TF1.h"
#include "TRandom3.h"
 
namespace ldmx {
 
class HgcrocEmulator {
 public:
  HgcrocEmulator(const framework::config::Parameters& ps);
 
  ~HgcrocEmulator() {}
 
  bool hasSeed() const { return noise_injector_.get() != nullptr; }
 
  void seedGenerator(uint64_t seed);
 
  void condition(const conditions::DoubleTableCondition& table) {
    // reset cache of column numbers if table changes
    if (&table != chip_conditions_) condition_names_to_index_.clear();
    chip_conditions_ = &table;
  }
 
  bool digitize(
      const int& channelID,
      std::vector<std::pair<double, double>>& arriving_pulses,
      std::vector<ldmx::HgcrocDigiCollection::Sample>& digiToAdd) const;
 
  std::vector<ldmx::HgcrocDigiCollection::Sample> noiseDigi(
      const int& channel, const double& soi_amplitude = 0) const;
 
  double noise(const int& channelID) const {
    return noise_injector_->Gaus(
        0, getCondition(channelID, "NOISE") * gain(channelID));
  };
 
  double gain(const int& channelID) const {
    return getCondition(channelID, "GAIN");
  }
 
  double pedestal(const int& id) const { return getCondition(id, "PEDESTAL"); }
 
  double readoutThreshold(const int& id) const {
    return getCondition(id, "READOUT_THRESHOLD");
  }
 
  bool save_pulse_truth_info_{false};
  ldmx::HgcrocPulseTruthCollection* pulse_truth_coll_;
 
 private:
  double getCondition(int id, const std::string& name) const {
    // check if emulator has been passed a table of conditions
    if (!chip_conditions_) {
      EXCEPTION_RAISE("HgcrocCond",
                      "HGC ROC Emulator was not given a conditions table.");
    }
 
    // cache column index for the input name
    if (condition_names_to_index_.count(name) == 0)
      condition_names_to_index_[name] = chip_conditions_->getColumnNumber(name);
 
    // get condition
    return chip_conditions_->get(id, condition_names_to_index_.at(name));
  }
 
 private:
  /**************************************************************************************
   * Parameters Identical for all Chips
   *************************************************************************************/
 
  bool noise_{true};
 
  int n_ad_cs_;
 
  int i_soi_;
 
  double clock_cycle_;
 
  double timing_jitter_;
 
  double ns_;
 
  double rate_up_slope_;
 
  double time_up_slope_;
 
  double rate_dn_slope_;
 
  double time_dn_slope_;
 
  double time_peak_;
 
  double hit_merge_ns_;
 
  /**************************************************************************************
   * Chip-Dependent Parameters (Conditions)
   *************************************************************************************/
 
  const conditions::DoubleTableCondition* chip_conditions_{nullptr};
 
  mutable std::map<std::string, int> condition_names_to_index_;
 
  /**************************************************************************************
   * Helpful Member Objects
   *************************************************************************************/
 
  std::unique_ptr<TRandom3> noise_injector_;
 
  mutable TF1 pulse_func_;
 
  enableLogging("HgcrocEmulator")
};  // HgcrocEmulator
 
}  // namespace ldmx
 
#endif  // TOOLS_HGCROCEMULATOR_H