TOFTimingResolution_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       TOFTimingResolution
// Plugin Type: analyzer (art v2_12_01)
// File:        TOFTimingResolution_module.cc
//
// Generated at Sat Apr  6 11:35:16 2019 by Dung Phan using cetskelgen
// from cetlib version v3_06_00.
////////////////////////////////////////////////////////////////////////

#include "art/Framework/Core/EDAnalyzer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "fhiclcpp/ParameterSet.h"
#include "art/Framework/Principal/Handle.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/CFDHitFinderAlg.h"
#include "RawData/RawBeamline.h"
#include "BeamlineRecoBase/BeamlineDigit.h"
#include "BeamlineRecoBase/BeamlinePID.h"
#include "BeamlineRecoBase/MuonStackTrack.h"
#include "BeamlineRecoBase/ToF.h"
#include "BeamlineRecoBase/WCTrack.h"
#include "BeamlineUtils/BeamlineChannelMap.h"

// ROOT
#include "TH1D.h"
#include "TH2D.h"
#include "TTree.h"

// stl
#include <iostream>

namespace novatb {
  class TOFTimingResolution;
}


class novatb::TOFTimingResolution : public art::EDAnalyzer {
public:
  explicit TOFTimingResolution(fhicl::ParameterSet const & p);
  void     analyze(art::Event const & e) override;
  void     reconfigure(const fhicl::ParameterSet& p);
  void     beginJob() override;
  double*  selectChannel(unsigned int digitizerChannel);

private:
  art::InputTag _ToFInputTag;
  art::InputTag _CherenkovInputTag;
  // art::InputTag _WCInputTag;

  // beamlinereco::CFDHitFinder<double>* cfdHF;
  // std::map<beamlinereco::CFDParams, double> paramSet;

  TTree * tof_tree;
  // double Channel_9[1024];
  // double Channel_8[1024];
  // double Channel_7[1024];
  // double Channel_6[1024];
  double Cherenkov[1024];
  double Paddle_4[1024];
  double Paddle_3[1024];
  double Paddle_2[1024];
  double Paddle_1[1024];

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

};


novatb::TOFTimingResolution::TOFTimingResolution(fhicl::ParameterSet const & p) : EDAnalyzer(p) {
  reconfigure(p);
}

void novatb::TOFTimingResolution::beginJob() {
  art::ServiceHandle<art::TFileService> tfs;
  tof_tree = tfs->make<TTree>("tof_tree", "TOF Tree");
  tof_tree->Branch("Paddle_1",  Paddle_1,  "Paddle_1[1024]/D");
  tof_tree->Branch("Paddle_2",  Paddle_2,  "Paddle_2[1024]/D");
  tof_tree->Branch("Paddle_3",  Paddle_3,  "Paddle_3[1024]/D");
  tof_tree->Branch("Paddle_4",  Paddle_4,  "Paddle_4[1024]/D");
  tof_tree->Branch("Cherenkov", Cherenkov, "Cherenkov[1024]/D");
  // tof_tree->Branch("Channel_6", Channel_6, "Channel_6[1024]/D");
  // tof_tree->Branch("Channel_7", Channel_7, "Channel_7[1024]/D");
  // tof_tree->Branch("Channel_8", Channel_8, "Channel_8[1024]/D");

  // double samplingRateInGSPS = 5;
  //
  // paramSet[beamlinereco::kADCNBits]                                   = 12;
  // paramSet[beamlinereco::kADCDynamicRange]                            = 1;
  // paramSet[beamlinereco::kADCOffset]                                  = 0;
  // paramSet[beamlinereco::kTimeSamplingInterval]                       = 1 / (samplingRateInGSPS);
  // paramSet[beamlinereco::kNSamplingPoints]                            = 1024;
  // paramSet[beamlinereco::kIsWaveformNegativePolarity]                 = 1;
  // paramSet[beamlinereco::kCFDThreshold]                               = 0.4;
  // paramSet[beamlinereco::kRawHitFinderThresholdInNoiseSigma]          = 8;
  // paramSet[beamlinereco::kShortRawHitIgnoringDurationInTicks]         = 10;
  // paramSet[beamlinereco::kConsecutiveHitSeperationDurationInTicks]    = 5;
  // paramSet[beamlinereco::kGSFilter]                                   = 0;
  // paramSet[beamlinereco::kGSFilterWindow]                             = 17;
  // paramSet[beamlinereco::kGSFilterDegree]                             = 3;
  // paramSet[beamlinereco::kIntergratedWindowFixed]                     = 0;
  // paramSet[beamlinereco::kIntergratedWindowLowerLimitIndex]           = 0;
  // paramSet[beamlinereco::kIntergratedWindowUpperLimitIndex]           = 1024;
  //
  // cfdHF = new beamlinereco::CFDHitFinder<double>();
  // cfdHF->SetParams(paramSet);
}

void novatb::TOFTimingResolution::reconfigure(const fhicl::ParameterSet& p) {
  _ToFInputTag       = "daq:ToF";
  _CherenkovInputTag = "daq:Cherenkov";
}

void novatb::TOFTimingResolution::analyze(art::Event const & e) {
  art::Handle<std::vector<rawdata::RawBeamlineDigit> > ToFHandle;
  std::vector<art::Ptr<rawdata::RawBeamlineDigit> > ToFs;
  if (e.getByLabel(_ToFInputTag, ToFHandle)) art::fill_ptr_vector(ToFs, ToFHandle);

  art::Handle<std::vector<rawdata::RawBeamlineDigit> > CherenkovHandle;
  std::vector<art::Ptr<rawdata::RawBeamlineDigit> > Cherenkovs;
  if (e.getByLabel(_CherenkovInputTag, CherenkovHandle)) art::fill_ptr_vector(Cherenkovs, CherenkovHandle);
  
  // art::Handle<std::vector<rawdata::RawBeamlineWC> > WCHandle;
  // std::vector<art::Ptr<rawdata::RawBeamlineWC> > WCs;
  // if (e.getByLabel(_WCInputTag, WCHandle)) art::fill_ptr_vector(WCs, WCHandle);

  for (auto itr = ToFs.begin(); itr != ToFs.end(); itr++) {
    unsigned int channel = fChannelMap->OnlineDigitChannel((*itr)->ChannelID());
    double* chPointer = selectChannel(channel);
    std::vector<uint16_t> waveform = (*itr)->ADCs();

    if (chPointer != NULL) {
      for (unsigned int i = 0; i < 1024; i++) {
        *(chPointer + i) = (double)waveform.at(i);
      }
    }
  }

  for (auto itr = Cherenkovs.begin(); itr != Cherenkovs.end(); itr++) {
    unsigned int channel = fChannelMap->OnlineDigitChannel((*itr)->ChannelID());
    double* chPointer = selectChannel(channel);
    std::vector<uint16_t> waveform = (*itr)->ADCs();

    if (chPointer != NULL) {
      for (unsigned int i = 0; i < 1024; i++) {
        *(chPointer + i) = (double)waveform.at(i);
      }
    }
  }

  tof_tree->Fill();
}

double* novatb::TOFTimingResolution::selectChannel(unsigned int digitizerChannel) {
  double* chPointer;
  switch (digitizerChannel) {
    case (3): {chPointer = &Cherenkov[0]; break;}
    case (4): {chPointer = &Paddle_1[0];  break;}
    case (5): {chPointer = &Paddle_2[0];  break;}
    case (6): {chPointer = &Paddle_3[0];  break;}
    case (7): {chPointer = &Paddle_4[0];  break;}
    // case (5): {chPointer = &Channel_5[0]; break;}
    // case (6): {chPointer = &Channel_6[0]; break;}
    // case (7): {chPointer = &Channel_7[0]; break;}
    // case (8): {chPointer = &Channel_8[0]; break;}
    default: {chPointer = NULL; break;}
  }

  return chPointer;
}


DEFINE_ART_MODULE(novatb::TOFTimingResolution)