StationTriggerUtil.cc

Go to the documentation of this file.

#include <det/Detector.h>

#include <sdet/SDetector.h>
#include <sdet/StationTriggerUtil.h>

#include <sevt/PMT.h>
#include <sevt/PMTSimData.h>
#include <sevt/SEvent.h>
#include <sevt/Station.h>
#include <sevt/StationSimData.h>
#include <sevt/StationTriggerData.h>

#include <utl/Accumulator.h>
#include <utl/TimeStamp.h>
#include <utl/TimeInterval.h>
#include <utl/TimeDistribution.h>

#include <vector>

using namespace det;
using namespace sevt;
using namespace utl;


namespace sdet {

  namespace Trigger {

    void
    Buffer(sevt::Station& station, const TimeStamp& eventTime,
           const StationTriggerData::Algorithm algorithm,
           const int pldBits, const int start, const int stop)
    {
      const auto& dStation = Detector::GetInstance().GetSDetector().GetStation(station);

      const auto triggerTime = eventTime + TimeInterval(stop * dStation.GetFADCBinSize());

      // Copy the trace information
      for (auto& pmt : station.PMTsRange(sdet::PMTConstants::eAnyType)) {

        if (!pmt.HasSimData())
          continue;

        auto& pmtSim = pmt.GetSimData();

        for (const auto& t : pmtSim.FADCTracesRange(sdet::PMTConstants::eHighGain)) {

          const auto component = static_cast<StationConstants::SignalComponent>(t.GetLabel());

          if (!pmtSim.HasFADCTrace(triggerTime, component))
            pmtSim.MakeFADCTrace(triggerTime, component);
          else {
            ERROR("PMT already had trace at this time, not replacing!");
            continue;
          }
          auto& hg = pmtSim.GetFADCTrace(triggerTime, sdet::PMTConstants::eHighGain, component);
          auto& lg = pmtSim.GetFADCTrace(triggerTime, sdet::PMTConstants::eLowGain, component);
          auto& hgD = pmtSim.GetFADCTraceD(triggerTime, sdet::PMTConstants::eHighGain, component);
          auto& lgD = pmtSim.GetFADCTraceD(triggerTime, sdet::PMTConstants::eLowGain, component);

          // This zeros the triggered trace

          for (unsigned int i = 0, n = dStation.GetFADCTraceLength(); i < n; ++i) {
            hg[i] = 0;
            lg[i] = 0;
            hgD[i] = 0;
            lgD[i] = 0;
          }

          const auto& hgSim = pmtSim.GetFADCTrace(sdet::PMTConstants::eHighGain, component);
          const auto& lgSim = pmtSim.GetFADCTrace(sdet::PMTConstants::eLowGain, component);
          const auto& hgSimD = pmtSim.GetFADCTraceD(sdet::PMTConstants::eHighGain, component);
          const auto& lgSimD = pmtSim.GetFADCTraceD(sdet::PMTConstants::eLowGain, component);

          // Copy in the information
          for (int i = start; i < stop; ++i) {
            const int bin = i - start;
            hg[bin] = hgSim.At(i);
            lg[bin] = lgSim.At(i);
            hgD[bin] = hgSimD.At(i);
            lgD[bin] = lgSimD.At(i);
          }

          if (!pmt.HasFADCTrace(component))
            pmt.MakeFADCTrace(component);

          auto& pmtHG = pmt.GetFADCTrace(sdet::PMTConstants::eHighGain, component);
          auto& pmtLG = pmt.GetFADCTrace(sdet::PMTConstants::eLowGain, component);
          pmtHG = hg;
          pmtLG = lg;

          auto& pmtHGD = pmt.GetFADCTraceD(sdet::PMTConstants::eHighGain, component);
          auto& pmtLGD = pmt.GetFADCTraceD(sdet::PMTConstants::eLowGain, component);
          pmtHGD = hgD;
          pmtLGD = lgD;

        }

      }

      auto& sSim = station.GetSimData();
      if (sSim.HasTriggerData(triggerTime)) {
        ERROR("Trigger data already in sim data, not changing!");
        return;
      }

      sSim.MakeTriggerAndGPSData(triggerTime);
      auto& trig = sSim.GetTriggerData(triggerTime);
      trig.SetAlgorithm(algorithm);
      trig.SetPLDTrigger(pldBits);
      trig.SetOffsetMicroSecond(0);
      trig.SetErrorCode(0);
    }


    void
    PrepareTraces(const sevt::Station& station,
                  int& startBin, int& stopBin,
                  std::vector<const TimeDistributionI*>& traces)
    {
      traces.clear();

      Accumulator::Safe<Accumulator::Min<int>> minBin;
      Accumulator::Safe<Accumulator::Max<int>> maxBin;

      unsigned int nTraces = 0;
      for (const auto& pmt : station.PMTsRange()) {
        if (pmt.HasSimData() && pmt.GetSimData().HasFADCTrace()) {
          const auto& fadc = pmt.GetSimData().GetFADCTrace();
          minBin(fadc.GetStart());
          maxBin(fadc.GetStop());
          traces.push_back(&fadc);
          ++nTraces;
        }
      }

      if (!nTraces)
        return;

      startBin = minBin.GetMin();
      stopBin = maxBin.GetMax();

      if (nTraces < 3) {
        static const TimeDistributionI empty(traces.front()->GetBinning());
        for (int i = nTraces; i < 3; ++i)
          traces.push_back(&empty);
      }
    }

  }

}