icarus_tool::SBNDataNoise Class Reference

Inheritance diagram for icarus_tool::SBNDataNoise:

Public Member Functions
	SBNDataNoise (const fhicl::ParameterSet &pset)
	~SBNDataNoise ()
void	configure (const fhicl::ParameterSet &pset) override
void	nextEvent () override
void	generateNoise (CLHEP::HepRandomEngine &noise_engine, CLHEP::HepRandomEngine &cornoise_engine, icarusutil::TimeVec &noise, detinfo::DetectorPropertiesData const &, double noise_factor, const geo::PlaneID &, unsigned int board) override

Private Types
using	CorrFactorsMap = std::map< unsigned int, std::vector< float >>
using	WaveformTools = icarus_signal_processing::WaveformTools< icarusutil::SigProcPrecision >

Private Member Functions
void	GenerateCorrelatedNoise (CLHEP::HepRandomEngine &, icarusutil::TimeVec &, double, unsigned int, unsigned int)
void	GenerateUncorrelatedNoise (CLHEP::HepRandomEngine &, icarusutil::TimeVec &, double, unsigned int)
void	GenNoise (std::function< void(double[])> &, const icarusutil::TimeVec &, icarusutil::TimeVec &, float)
void	ComputeRMSs ()
void	makeHistograms ()
void	SampleCorrelatedRMSs ()
void	ExtractUncorrelatedRMS (float &, int) const
Private Member Functions inherited from icarus_tool::IGenNoise
virtual	~IGenNoise () noexcept=default

Private Attributes
size_t	fPlane
int	fMedianNumBins
float	fNoiseRand
long	fCorrelatedSeed
long	fUncorrelatedSeed
std::vector< float >	fIncoherentNoiseFrac
bool	fStoreHistograms
std::vector< std::string >	fInputNoiseHistFileName
std::string	fHistogramName
std::string	fCorrelatedHistogramName
std::string	fUncorrelatedHistogramName
std::string	fCorrelatedRMSHistoName
std::string	fUncorrelatedRMSHistoName
std::string	fTotalRMSHistoName
CorrFactorsMap	fCorrFactorsMap
WaveformTools	fWaveformTool
std::vector< icarusutil::TimeVec >	fCoherentNoiseVec
std::vector< icarusutil::TimeVec >	fIncoherentNoiseVec
Noise::ICoherentNoiseFactor *	fCoherentNoiseService
double	fIncoherentNoiseRMS
double	fCoherentNoiseRMS
icarusutil::FrequencyVec	fNoiseFrequencyVec
bool	fNeedFirstSeed =true
TProfile *	fInputNoiseHist
TH1D *	fMediaNoiseHist
TProfile *	fPeakNoiseHist
std::vector< TH1D * >	corrRMSHistPtr
std::vector< TH1D * >	uncorrRMSHistPtr
std::vector< TH1D * >	totalRMSHistPtr
std::vector< float >	totalRMS
std::vector< float >	rmsUnc
std::vector< float >	rmsCorr
Eigen::FFT< double >	fEigenFFT

Detailed Description

Definition at line 43 of file SBNDataNoise_tool.cc.

Member Typedef Documentation

using icarus_tool::SBNDataNoise::CorrFactorsMap = std::map<unsigned int, std::vector<float>>

private

Definition at line 87 of file SBNDataNoise_tool.cc.

using icarus_tool::SBNDataNoise::WaveformTools = icarus_signal_processing::WaveformTools<icarusutil::SigProcPrecision>

private

Definition at line 91 of file SBNDataNoise_tool.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 130 of file SBNDataNoise_tool.cc.

{
    // Recover the configuration of the tool from the input fhicl file and set up
    configure(pset);
    ComputeRMSs();
    
    // Output some histograms to catalogue what's been done
    makeHistograms();
}

icarus_tool::SBNDataNoise::~SBNDataNoise

(

)

Definition at line 140 of file SBNDataNoise_tool.cc.

{
}

Member Function Documentation

void icarus_tool::SBNDataNoise::ComputeRMSs ( )

private

Definition at line 439 of file SBNDataNoise_tool.cc.

{
    // Let's get the rms we expect from the incoherent noise contribution to the waveform
    // A couple of ways to do this, let's basically invert the frequency spectrum to
    // produce a waveform and then get the rms from that
    std::function<void (double[])> randGenFunc = [](double randArray[]){randArray[0]=0.5; randArray[1]=0.5;};
    
    icarusutil::TimeVec waveNoise(fIncoherentNoiseVec.back().size());
    //float              scaleFactor = 1.;
    
  //  GenNoise(randGenFunc, fIncoherentNoiseVec, waveNoise, scaleFactor);
    
    // Now get the details...
    double nSig(3.);
    double mean,rmsTrunc;
    int    nTrunc;
    int    range;
    
    // Use the waveform tool to recover the full rms
    fWaveformTool.getTruncatedMeanRMS(waveNoise, nSig, mean, fIncoherentNoiseRMS, rmsTrunc, nTrunc, range);
    
    // Do the same for the coherent term
  //  GenNoise(randGenFunc, fCoherentNoiseVec, waveNoise, scaleFactor);
    
    fWaveformTool.getTruncatedMeanRMS(waveNoise, nSig, mean, fCoherentNoiseRMS, rmsTrunc, nTrunc, range);

for(unsigned int jh=0;jh<totalRMSHistPtr.size();jh++) {
 totalRMS.push_back(totalRMSHistPtr[jh]->GetMean());
 rmsUnc.push_back(uncorrRMSHistPtr[jh]->GetMean());
rmsCorr.push_back(corrRMSHistPtr[jh]->GetMean());
fIncoherentNoiseFrac.push_back(rmsUnc.back()/totalRMS.back());
//TEMPORARY!
//fIncoherentNoiseFrac[jh]=0;
std::cout <<  " index " <<jh << "  totalRMS " << totalRMS.back() << std::endl;
std::cout <<   " index " <<jh <<" uncRMS " << rmsUnc.back() << std::endl;
std::cout <<   " index " <<jh <<"  corrRMS " << rmsCorr.back() << std::endl;
}
    return;
}

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

overridevirtual

Implements icarus_tool::IGenNoise.

Definition at line 144 of file SBNDataNoise_tool.cc.

{
    // Recover the histogram used for noise generation
    fPlane                     = pset.get< size_t      >("Plane");
    fMedianNumBins             = pset.get< int         >("MedianNumBins");
    fNoiseRand                 = pset.get< float       >("NoiseRand");
    fCorrelatedSeed            = pset.get< long        >("CorrelatedSeed",1000);
    fUncorrelatedSeed          = pset.get< long        >("UncorrelatedSeed",5000);
 std::vector<float> noiseFracVec = pset.get< std::vector<float> >("IncoherentNoiseFraction", std::vector<float>());
 for(auto& noiseFrac : noiseFracVec) {
        fIncoherentNoiseFrac.push_back(float(noiseFrac));
    }
   // fIncoherentNoiseFrac       = pset.get< float       >("IncoherentNoiseFraction",0.5);
    fStoreHistograms           = pset.get< bool        >("StoreHistograms");

    std::vector<std::string> noiseToolParamSetVec = pset.get< std::vector<std::string> >("NoiseHistFileName", std::vector<std::string>());
   for(auto& noiseToolParams : noiseToolParamSetVec) {
        fInputNoiseHistFileName.push_back(std::string(noiseToolParams));
    }
 //   fInputNoiseHistFileName    = pset.get< std::string >("NoiseHistFileName");
    fCorrelatedHistogramName   = pset.get< std::string >("CorrelatedHistogramName");
    fUncorrelatedHistogramName = pset.get< std::string >("UncorrelatedHistogramName");
    fCorrelatedRMSHistoName    = pset.get< std::string >("CorrelatedRMSHistoName");
    fUncorrelatedRMSHistoName  = pset.get< std::string >("UncorrelatedRMSHistoName");
    fTotalRMSHistoName         = pset.get< std::string >("TotalRMSHistoName");
    // Initialize the work vector
    auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
    auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob(clockData);
    fNoiseFrequencyVec.resize(detProp.NumberTimeSamples(),std::complex<float>(0.,0.));

for(auto& filename : fInputNoiseHistFileName) {
    // Set up to input the histogram with the overall noise spectrum
    std::string fullFileName;

    cet::search_path searchPath("FW_SEARCH_PATH");

    searchPath.find_file(filename, fullFileName);
std::cout << " inputfilename;" << filename << std::endl;
    std::cout << " fullfilename;" << fullFileName << std::endl;
  std::cout << "correlated histo name: " << fCorrelatedHistogramName << std::endl;
std::cout << "uncorrelated histo name: " << fUncorrelatedHistogramName << std::endl;
    TFile inputFile(fullFileName.c_str(), "READ");
    
    if (!inputFile.IsOpen())
        throw cet::exception("NoiseFromHist::configure") << "Unable to open input file: " << filename << std::endl;
    
    TH1D* corrHistPtr = (TH1D*)inputFile.Get(fCorrelatedHistogramName.c_str());    
    if (!corrHistPtr)
        throw cet::exception("NoiseFromHist::configure") << "Unable to recover desired histogram: " << fCorrelatedHistogramName << std::endl;

  TH1D* uncorrHistPtr = (TH1D*)inputFile.Get(fUncorrelatedHistogramName.c_str());    
    if (!inputFile.Get(fUncorrelatedHistogramName.c_str()))
        throw cet::exception("NoiseFromHist::configure") << "Unable to recover desired histogram: " << fUncorrelatedHistogramName << std::endl;

    corrRMSHistPtr.push_back((TH1D*)inputFile.Get(fCorrelatedRMSHistoName.c_str()));  
    if (!inputFile.Get(fCorrelatedRMSHistoName.c_str()))
        throw cet::exception("NoiseFromHist::configure") << "Unable to recover desired histogram: " << fCorrelatedRMSHistoName << std::endl;

  uncorrRMSHistPtr.push_back((TH1D*)inputFile.Get(fUncorrelatedRMSHistoName.c_str()));  
    if (!inputFile.Get(fUncorrelatedRMSHistoName.c_str()))
        throw cet::exception("NoiseFromHist::configure") << "Unable to recover desired histogram: " << fUncorrelatedRMSHistoName << std::endl;

 totalRMSHistPtr.push_back((TH1D*)inputFile.Get(fTotalRMSHistoName.c_str()));  
    if (!inputFile.Get(fTotalRMSHistoName.c_str()))
        throw cet::exception("NoiseFromHist::configure") << "Unable to recover desired histogram: " << fTotalRMSHistoName << std::endl;

    // Close the input file
    inputFile.Close();

std::cout << " corr hist nbins " << corrHistPtr->GetNbinsX() << std::endl;
std::cout << " uncorr hist  nbins " << uncorrHistPtr->GetNbinsX() << std::endl;
icarusutil::TimeVec corvec;
    corvec.resize(corrHistPtr->GetNbinsX(), 0.);
    
    // Recover the bin contents into local vectors
    for(size_t histIdx = 0; histIdx < size_t(corrHistPtr->GetNbinsX()); histIdx++)
        corvec[histIdx] = corrHistPtr->GetBinContent(histIdx+1);
fCoherentNoiseVec.push_back(corvec);
icarusutil::TimeVec incvec;
incvec.resize(uncorrHistPtr->GetNbinsX(), 0.);
    
    // Recover the bin contents into local vectors
    for(size_t histIdx = 0; histIdx < size_t(uncorrHistPtr->GetNbinsX()); histIdx++)
        incvec[histIdx] = uncorrHistPtr->GetBinContent(histIdx+1);
fIncoherentNoiseVec.push_back(incvec);
    // Should we store hists?

}
std::cout << " after filling vectors " << std::endl;
    if (fStoreHistograms)
    {
        // Define histograms
        art::ServiceHandle<art::TFileService> tfs;
    
        art::TFileDirectory* histDirectory = tfs.get();
        
        // Make a directory for these histograms
        art::TFileDirectory dir = histDirectory->mkdir(Form("CorNoisePlane%1zu",fPlane));
        
        float sampleRate  = sampling_rate(clockData);
        float readOutSize = detProp.ReadOutWindowSize();
        float maxFreq     = 1.e6 / (2. * sampleRate);
        float minFreq     = 1.e6 / (2. * sampleRate * readOutSize);
        int   numSamples  = readOutSize / 2;
        
        fInputNoiseHist   = dir.make<TProfile>("InNoise",   ";freq(kHz)", numSamples, minFreq, maxFreq);
        fMediaNoiseHist  = dir.make<TH1D>("MedNoise",  ";ADC", 100, -10., -10.);;
        fPeakNoiseHist    = dir.make<TProfile>("PeakNoise", ";freq(kHz)", numSamples, minFreq, maxFreq);;
        
    }

    // Set up the board->correlated factors map
    const auto& channelMap = art::ServiceHandle<icarusDB::IICARUSChannelMap const>{}.get();

    const icarusDB::TPCReadoutBoardToChannelMap& readoutBoardToChannelMap = channelMap->getReadoutBoardToChannelMap();

    for(const auto& boardPair : readoutBoardToChannelMap)
    {
        fCorrFactorsMap.insert({boardPair.first,std::vector<float>(4,0.)});
    }

    fCoherentNoiseService = art::ServiceHandle<Noise::ICoherentNoiseFactor>{}.get();

    SampleCorrelatedRMSs();

    return;
}

void icarus_tool::SBNDataNoise::ExtractUncorrelatedRMS ( float &  cf, int  index  ) const

private

Definition at line 497 of file SBNDataNoise_tool.cc.

{
TH1D* histo=uncorrRMSHistPtr[index];


float rndRMS=histo->GetRandom();
float meanRMS=histo->GetMean();
cf=rndRMS/meanRMS; 
//corrFactor=10;
//if(fPlane==1) std::cout << " rndRMS " << rndRMS << " meanRMS " << meanRMS << " corrFactor " << corrFactor << std::endl;
}

void icarus_tool::SBNDataNoise::GenerateCorrelatedNoise ( CLHEP::HepRandomEngine &  engine, icarusutil::TimeVec &  noise, double  noise_factor, unsigned int  board, unsigned int  index  )

private

Definition at line 386 of file SBNDataNoise_tool.cc.

{    
   
        // Set the engine seed to the board being considered
        engine.setSeed(fCorrelatedSeed+board,0);
        
        CLHEP::RandFlat noiseGen(engine,0,1);
        
        std::function<void (double[])> randGenFunc = [&noiseGen](double randArray[]){noiseGen.fireArray(2,randArray);};
    

        float scaleFactor = noise_factor;
    //      std::cout << " fraction " << fraction << " corr scale Factor " << scaleFactor << std::endl;
        GenNoise(randGenFunc, fCoherentNoiseVec[index], noise, scaleFactor);
    
    
    return;
}

void icarus_tool::SBNDataNoise::generateNoise ( CLHEP::HepRandomEngine &  noise_engine, CLHEP::HepRandomEngine &  cornoise_engine, icarusutil::TimeVec &  noise, detinfo::DetectorPropertiesData const &  , double  noise_factor, const geo::PlaneID &  planeID, unsigned int  board  )

overridevirtual

Implements icarus_tool::IGenNoise.

Definition at line 280 of file SBNDataNoise_tool.cc.

{
//std::cout << " generating noise channel " << channel << std::endl;
   //GET THE GEOMETRY.
//    art::ServiceHandle<geo::Geometry> geom;
    // get the WireID for this hit
//          std::vector<geo::WireID> wids = geom->ChannelToWire(channel);
          // for now, just take the first option returned from ChannelToWire
//          geo::WireID wid  = wids[0];
          // We need to know the plane to look up parameters
         
          size_t cryostat=planeID.Cryostat;
          size_t tpc=planeID.TPC;
//          size_t iWire=wid.Wire;
//std::cout << " generating noise cryostat " << cryostat << " tpc " << tpc << " wire " << iWire << std::endl;
int index=-1;
if(cryostat==0&&tpc<2) index=0;
if(cryostat==0&&tpc>1) index=1;
if(cryostat==1&&tpc<2) index=2;
if(cryostat==1&&tpc>1) index=3;

//std::cout << " index " << index << std::endl;
//std::cout << " totalrms size " << totalRMS.size() << std::endl;

//  noise_factor=1;  ****** not sure why this was done? 
//noise_factor=totalRMS[index]/3.9;

//std::cout <<  " index " << index << " generating noise totalRMS " << totalRMS[index] << std::endl;
    // Define a couple of vectors to hold intermediate work
    icarusutil::TimeVec noise_unc(noise.size(),0.);
    icarusutil::TimeVec noise_corr(noise.size(),0.);
    
    // Make sure the work vector is size right with the output
    if (fNoiseFrequencyVec.size() != noise.size()) fNoiseFrequencyVec.resize(noise.size(),std::complex<float>(0.,0.));
    //std::cout <<  " generating uncorrelated noise " << std::endl;
    // If applying incoherent noise call the generator
   GenerateUncorrelatedNoise(engine_unc,noise_unc,noise_factor,index);  
//int board=iWire/32;


//float cf=corrFactors[board][index];

CorrFactorsMap::const_iterator corrFactorItr = fCorrFactorsMap.find(board);

if (corrFactorItr == fCorrFactorsMap.end()) std::cout << "********************** board " << board << " not found in map!" << std::endl;

//float cf = fCorrFactorsMap[board][index];

float cf = fCoherentNoiseService->getCoherentNoiseFactor(board,index);


   GenerateCorrelatedNoise(engine_corr, noise_corr, noise_factor*cf, board, index);

   // std::cout <<  " summing noise " << std::endl;
    // Take the noise as the simple sum of the two contributions
    std::transform(noise_unc.begin(),noise_unc.end(),noise_corr.begin(),noise.begin(),std::plus<float>());
    
 float mediaNoise=0;
 for(unsigned int jn=0;jn<noise.size();jn++) {
//if(!cryostat&&!tpc&&!fPlane&&iWire<2) 
//{
//std::cout << " jn " << jn << " noise sum " << noise.at(jn) << std::endl; 
//std::cout << " jn " << jn << " noise unc " << noise_unc.at(jn) << std::endl; 
//std::cout << " jn " << jn << " noise corr " << noise_corr.at(jn) << std::endl; 
//}
  mediaNoise+=noise.at(jn);
}

mediaNoise/=(noise.size());
//std::cout << " media noise size " << noise.size() << std::endl;
fMediaNoiseHist->Fill(mediaNoise);
//std::cout << " media noise " << mediaNoise << std::endl;

    return;
}

void icarus_tool::SBNDataNoise::GenerateUncorrelatedNoise ( CLHEP::HepRandomEngine &  engine, icarusutil::TimeVec &  noise, double  noise_factor, unsigned int  index  )

private

Definition at line 362 of file SBNDataNoise_tool.cc.

{
    // Here we aim to produce a waveform consisting of incoherent noise
    // Note that this is expected to be the dominate noise contribution
    // Check for seed initialization
    if (fNeedFirstSeed)
    {
        engine.setSeed(fUncorrelatedSeed,0);
        fNeedFirstSeed = false;
    }
    
    // Get the generator
    CLHEP::RandFlat noiseGen(engine,0,1);
    
    std::function<void (double[])> randGenFunc = [&noiseGen](double randArray[]){noiseGen.fireArray(2,randArray);};
float cf;
ExtractUncorrelatedRMS(cf,index);
    float  scaleFactor = cf*noise_factor;
   //std::cout << " fraction " << fraction <<" unc scale Factor " << scaleFactor << std::endl;
    GenNoise(randGenFunc, fIncoherentNoiseVec[index], noise, scaleFactor);

    return;
}

void icarus_tool::SBNDataNoise::GenNoise ( std::function< void(double[])> &  gen, const icarusutil::TimeVec &  freqDist, icarusutil::TimeVec &  noise, float  scaleFactor  )

private

Definition at line 405 of file SBNDataNoise_tool.cc.

{
    double rnd_corr[2] = {0.,0.};
    
    // Build out the frequency vector
    for(size_t i=0; i< noise.size()/2; ++i)
    {
//std::cout << " i " << i << " freqdist " << freqDist[i] << std::endl;
        // exponential noise spectrum
        gen(rnd_corr);
     // if(i!=10) continue;
        float pval  = freqDist[i] * ((1-fNoiseRand) + 2 * fNoiseRand*rnd_corr[0]) * scaleFactor;
        float phase = rnd_corr[1] * 2. * M_PI;
     //   float pval  = freqDist[i]*scaleFactor ;
      //  float phase = 0;
        std::complex<float> tc(pval*cos(phase),pval*sin(phase));
        
        fNoiseFrequencyVec[i] = tc;
//std::cout << " i " << i << " noise freqvec " << fNoiseFrequencyVec[i] << std::endl; 
    }
    
    // inverse FFT MCSignal
    fEigenFFT.inv(noise, fNoiseFrequencyVec);
//    for(unsigned int jn=0;jn<noise.size();jn++) std::cout << " jn " << jn << " noise sum " << noise.at(jn) << std::endl; 
//exit(22);
    return;
}

void icarus_tool::SBNDataNoise::makeHistograms ( )

private

Definition at line 433 of file SBNDataNoise_tool.cc.

{
    
    return;
}

void icarus_tool::SBNDataNoise::nextEvent ( )

overridevirtual

Implements icarus_tool::IGenNoise.

Definition at line 272 of file SBNDataNoise_tool.cc.

{
    // We update the correlated seed because we want to see different noise event-by-event
    fCorrelatedSeed   = (333 * fCorrelatedSeed) % 900000000;
       SampleCorrelatedRMSs();
    return;
}

void icarus_tool::SBNDataNoise::SampleCorrelatedRMSs ( )

private

Definition at line 478 of file SBNDataNoise_tool.cc.

{
    for(size_t index = 0; index < 4; index++)
    {
        TH1D* noiseHist = corrRMSHistPtr[index];

        float meanVal = noiseHist->GetMean();
    
        for(auto& correction : fCorrFactorsMap)
        {
            float corVal = noiseHist->GetRandom() / meanVal;

            correction.second[index] = corVal;
        }
    
        fCoherentNoiseService->resetCoherentNoiseFactors(noiseHist);
    }
}

Member Data Documentation

std::vector<TH1D*> icarus_tool::SBNDataNoise::corrRMSHistPtr

private

Definition at line 115 of file SBNDataNoise_tool.cc.

double icarus_tool::SBNDataNoise::fCoherentNoiseRMS

private

Definition at line 102 of file SBNDataNoise_tool.cc.

Noise::ICoherentNoiseFactor* icarus_tool::SBNDataNoise::fCoherentNoiseService

private

Definition at line 99 of file SBNDataNoise_tool.cc.

std::vector<icarusutil::TimeVec> icarus_tool::SBNDataNoise::fCoherentNoiseVec

private

Definition at line 97 of file SBNDataNoise_tool.cc.

std::string icarus_tool::SBNDataNoise::fCorrelatedHistogramName

private

Definition at line 81 of file SBNDataNoise_tool.cc.

std::string icarus_tool::SBNDataNoise::fCorrelatedRMSHistoName

private

Definition at line 83 of file SBNDataNoise_tool.cc.

long icarus_tool::SBNDataNoise::fCorrelatedSeed

private

Definition at line 75 of file SBNDataNoise_tool.cc.

CorrFactorsMap icarus_tool::SBNDataNoise::fCorrFactorsMap

private

Definition at line 89 of file SBNDataNoise_tool.cc.

Eigen::FFT<double> icarus_tool::SBNDataNoise::fEigenFFT

private

Definition at line 124 of file SBNDataNoise_tool.cc.

std::string icarus_tool::SBNDataNoise::fHistogramName

private

Definition at line 80 of file SBNDataNoise_tool.cc.

std::vector<float> icarus_tool::SBNDataNoise::fIncoherentNoiseFrac

private

Definition at line 77 of file SBNDataNoise_tool.cc.

double icarus_tool::SBNDataNoise::fIncoherentNoiseRMS

private

Definition at line 101 of file SBNDataNoise_tool.cc.

std::vector<icarusutil::TimeVec> icarus_tool::SBNDataNoise::fIncoherentNoiseVec

private

Definition at line 98 of file SBNDataNoise_tool.cc.

TProfile* icarus_tool::SBNDataNoise::fInputNoiseHist

private

Definition at line 111 of file SBNDataNoise_tool.cc.

std::vector<std::string> icarus_tool::SBNDataNoise::fInputNoiseHistFileName

private

Definition at line 79 of file SBNDataNoise_tool.cc.

int icarus_tool::SBNDataNoise::fMedianNumBins

private

Definition at line 73 of file SBNDataNoise_tool.cc.

TH1D* icarus_tool::SBNDataNoise::fMediaNoiseHist

private

Definition at line 112 of file SBNDataNoise_tool.cc.

bool icarus_tool::SBNDataNoise::fNeedFirstSeed =true

private

Definition at line 108 of file SBNDataNoise_tool.cc.

icarusutil::FrequencyVec icarus_tool::SBNDataNoise::fNoiseFrequencyVec

private

Definition at line 105 of file SBNDataNoise_tool.cc.

float icarus_tool::SBNDataNoise::fNoiseRand

private

Definition at line 74 of file SBNDataNoise_tool.cc.

TProfile* icarus_tool::SBNDataNoise::fPeakNoiseHist

private

Definition at line 113 of file SBNDataNoise_tool.cc.

size_t icarus_tool::SBNDataNoise::fPlane

private

Definition at line 72 of file SBNDataNoise_tool.cc.

bool icarus_tool::SBNDataNoise::fStoreHistograms

private

Definition at line 78 of file SBNDataNoise_tool.cc.

std::string icarus_tool::SBNDataNoise::fTotalRMSHistoName

private

Definition at line 85 of file SBNDataNoise_tool.cc.

std::string icarus_tool::SBNDataNoise::fUncorrelatedHistogramName

private

Definition at line 82 of file SBNDataNoise_tool.cc.

std::string icarus_tool::SBNDataNoise::fUncorrelatedRMSHistoName

private

Definition at line 84 of file SBNDataNoise_tool.cc.

long icarus_tool::SBNDataNoise::fUncorrelatedSeed

private

Definition at line 76 of file SBNDataNoise_tool.cc.

WaveformTools icarus_tool::SBNDataNoise::fWaveformTool

private

Definition at line 93 of file SBNDataNoise_tool.cc.

std::vector<float> icarus_tool::SBNDataNoise::rmsCorr

private

Definition at line 121 of file SBNDataNoise_tool.cc.

std::vector<float> icarus_tool::SBNDataNoise::rmsUnc

private

Definition at line 120 of file SBNDataNoise_tool.cc.

std::vector<float> icarus_tool::SBNDataNoise::totalRMS

private

Definition at line 119 of file SBNDataNoise_tool.cc.

std::vector<TH1D*> icarus_tool::SBNDataNoise::totalRMSHistPtr

private

Definition at line 117 of file SBNDataNoise_tool.cc.

std::vector<TH1D*> icarus_tool::SBNDataNoise::uncorrRMSHistPtr

private

Definition at line 116 of file SBNDataNoise_tool.cc.

---

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

• SBNDataNoise_tool.cc