LEHitReco_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       LEHitReco
// Plugin Type: producer (art v2_12_00)
// File:        LEHitReco_module.cc
//
// Generated at Tue Mar 12 13:47:28 2019 by Dung Phan using cetskelgen
// from cetlib version v3_06_00.
// this version modifided by John Rabaey for LE discrimination, as opposed to CFD
//
// Description: Reconstruct hits from digitizer channels with LE.
////////////////////////////////////////////////////////////////////////

// framework
#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Principal/Run.h"
#include "art/Framework/Principal/SubRun.h"
#include "canvas/Utilities/InputTag.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "art/Framework/Services/Optional/TFileService.h"
#include "art/Framework/Services/Optional/TFileDirectory.h"
#include "canvas/Persistency/Common/FindManyP.h"

// nova
#include "BeamlineReco/LEHitFinderAlg.h"
#include "BeamlineRecoBase/BeamlineDigit.h"
#include "BeamlineUtils/BeamlineChannelMap.h"
#include "RawData/RawBeamline.h"
#include "Utilities/AssociationUtil.h"

// stl
#include <iostream>
#include <memory>

namespace beamlinereco {
  class LEHitReco;
}

class beamlinereco::LEHitReco : public art::EDProducer {
public:
  explicit LEHitReco(const fhicl::ParameterSet & p);

  void reconfigure(const fhicl::ParameterSet & p);
  void produce(art::Event & e) override;

private:
  LEHitFinder<double>*         fLEHitFinderAlg;
  art::InputTag                fRawDataLabel;
  std::map<LEParams, double>  fLEParamSet;

  // services
  art::ServiceHandle<beamlineutil::BeamlineChannelMap> fChannelMap;
};


beamlinereco::LEHitReco::LEHitReco(const fhicl::ParameterSet & p) {
  produces<std::vector<brb::BeamlineDigit> >();
  produces<art::Assns<brb::BeamlineDigit, rawdata::RawBeamlineDigit> >();
  
  reconfigure(p);
}

void beamlinereco::LEHitReco::reconfigure(const fhicl::ParameterSet & p) {
  fRawDataLabel                                          = p.get<art::InputTag>("RawDataLabel");
  
  fLEParamSet[kADCNBits]                                = p.get<double>("valADCNBits");
  fLEParamSet[kADCDynamicRange]                         = p.get<double>("valADCDynamicRange");
  fLEParamSet[kADCOffset]                               = p.get<double>("valADCOffset");
  fLEParamSet[kTimeSamplingInterval]                    = p.get<double>("valTimeSamplingInterval");
  fLEParamSet[kNSamplingPoints]                         = p.get<double>("valNSamplingPoints");
  fLEParamSet[kIsWaveformNegativePolarity]              = p.get<bool>  ("valIsWaveformNegativePolarity");
  fLEParamSet[kLEThresholdInNoiseBands]                 = p.get<double>("valLEThresholdInNoiseBands");
  fLEParamSet[kRawHitFinderThresholdInNoiseSigma]       = p.get<double>("valRawHitFinderThresholdInNoiseSigma");
  fLEParamSet[kShortRawHitIgnoringDurationInTicks]      = p.get<double>("valShortRawHitIgnoringDurationInTicks");
  fLEParamSet[kConsecutiveHitSeperationDurationInTicks] = p.get<double>("valConsecutiveHitSeperationDurationInTicks");
  fLEParamSet[kGSFilter]                                = p.get<bool>  ("valGSFilter"); 
  fLEParamSet[kGSFilterWindow]                          = p.get<double>("valGSFilterWindow");
  fLEParamSet[kGSFilterDegree]                          = p.get<double>("valGSFilterDegree");
  fLEParamSet[kIntergratedWindowFixed]                  = p.get<bool>  ("valIntergratedWindowFixed");
  fLEParamSet[kIntergratedWindowLowerLimitIndex]        = p.get<double>("valIntergratedWindowLowerLimitIndex");
  fLEParamSet[kIntergratedWindowUpperLimitIndex]        = p.get<double>("valIntergratedWindowUpperLimitIndex");

  fLEHitFinderAlg = new LEHitFinder<double>();
  fLEHitFinderAlg->SetParams(fLEParamSet);
}

void beamlinereco::LEHitReco::produce(art::Event & e) {
  std::unique_ptr<std::vector<brb::BeamlineDigit> > digit_reco(new std::vector<brb::BeamlineDigit>);
  std::unique_ptr<art::Assns<brb::BeamlineDigit, rawdata::RawBeamlineDigit> > digit_assn(new art::Assns<brb::BeamlineDigit, rawdata::RawBeamlineDigit>);

  // get the raw digits
  art::Handle<std::vector<rawdata::RawBeamlineDigit> > digitHandle;
  std::vector<art::Ptr<rawdata::RawBeamlineDigit> > digits;
  if (e.getByLabel(fRawDataLabel, digitHandle)) art::fill_ptr_vector(digits, digitHandle);

  // run the reco algorithm here
  for (std::vector<art::Ptr<rawdata::RawBeamlineDigit> >::const_iterator digitIt = digits.begin(); digitIt != digits.end(); ++digitIt) {
    unsigned int channelNumber = fChannelMap->OnlineDigitChannel((*digitIt)->ChannelID());
    std::vector<uint16_t> waveform = (*digitIt)->ADCs();
    uint32_t timestamp = (*digitIt)->Timestamp();

    fLEHitFinderAlg->SetWaveform(waveform, channelNumber, timestamp);
    fLEHitFinderAlg->Go();
    std::map<double, hit_t<double> > HitCollection = fLEHitFinderAlg->GetHitCollection();

    for (std::map<double, hit_t<double> >::iterator digitHCIt = HitCollection.begin(); digitHCIt != HitCollection.end(); digitHCIt++) {
      brb::BeamlineDigit in_this_channel;
      //in_this_channel.SetChannelID((digitHCIt->second).DigitizerChannel);
      in_this_channel.SetChannelID((*digitIt)->ChannelID());
      in_this_channel.SetStartTimeInNanoSec((digitHCIt->second).TStartInNanoSec);
      in_this_channel.SetPeakTimeInNanoSec((digitHCIt->second).TPeakInNanoSec);
      in_this_channel.SetEndTimeInNanoSec((digitHCIt->second).TStartInNanoSec + (digitHCIt->second).RiseTimeInNanoSec + (digitHCIt->second).FallTimeInNanoSec);
      in_this_channel.SetPeakADC((digitHCIt->second).AmplitudeInADC);

      digit_reco->push_back(in_this_channel);

      // make assn between the reconstructed and raw digits
      util::CreateAssn(*this, e, *(digit_reco.get()), *digitIt, *(digit_assn.get()), digit_reco->size()-1);
    }
  }

  e.put(std::move(digit_reco));
  e.put(std::move(digit_assn));
}

DEFINE_ART_MODULE(beamlinereco::LEHitReco)