caldata::FFTTest Class Reference

Inheritance diagram for caldata::FFTTest:

Public Member Functions
	FFTTest (fhicl::ParameterSet const &pset)
virtual	~FFTTest ()
void	analyze (const art::Event &evt)
Public Member Functions inherited from art::EDAnalyzer
	EDAnalyzer (fhicl::ParameterSet const &pset)
template<typename Config >
	EDAnalyzer (Table< Config > const &config)
std::string	workerType () const
Public Member Functions inherited from art::detail::Analyzer
virtual	~Analyzer () noexcept
	Analyzer (fhicl::ParameterSet const &pset)
template<typename Config >
	Analyzer (Table< Config > const &config)
void	doBeginJob (SharedResources const &resources)
void	doEndJob ()
void	doRespondToOpenInputFile (FileBlock const &fb)
void	doRespondToCloseInputFile (FileBlock const &fb)
void	doRespondToOpenOutputFiles (FileBlock const &fb)
void	doRespondToCloseOutputFiles (FileBlock const &fb)
bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)
bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)
bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)
Public Member Functions inherited from art::Observer
	~Observer () noexcept
	Observer (Observer const &)=delete
	Observer (Observer &&)=delete
Observer &	operator= (Observer const &)=delete
Observer &	operator= (Observer &&)=delete
void	registerProducts (ProductDescriptions &, ModuleDescription const &)
void	fillDescriptions (ModuleDescription const &)
fhicl::ParameterSetID	selectorConfig () const
Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept
	ModuleBase ()
ModuleDescription const &	moduleDescription () const
void	setModuleDescription (ModuleDescription const &)
std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const
void	sortConsumables (std::string const &current_process_name)
template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)
template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Attributes
std::string	fSimFile
std::string	fCalFile
int	fNTicks
std::vector< double >	fSimElect
std::vector< double >	fSimColField
std::vector< double >	fSimIndField
std::vector< double >	fSimColConv
std::vector< double >	fSimIndConv
std::vector< TComplex >	fSimElectF
std::vector< TComplex >	fSimColFieldF
std::vector< TComplex >	fSimIndFieldF
std::vector< TComplex >	fSimColConvF
std::vector< TComplex >	fSimIndConvF
std::vector< TComplex >	fColDeconvF
std::vector< TComplex >	fIndDeconvF

Additional Inherited Members
Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >
using	ModuleType = EDAnalyzer
Protected Member Functions inherited from art::Observer
std::string const &	processName () const
bool	wantAllEvents () const noexcept
bool	wantEvent (ScheduleID id, Event const &e) const
Handle< TriggerResults >	getTriggerResults (Event const &e) const
	Observer (fhicl::ParameterSet const &config)
	Observer (std::vector< std::string > const &select_paths, std::vector< std::string > const &reject_paths, fhicl::ParameterSet const &config)
Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()
template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)
template<typename T , BranchType = InEvent>
void	consumesMany ()
template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)
template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Definition at line 67 of file FFTTest_module.cc.

Constructor & Destructor Documentation

caldata::FFTTest::FFTTest ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 109 of file FFTTest_module.cc.

  : EDAnalyzer(pset)
  {
    // Get file service.

    art::ServiceHandle<art::TFileService> tfs;

    // Get FFT service.

    art::ServiceHandle<util::LArFFT> fFFT;
    fNTicks = fFFT->FFTSize();
    std::cout << "Number of ticks = " << fNTicks << std::endl;

    // Get simulation (convolution) response functions.

    fSimFile = pset.get<std::string>("simwire_file");
    std::cout << "SimWire file = " << fSimFile << std::endl;

    TFile fsim(fSimFile.c_str());

    TH1D* hSimElect = dynamic_cast<TH1D*>(fsim.Get("daq/ElectronicsResponse"));
    hist_to_vector(hSimElect, fSimElect);
    fSimElect.resize(fNTicks, 0.);
    fSimElectF.resize(fNTicks/2+1);
    fFFT->DoFFT(fSimElect, fSimElectF);

    TH1D* hSimColField = dynamic_cast<TH1D*>(fsim.Get("daq/CollectionFieldResponse"));
    hist_to_vector(hSimColField, fSimColField);
    fSimColField.resize(fNTicks, 0.);
    fSimColFieldF.resize(fNTicks/2+1);
    fFFT->DoFFT(fSimColField, fSimColFieldF);

    TH1D* hSimIndField = dynamic_cast<TH1D*>(fsim.Get("daq/InductionFieldResponse"));
    hist_to_vector(hSimIndField, fSimIndField);
    fSimIndField.resize(fNTicks, 0.);
    fSimIndFieldF.resize(fNTicks/2+1);
    fFFT->DoFFT(fSimIndField, fSimIndFieldF);

    TH1D* hSimColConv = dynamic_cast<TH1D*>(fsim.Get("daq/ConvolutedCollection"));
    hist_to_vector(hSimColConv, fSimColConv);
    fSimColConv.resize(fNTicks, 0.);
    fSimColConvF.resize(fNTicks/2+1);
    fFFT->DoFFT(fSimColConv, fSimColConvF);

    TH1D* hSimIndConv = dynamic_cast<TH1D*>(fsim.Get("daq/ConvolutedInduction"));
    hist_to_vector(hSimIndConv, fSimIndConv);
    fSimIndConv.resize(fNTicks, 0.);
    fSimIndConvF.resize(fNTicks/2+1);
    fFFT->DoFFT(fSimIndConv, fSimIndConvF);

    // Get reco (deconvolution) response function.

    fhicl::ParameterSet calwire_pset = pset.get<fhicl::ParameterSet>("calwire");
    cet::search_path sp("FW_SEARCH_PATH");
    sp.find_file(calwire_pset.get<std::string>("ResponseFile"), fCalFile);
    std::cout << "CalWire file = " << fCalFile << std::endl;

    TFile fcal(fCalFile.c_str());

    TH2D* respRe = dynamic_cast<TH2D*>(fcal.Get("sim/RespRe"));
    TH2D* respIm = dynamic_cast<TH2D*>(fcal.Get("sim/RespIm"));
    int nx = respRe->GetNbinsX();
    int ny = respRe->GetNbinsY();
    assert(nx == respIm->GetNbinsX());
    assert(ny == respIm->GetNbinsY());
    assert(nx == 2);   // 1=induction, 2=collection.

    fColDeconvF.resize(ny);
    fIndDeconvF.resize(ny);

    for(int i=0; i<ny; ++i) {
      double ac = respRe->GetBinContent(2, i+1);
      double bc = respIm->GetBinContent(2, i+1);
      TComplex zc(ac, bc);
      fColDeconvF[i] = zc;

      double ai = respRe->GetBinContent(1, i+1);
      double bi = respIm->GetBinContent(1, i+1);
      TComplex zi(ai, bi);
      fIndDeconvF[i] = zi;
    }

    // Calculate response of delta function to collection field + electronics.

    art::TFileDirectory dirc = tfs->mkdir("Collection", "Collection");
    int nhist = std::min(200, fNTicks);

    // Input signal (delta function).

    std::vector<double> tinc(fNTicks, 0.);
    fill_delta(tinc, nhist/2);
    TH1D* hinc = dirc.make<TH1D>("input", "Collection Input", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tinc, hinc);

    // Electronics response.

    std::vector<double> telectc(tinc);
    fFFT->Convolute(telectc, fSimElectF);
    TH1D* helectc = dirc.make<TH1D>("elect", "Collection Electronics", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(telectc, helectc);

    // Field response.

    std::vector<double> tfieldc(tinc);
    fill_delta(tfieldc, nhist/2);
    fFFT->Convolute(tfieldc, fSimColFieldF);
    TH1D* hfieldc = dirc.make<TH1D>("field", "Collection Field", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tfieldc, hfieldc);

    // Convolution of electronics and field response.

    std::vector<double> tbothc(tfieldc);
    fFFT->Convolute(tbothc, fSimElectF);
    TH1D* hbothc = dirc.make<TH1D>("both", "Collection Field+Electronics", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tbothc, hbothc);

    // Shifted convolution of electronics and field response.

    double shift = fFFT->PeakCorrelation(tbothc, tinc);
    std::cout << "Collection shift = " << shift << std::endl;
    std::vector<double> tshiftc(tbothc);
    fFFT->ShiftData(tshiftc, shift);
    TH1D* hshiftc = dirc.make<TH1D>("shift", "Collection Field+Electronics+Shift", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tshiftc, hshiftc);

    // Convolution response function read from file.

    std::vector<double> tconvc(tinc);
    fFFT->Convolute(tconvc, fSimColConvF);
    TH1D* hconvc = dirc.make<TH1D>("conv", "Collection Response", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tconvc, hconvc);

    // Deconvolution.

    std::vector<double> tdeconvc(tconvc);
    fFFT->Convolute(tdeconvc, fColDeconvF);
    TH1D* hdeconvc = dirc.make<TH1D>("deconv", "Collection Deconvoluted", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tdeconvc, hdeconvc);

    // Calculate response of delta function to induction field + electronics.

    art::TFileDirectory diri = tfs->mkdir("Induction", "Induction");

    // Input signal (delta function).

    std::vector<double> tini(fNTicks, 0.);
    fill_delta(tini, nhist/2);
    TH1D* hini = diri.make<TH1D>("input", "Induction Input", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tini, hini);

    // Electronics response.

    std::vector<double> telecti(tini);
    fFFT->Convolute(telecti, fSimElectF);
    TH1D* helecti = diri.make<TH1D>("elect", "Induction Electronics", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(telecti, helecti);

    // Field response.

    std::vector<double> tfieldi(tini);
    fFFT->Convolute(tfieldi, fSimIndFieldF);
    TH1D* hfieldi = diri.make<TH1D>("field", "Induction Field", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tfieldi, hfieldi);

    // Convolution of electronics and field response.

    std::vector<double> tbothi(tfieldi);
    fFFT->Convolute(tbothi, fSimElectF);
    TH1D* hbothi = diri.make<TH1D>("both", "Induction Field+Electronics", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tbothi, hbothi);

    // Shifted convolution of electronics and field response.

    shift = fFFT->PeakCorrelation(tbothi, tini);
    std::cout << "Induction shift = " << shift << std::endl;
    std::vector<double> tshifti(tbothi);
    fFFT->ShiftData(tshifti, shift);
    TH1D* hshifti = diri.make<TH1D>("shift", "Induction Field+Electronics+Shift", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tshifti, hshifti);

    // Convolution response function read from file.

    std::vector<double> tconvi(tini);
    fFFT->Convolute(tconvi, fSimIndConvF);
    TH1D* hconvi = diri.make<TH1D>("conv", "Induction Response", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tconvi, hconvi);

    // Deconvolution.

    std::vector<double> tdeconvi(tconvi);
    fFFT->Convolute(tdeconvi, fIndDeconvF);
    TH1D* hdeconvi = diri.make<TH1D>("deconv", "Induction Deconvoluted", nhist+1, -0.5, nhist+0.5);
    vector_to_hist(tdeconvi, hdeconvi);
  }

caldata::FFTTest::~FFTTest ( )

virtual

Definition at line 304 of file FFTTest_module.cc.

  {}

Member Function Documentation

void caldata::FFTTest::analyze

(

const art::Event &

evt

)

Definition at line 307 of file FFTTest_module.cc.

 {}

Member Data Documentation

std::string caldata::FFTTest::fCalFile

private

Definition at line 85 of file FFTTest_module.cc.

std::vector<TComplex> caldata::FFTTest::fColDeconvF

private

Definition at line 103 of file FFTTest_module.cc.

std::vector<TComplex> caldata::FFTTest::fIndDeconvF

private

Definition at line 104 of file FFTTest_module.cc.

int caldata::FFTTest::fNTicks

private

Definition at line 86 of file FFTTest_module.cc.

std::vector<double> caldata::FFTTest::fSimColConv

private

Definition at line 93 of file FFTTest_module.cc.

std::vector<TComplex> caldata::FFTTest::fSimColConvF

private

Definition at line 101 of file FFTTest_module.cc.

std::vector<double> caldata::FFTTest::fSimColField

private

Definition at line 91 of file FFTTest_module.cc.

std::vector<TComplex> caldata::FFTTest::fSimColFieldF

private

Definition at line 99 of file FFTTest_module.cc.

std::vector<double> caldata::FFTTest::fSimElect

private

Definition at line 90 of file FFTTest_module.cc.

std::vector<TComplex> caldata::FFTTest::fSimElectF

private

Definition at line 98 of file FFTTest_module.cc.

std::string caldata::FFTTest::fSimFile

private

Definition at line 84 of file FFTTest_module.cc.

std::vector<double> caldata::FFTTest::fSimIndConv

private

Definition at line 94 of file FFTTest_module.cc.

std::vector<TComplex> caldata::FFTTest::fSimIndConvF

private

Definition at line 102 of file FFTTest_module.cc.

std::vector<double> caldata::FFTTest::fSimIndField

private

Definition at line 92 of file FFTTest_module.cc.

std::vector<TComplex> caldata::FFTTest::fSimIndFieldF

private

Definition at line 100 of file FFTTest_module.cc.

---

The documentation for this class was generated from the following file:

• larevt/larevt/CalData/test/FFTTest_module.cc