Inheritance diagram for icarus_tool::ElectronicsResponse:

Public Member Functions
	ElectronicsResponse (const fhicl::ParameterSet &pset)

	~ElectronicsResponse ()

void	configure (const fhicl::ParameterSet &pset) override

void	setResponse (size_t numBins, double binWidth) override

void	outputHistograms (art::TFileDirectory &) const override

size_t	getPlane () const override

double	getFCperADCMicroS () const override

double	getASICShapingTime () const override

const icarusutil::TimeVec &	getResponseVec () const override

const icarusutil::FrequencyVec &	getResponseFFTVec () const override

Private Attributes
size_t	fPlane

double	fFCperADCMicroS

double	fASICShapingTime

double	fADCPerPCAtLowestASICGain

double	fBinWidth

icarusutil::TimeVec	fElectronicsResponseVec

icarusutil::FrequencyVec	fElectronicsResponseFFTVec

std::unique_ptr < icarus_signal_processing::ICARUSFFT < double > >	fFFT
	Object to handle thread safe FFT. More...

Additional Inherited Members
Private Member Functions inherited from icarus_tool::IElectronicsResponse
virtual	~IElectronicsResponse () noexcept=default

Detailed Description

Definition at line 24 of file ElectronicsResponse_tool.cc.

Constructor & Destructor Documentation

icarus_tool::ElectronicsResponse::ElectronicsResponse ( const fhicl::ParameterSet & pset )

explicit

Definition at line 63 of file ElectronicsResponse_tool.cc.

                                                                       :
     fBinWidth(0.),
     fFFT(nullptr)
 {
     configure(pset);
 }

icarus_tool::ElectronicsResponse::~ElectronicsResponse ( )

inline

Definition at line 29 of file ElectronicsResponse_tool.cc.

29 {}

Member Function Documentation

void icarus_tool::ElectronicsResponse::configure ( const fhicl::ParameterSet & pset )

overridevirtual

Implements icarus_tool::IElectronicsResponse.

Definition at line 70 of file ElectronicsResponse_tool.cc.

 {
     // Start by recovering the parameters
     fPlane                    = pset.get<size_t>("Plane");
     fFCperADCMicroS           = pset.get<double>("FCperADCMicroS");
     fASICShapingTime          = pset.get<double>("ASICShapingTime");
     fADCPerPCAtLowestASICGain = pset.get<double>("ADCPerPCAtLowestASICGain");
     
     return;
 }

double icarus_tool::ElectronicsResponse::getASICShapingTime ( ) const

inlineoverridevirtual

Implements icarus_tool::IElectronicsResponse.

Definition at line 37 of file ElectronicsResponse_tool.cc.

37 {return fASICShapingTime;}

icarus_tool::ElectronicsResponse::fASICShapingTime

double fASICShapingTime

Definition: ElectronicsResponse_tool.cc:45

double icarus_tool::ElectronicsResponse::getFCperADCMicroS ( ) const

inlineoverridevirtual

Implements icarus_tool::IElectronicsResponse.

Definition at line 36 of file ElectronicsResponse_tool.cc.

36 {return fFCperADCMicroS;}

icarus_tool::ElectronicsResponse::fFCperADCMicroS

double fFCperADCMicroS

Definition: ElectronicsResponse_tool.cc:44

size_t icarus_tool::ElectronicsResponse::getPlane ( ) const

inlineoverridevirtual

Implements icarus_tool::IElectronicsResponse.

Definition at line 35 of file ElectronicsResponse_tool.cc.

35 {return fPlane;}

icarus_tool::ElectronicsResponse::fPlane

size_t fPlane

Definition: ElectronicsResponse_tool.cc:43

const icarusutil::FrequencyVec& icarus_tool::ElectronicsResponse::getResponseFFTVec ( ) const

inlineoverridevirtual

Implements icarus_tool::IElectronicsResponse.

Definition at line 39 of file ElectronicsResponse_tool.cc.

39 {return fElectronicsResponseFFTVec;}

icarus_tool::ElectronicsResponse::fElectronicsResponseFFTVec

icarusutil::FrequencyVec fElectronicsResponseFFTVec

Definition: ElectronicsResponse_tool.cc:55

const icarusutil::TimeVec& icarus_tool::ElectronicsResponse::getResponseVec ( ) const

inlineoverridevirtual

Implements icarus_tool::IElectronicsResponse.

Definition at line 38 of file ElectronicsResponse_tool.cc.

38 {return fElectronicsResponseVec;}

icarus_tool::ElectronicsResponse::fElectronicsResponseVec

icarusutil::TimeVec fElectronicsResponseVec

Definition: ElectronicsResponse_tool.cc:52

void icarus_tool::ElectronicsResponse::outputHistograms ( art::TFileDirectory & histDir ) const

overridevirtual

Implements icarus_tool::IElectronicsResponse.

Definition at line 142 of file ElectronicsResponse_tool.cc.

 {
     // It is assumed that the input TFileDirectory has been set up to group histograms into a common
     // folder at the calling routine's level. Here we create one more level of indirection to keep
     // histograms made by this tool separate.
     std::string dirName = "ElectronicsPlane_" + std::to_string(fPlane);
     
     art::TFileDirectory dir = histDir.mkdir(dirName.c_str());
     
     std::string histName = "ElectronicsResponse_" + std::to_string(fPlane);
     
     double hiEdge = fElectronicsResponseVec.size() * fBinWidth;
     
     TProfile* hist = dir.make<TProfile>(histName.c_str(), "Response;Time(us)", fElectronicsResponseVec.size(), 0., hiEdge);
     
     for(size_t idx = 0; idx < fElectronicsResponseVec.size(); idx++) hist->Fill(idx * fBinWidth, fElectronicsResponseVec.at(idx), 1.);
     
     // Get the FFT of the response
     icarusutil::TimeVec powerVec;
     
     fFFT->getFFTPower(fElectronicsResponseVec, powerVec);
     
     // Now we can plot this...
     double maxFreq   = 0.5 / fBinWidth;   // binWidth will be in us, maxFreq will be units of MHz
     double freqWidth = maxFreq / powerVec.size();
     
     histName = "FFT_" + histName;
     
     TProfile* fftHist = dir.make<TProfile>(histName.c_str(), "Electronics FFT; Frequency(MHz)", powerVec.size(), 0., maxFreq);
     
     for(size_t idx = 0; idx < powerVec.size(); idx++)
     {
         float bin = (idx + 0.5) * freqWidth;
         
         fftHist->Fill(bin, powerVec.at(idx), 1.);
     }
 
     return;
 }

void icarus_tool::ElectronicsResponse::setResponse	(	size_t	numBins,
		double	binWidth
	)

overridevirtual

Implements icarus_tool::IElectronicsResponse.

Definition at line 81 of file ElectronicsResponse_tool.cc.

 {
     // The input binWidth is in nanoseconds, we need to convert to microseconds to match the
     // parameters for the electronics response which are given in us
     double timeCorrect  = 1.e-3;
     
     fBinWidth = binWidth * timeCorrect;
     
     fElectronicsResponseVec.resize(numBins, 0.);
 
     // Check that we have initialized our FFT object
     if (!fFFT) fFFT = std::make_unique<icarus_signal_processing::ICARUSFFT<double>>(numBins);
     
     // This note from Filippo:
     // The following sets the ICARUS electronics response function in
     // time-space. Function comes from BNL SPICE simulation of ICARUS
     // electronics. SPICE gives the electronics transfer function in
     // frequency-space. The inverse laplace transform of that function
     // (in time-space) was calculated in Mathematica and is what is being
     // used below. Parameters Ao and To are cumulative gain/timing parameters
     // from the full (ASIC->Intermediate amp->Receiver->ADC) electronics chain.
     // They have been adjusted to make the SPICE simulation to match the
     // actual electronics response. Default params are Ao=1.4, To=0.5us.
     
     for(size_t timeIdx = 0; timeIdx < numBins; timeIdx++)
     {
        double funcArg = double(timeIdx) * fBinWidth / fASICShapingTime;
         
         fElectronicsResponseVec[timeIdx] = funcArg * exp(-funcArg);
     }
     
     // normalize fElectResponse[i], before the convolution
     // Put in overall normalization in a pedantic way:
     // first put in the pulse area per eleectron at the lowest gain setting,
     // then normalize by the actual ASIC gain setting used.
     // This code is executed only during initialization of service,
     // so don't worry about code inefficiencies here.
     //    double last_integral=0;
     //    double last_max=0;
     
     // ICARUS Normalization are the following
     // Field response is normalized to 1 electron. Shaping function written as (t/tau)*exp(-t/tau) is normalized to 1
     // From test pulse measurement with FLIC@CERN we have 0.027 fC/(ADC*us)
     // Therefore 0.027*6242 electrons/(ADC*us)
 
     // The below scales the response by 1./FCperADCMicroS... but this gets taken out in the normalization
     std::transform(fElectronicsResponseVec.begin(),fElectronicsResponseVec.end(),fElectronicsResponseVec.begin(),std::bind(std::divides<double>(),std::placeholders::_1,fFCperADCMicroS));
 
     //double respIntegral = fBinWidth * std::accumulate(fElectronicsResponseVec.begin(),fElectronicsResponseVec.end(),0.);
     double respIntegral = std::accumulate(fElectronicsResponseVec.begin(),fElectronicsResponseVec.end(),0.);
 
     std::transform(fElectronicsResponseVec.begin(),fElectronicsResponseVec.end(),fElectronicsResponseVec.begin(),std::bind(std::divides<double>(),std::placeholders::_1,respIntegral));
     
     // Resize and pad with zeroes
     fElectronicsResponseFFTVec.resize(fElectronicsResponseVec.size(),std::complex<double>(0.,0.));
     
     fFFT->forwardFFT(fElectronicsResponseVec, fElectronicsResponseFFTVec);
 
     return;
 }