TankTriggerSimulator.cc

Go to the documentation of this file.

#include <fwk/CentralConfig.h>
#include <det/Detector.h>
#include <sdet/SDetector.h>
#include <sdet/Station.h>
#include <evt/Event.h>
#include <sevt/PMT.h>
#include <sevt/PMTCalibData.h>
#include <sevt/SEvent.h>
#include <sevt/Header.h>
#include <sevt/Station.h>
#include <sevt/StationTriggerData.h>
#include <utl/AugerUnits.h>
#include <utl/ErrorLogger.h>
#include <utl/TimeDistribution.h>
#include <utl/MultiTrace.h>
#include <utl/PhysicalConstants.h>
#include <utl/Reader.h>
#include <utl/TimeStamp.h>
#include <utl/RandomEngine.h>
#include <utl/TabularStream.h>
#include <sdet/StationTriggerAlgorithm.h>
#include <sdet/StationTriggerUtil.h>

#include "TankTriggerSimulator.h"

#include <cmath>

using namespace fwk;
using namespace det;
using namespace evt;
using namespace sevt;
using namespace utl;
using namespace std;


namespace TankTriggerSimulatorOG {

#define PARAMETER_SET(_p_, _b_) f##_p_ = _b_.GetChild(#_p_).Get<decltype(f##_p_)>()

  void
  TankTriggerSimulator::T1ThresholdParameters::Set(const Branch& b)
  {
    PARAMETER_SET(LevelVEM, b);
    PARAMETER_SET(Multiplicity, b);
  }


  void
  TankTriggerSimulator::T2ThresholdParameters::Set(const Branch& b)
  {
    PARAMETER_SET(LevelVEM, b);
    PARAMETER_SET(Multiplicity, b);
  }


  void
  TankTriggerSimulator::TOTParameters::Set(const Branch& b)
  {
    PARAMETER_SET(LevelVEM, b);
    PARAMETER_SET(Occupancy, b);
    PARAMETER_SET(Window, b);
    PARAMETER_SET(Multiplicity, b);
  }


  void
  TankTriggerSimulator::IntegralParameters::Set(const Branch& b)
  {
    PARAMETER_SET(Window, b);
    PARAMETER_SET(Decrement, b);
    PARAMETER_SET(Threshold, b);
    PARAMETER_SET(BaselineTolerance, b);
    PARAMETER_SET(BaselineStep, b);
  }


  void
  TankTriggerSimulator::TOTdParameters::Set(const Branch& b)
  {
    PARAMETER_SET(LevelVEM, b);
    PARAMETER_SET(DecayFD, b);
    PARAMETER_SET(DecayFN, b);
    PARAMETER_SET(Occupancy, b);
    PARAMETER_SET(Window, b);
    PARAMETER_SET(Multiplicity, b);
  }


  void
  TankTriggerSimulator::MOPSParameters::Set(const Branch& b)
  {
    PARAMETER_SET(Occupancy, b);
    PARAMETER_SET(Window, b);
    PARAMETER_SET(MinUp, b);
    PARAMETER_SET(MaxUp, b);
    PARAMETER_SET(VetoOffset, b);
    PARAMETER_SET(Multiplicity, b);
  }

#undef PARAMETER_SET


  VModule::ResultFlag
  TankTriggerSimulator::Init()
  {
    auto& cc = *CentralConfig::GetInstance();
    Branch topB = cc.GetTopBranch("TankTriggerSimulatorOG");

    if (!topB) {
      WARNING("Top branch <TankTriggerSimulatorOG> not found, trying <TankTriggerSimulator> instead.");
      topB = cc.GetTopBranch("TankTriggerSimulator");
    }

    fT1Threshold.Set(topB.GetChild("T1Threshold"));

    fT2Threshold.Set(topB.GetChild("T2Threshold"));

    fTOT.Set(topB.GetChild("TOT"));

    fIntegral.Set(topB.GetChild("Integral"));

    fTOTd.Set(topB.GetChild("TOTd"));

    fMOPS.Set(topB.GetChild("MOPS"));

    return eSuccess;
  }


  VModule::ResultFlag
  TankTriggerSimulator::Run(evt::Event& event)
  {
    if (!event.HasSEvent()) {
      ERROR("Nonexisting SEvent.");
      return eFailure;
    }

    auto& sEvent = event.GetSEvent();

    const auto& eventTime = event.GetHeader().GetTime();

    vector<const TimeDistributionI*> traces;

    TabularStream tab("r|r|r|r|l");
    tab << "ID" << endc
        << "(start, stop)" << endc
        << "bins" << endc
        << "latch" << endc
        << "" << endr;

    for (auto& station : sEvent.StationsRange()) {

      using namespace sdet::Trigger;
      int startBin = 0;
      int stopBin = 0;
      PrepareTraces(station, startBin, stopBin, traces);

      if (traces.size() < 3)
        continue;

      const auto& dStation = Detector::GetInstance().GetSDetector().GetStation(station);

      // Set the thresholds according to this particular station.
      FADCCalibInfo calib;
      const int nThresholds = GetCalibInfo(station, calib);

      if (nThresholds < 3)
        continue;

      const int n = 3; // number of traces
      const ThresholdUp t1th(calib.fT1Threshold, fT1Threshold.fMultiplicity, n);
      const ThresholdUp t2th(calib.fT2Threshold, fT2Threshold.fMultiplicity, n);
      const TimeOverThreshold tot(calib.fTOTThreshold, fTOT.fOccupancy, fTOT.fWindow, fTOT.fMultiplicity, n);
      // UUB has 4x resolution in fadc
      const int adcFactor = station.IsUUB() ? 4 : 1;
      const int integralThreshold = adcFactor * fIntegral.fThreshold;
      const DecayingIntegral integ(fIntegral.fWindow, fIntegral.fDecrement, integralThreshold,
                                   calib.fBaseline, fIntegral.fBaselineTolerance, fIntegral.fBaselineStep, n);
      const TimeOverThresholdDeconvolved totd(calib.fTOTdThreshold,
                                              fTOTd.fDecayFD, fTOTd.fDecayFN,
                                              fTOTd.fOccupancy, fTOTd.fWindow,
                                              fTOTd.fMultiplicity, n);
      const int mopsMinUp = adcFactor * fMOPS.fMinUp;
      const int mopsMaxUp = adcFactor * fMOPS.fMaxUp;

      // DFN: We need to use different veto offset here for UB and UUB.
      const int vetoOffset = station.IsUUB() ? fMOPS.fVetoOffset+3 : fMOPS.fVetoOffset;
      const MultiplicityOfPositiveSteps mops(fMOPS.fOccupancy, fMOPS.fWindow,
                                             mopsMinUp, mopsMaxUp, vetoOffset,
                                             fMOPS.fMultiplicity, n);

      sdet::StationTriggerAlgorithm stationTrigger(t1th, t2th, tot, integ, totd, mops,
                                                   dStation.GetLatchBin(), dStation.GetFADCTraceLength());

      const auto info = stationTrigger.Run(startBin, stopBin, traces);

      if (info.empty())
        Buffer(station, eventTime, StationTriggerData::eSilent, StationTriggerData::ePLDNone, 0, 0);
      else {
        for (const auto& i : info) {
          tab << station.GetId() << endc
              << "(" << startBin << ", " << stopBin << ")" << endc
              << "(" << i.GetStart() << ", " << i.GetStop() << ")" << endc
              << i.GetLatch() << endc;
          if (i.IsT1Threshold())
            tab << "T1Thr ";
          if (i.IsTimeOverThreshold())
            tab << "ToT ";
          if (i.IsTimeOverThresholdDeconvoluted())
            tab << "ToTd ";
          if (i.IsMultiplicityOfPositiveSteps())
            tab << "MoPs ";
          if (i.IsT2Threshold())
            tab << "T2thr ";
          tab << endr;

          Buffer(station, eventTime, i.GetTrigger(), i.GetPLDBits(), i.GetStart(), i.GetStop());

        }
      }
    }

    DEBUGLOG(tab);

    return eSuccess;
  }


  int
  TankTriggerSimulator::GetCalibInfo(const Station& station, FADCCalibInfo& calibInfo)
    const
  {
    const bool isUUB = station.IsUUB();

    int nPMTs = 0;

    for (const auto& pmt : station.PMTsRange()) {

      const auto& calib = pmt.GetCalibData();
      const auto base = calib.GetBaseline();

      const auto& sim = pmt.GetSimData();
      const double vem = sim.GetTriggerVEMPeak(isUUB);

      const int pmtId = pmt.GetId() - sdet::Station::GetFirstPMTId();
      calibInfo.fBaseline[pmtId] = base;
      calibInfo.fT1Threshold[pmtId] = round(base + vem * fT1Threshold.fLevelVEM);
      calibInfo.fT2Threshold[pmtId] = round(base + vem * fT2Threshold.fLevelVEM);
      calibInfo.fTOTThreshold[pmtId] = round(base + vem * fTOT.fLevelVEM);
      calibInfo.fTOTdThreshold[pmtId] = round(base + vem * fTOTd.fLevelVEM);

      ++nPMTs;

    }

    return nPMTs;
  }

}