SBNDuBooNEDataDrivenNoiseService Class Reference

#include <SBNDuBooNEDataDrivenNoiseService.h>

Inheritance diagram for SBNDuBooNEDataDrivenNoiseService:

Public Member Functions
	SBNDuBooNEDataDrivenNoiseService (fhicl::ParameterSet const &pset)
	SBNDuBooNEDataDrivenNoiseService (fhicl::ParameterSet const &pset, art::ActivityRegistry &)
	~SBNDuBooNEDataDrivenNoiseService ()
int	addNoise (detinfo::DetectorClocksData const &clockData, Channel chan, AdcSignalVector &sigs) const override
void	generateNoise (detinfo::DetectorClocksData const &clockData) override
std::ostream &	print (std::ostream &out=std::cout, std::string prefix="") const override
Public Member Functions inherited from ChannelNoiseService
virtual	~ChannelNoiseService ()=default
virtual void	InitialiseProducerDeps (art::EDProducer *EDProdPointer, fhicl::ParameterSet const &pset)

Private Member Functions
void	generateMicroBooNoise (float wirelength, float ENOB, AdcSignalVector &noise, TH1 *aNoiseHist) const
void	generateGaussianNoise (detinfo::DetectorClocksData const &clockData, AdcSignalVector &noise, std::vector< float > gausNorm, std::vector< float > gausMean, std::vector< float > gausSigma, TH1 *aNoiseHist) const
void	generateCoherentNoise (detinfo::DetectorClocksData const &clockData, AdcSignalVector &noise, std::vector< float > gausNorm, std::vector< float > gausMean, std::vector< float > gausSigma, float cohExpNorm, float cohExpWidth, float cohExpOffset, TH1 *aNoiseHist) const
void	makeCoherentGroupsByOfflineChannel (unsigned int nchpergroup)
unsigned int	getGroupNumberFromOfflineChannel (unsigned int offlinechan) const
unsigned int	getCohNoiseChanFromGroup (unsigned int cohgroup) const
CLHEP::HepRandomEngine *	ConstructRandomEngine (const bool haveSeed)
double	GetRandomTF1 (TF1 *func) const

Private Attributes
std::vector< unsigned int >	fChannelGroupMap
	assign each channel a group number More...
std::vector< int >	fGroupCoherentNoiseMap
	assign each group a noise More...
unsigned int	fNoiseArrayPoints
	number of points in randomly generated noise array More...
int	fRandomSeed
	Seed for random number service. If absent or zero, use SeedSvc. More...
int	fLogLevel
	Log message level: 0=quiet, 1=init only, 2+=every event. More...
bool	fEnableWhiteNoise
float	fWhiteNoiseZ
	Level (per freq bin) for white noise for Z. More...
float	fWhiteNoiseU
	Level (per freq bin) for white noise for U. More...
float	fWhiteNoiseV
	Level (per freq bin) for white noise for V. More...
bool	fEnableGaussianNoise
std::vector< float >	fGausNormU
	noise scale factor for the gaussian component in coherent noise More...
std::vector< float >	fGausMeanU
	mean of the gaussian component in coherent noise More...
std::vector< float >	fGausSigmaU
	sigma of the gaussian component in coherent noise More...
std::vector< float >	fGausNormV
	noise scale factor for the gaussian component in coherent noise More...
std::vector< float >	fGausMeanV
	mean of the gaussian component in coherent noise More...
std::vector< float >	fGausSigmaV
	sigma of the gaussian component in coherent noise More...
std::vector< float >	fGausNormZ
	noise scale factor for the gaussian component in coherent noise More...
std::vector< float >	fGausMeanZ
	mean of the gaussian component in coherent noise More...
std::vector< float >	fGausSigmaZ
	sigma of the gaussian component in coherent noise More...
bool	fEnableMicroBooNoise
	enable MicroBooNE noise model More...
float	fENOB
	Effective number of bits. More...
bool	fIncludeJumpers
	Include jumper term. More...
float	fJumperCapacitance
	Capacitance of jumper cables in pF. Defaults to 0 if not included. More...
float	fUFirstJumper
	Wire number of first wire on U layer to include a jumper cable. Defaults to 0 if not included. More...
float	fULastJumper
	Wire number of last wire on U layer to include a jumper cable. Defaults to 0 if not included. More...
float	fVFirstJumper
	Wire number of first wire on V layer to include a jumper cable. Defaults to 0 if not included. More...
float	fVLastJumper
	Wire number of last wire on V layer to include a jumper cable. Defaults to 0 if not included. More...
std::vector< float >	fNoiseFunctionParameters
	Parameters in the MicroBooNE noise model. More...
bool	fEnableCoherentNoise
std::vector< unsigned int >	fNChannelsPerCoherentGroup
unsigned int	fExpNoiseArrayPoints
	number of points in randomly generated noise array More...
unsigned int	fCohNoiseArrayPoints
	number of points in randomly generated noise array More...
float	fCohExpNorm
	noise scale factor for the exponential component component in coherent noise More...
float	fCohExpWidth
	width of the exponential component in coherent noise More...
float	fCohExpOffset
	Amplitude offset of the exponential background component in coherent noise. More...
std::vector< float >	fCohGausNorm
	noise scale factor for the gaussian component in coherent noise More...
std::vector< float >	fCohGausMean
	mean of the gaussian component in coherent noise More...
std::vector< float >	fCohGausSigma
	sigma of the gaussian component in coherent noise More...
AdcSignalVectorVector	fGausNoiseZ
AdcSignalVectorVector	fGausNoiseU
AdcSignalVectorVector	fGausNoiseV
AdcSignalVectorVector	fMicroBooNoiseZ
AdcSignalVectorVector	fMicroBooNoiseU
AdcSignalVectorVector	fMicroBooNoiseV
AdcSignalVectorVector	fCohNoiseZ
	noise on each channel for each time for all planes More...
AdcSignalVectorVector	fCohNoiseU
	noise on each channel for each time for all planes More...
AdcSignalVectorVector	fCohNoiseV
	noise on each channel for each time for all planes More...
TH1 *	fGausNoiseHistZ
	distribution of noise counts for Z More...
TH1 *	fGausNoiseHistU
	distribution of noise counts for U More...
TH1 *	fGausNoiseHistV
	distribution of noise counts for V More...
TH1 *	fGausNoiseChanHist
	distribution of accessed noise samples More...
TH1 *	fMicroBooNoiseHistZ
	distribution of noise counts for Z More...
TH1 *	fMicroBooNoiseHistU
	distribution of noise counts for U More...
TH1 *	fMicroBooNoiseHistV
	distribution of noise counts for V More...
TH1 *	fMicroBooNoiseChanHist
	distribution of accessed noise samples More...
TH1 *	fCohNoiseHist
	distribution of noise counts More...
TH1 *	fCohNoiseChanHist
	distribution of accessed noise samples More...
TF1 *	_wld_f
double	wldparams [2]
TF1 *	_poisson
bool	haveSeed
CLHEP::HepRandomEngine *	m_pran
TRandom3 *	fTRandom3

Additional Inherited Members
Public Types inherited from ChannelNoiseService
typedef unsigned int	Channel

Detailed Description

Definition at line 50 of file SBNDuBooNEDataDrivenNoiseService.h.

Constructor & Destructor Documentation

SBNDuBooNEDataDrivenNoiseService::SBNDuBooNEDataDrivenNoiseService

(

fhicl::ParameterSet const &

pset

)

Definition at line 25 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

  : fRandomSeed(0), fLogLevel(pset.get<int>("LogLevel")),
  fGausNoiseHistZ(nullptr), fGausNoiseHistU(nullptr), fGausNoiseHistV(nullptr),
  fGausNoiseChanHist(nullptr),
  fMicroBooNoiseHistZ(nullptr), fMicroBooNoiseHistU(nullptr), fMicroBooNoiseHistV(nullptr),
  fMicroBooNoiseChanHist(nullptr),
  fCohNoiseHist(nullptr), fCohNoiseChanHist(nullptr),
  haveSeed(pset.get_if_present<int>("RandomSeed", fRandomSeed)),
  m_pran(ConstructRandomEngine(haveSeed)),
  fTRandom3(new TRandom3(m_pran->getSeed()))
{

  fNoiseArrayPoints  = pset.get<unsigned int>("NoiseArrayPoints");
  
  fEnableWhiteNoise  = pset.get<bool>("EnableWhiteNoise");
  fWhiteNoiseZ       = pset.get<double>("WhiteNoiseZ");
  fWhiteNoiseU       = pset.get<double>("WhiteNoiseU");
  fWhiteNoiseV       = pset.get<double>("WhiteNoiseV");
  
  fEnableGaussianNoise = pset.get<bool>("EnableGaussianNoise");
  fGausNormU     = pset.get<std::vector<float>>("GausNormU");
  fGausMeanU     = pset.get<std::vector<float>>("GausMeanU");
  fGausSigmaU    = pset.get<std::vector<float>>("GausSigmaU");
  fGausNormV     = pset.get<std::vector<float>>("GausNormV");
  fGausMeanV     = pset.get<std::vector<float>>("GausMeanV");
  fGausSigmaV    = pset.get<std::vector<float>>("GausSigmaV");
  fGausNormZ     = pset.get<std::vector<float>>("GausNormZ");
  fGausMeanZ     = pset.get<std::vector<float>>("GausMeanZ");
  fGausSigmaZ    = pset.get<std::vector<float>>("GausSigmaZ");
  
  fEnableMicroBooNoise = pset.get<bool>("EnableMicroBooNoise");
  fENOB                = pset.get<double>("EffectiveNBits");
  fIncludeJumpers      = pset.get<bool>("IncludeJumpers");
  fJumperCapacitance   = pset.get<double>("JumperCapacitance");
  fUFirstJumper        = pset.get<double>("UFirstJumper");
  fULastJumper         = pset.get<double>("ULastJumper");
  fVFirstJumper        = pset.get<double>("VFirstJumper");
  fVLastJumper         = pset.get<double>("VLastJumper");
  fNoiseFunctionParameters   = pset.get<std::vector<float>>("NoiseFunctionParameters");
  
  fEnableCoherentNoise = pset.get<bool>("EnableCoherentNoise");
  fCohNoiseArrayPoints = pset.get<unsigned int>("CohNoiseArrayPoints");
  fCohExpNorm          = pset.get<float>("CohExpNorm");
  fCohExpWidth         = pset.get<float>("CohExpWidth");
  fCohExpOffset        = pset.get<float>("CohExpOffset");
  fCohGausNorm         = pset.get<std::vector<float>>("CohGausNorm");
  fCohGausMean         = pset.get<std::vector<float>>("CohGausMean");
  fCohGausSigma        = pset.get<std::vector<float>>("CohGausSigma");
  fNChannelsPerCoherentGroup      = pset.get<std::vector<unsigned int>>("NChannelsPerCoherentGroup");
  
  art::ServiceHandle<art::TFileService> tfs;
  fMicroBooNoiseHistZ = tfs->make<TH1F>("MicroBoo znoise", ";Z Noise [ADC counts];", 1000,   -10., 10.);
  fMicroBooNoiseHistU = tfs->make<TH1F>("MicroBoo unoise", ";U Noise [ADC counts];", 1000,   -10., 10.);
  fMicroBooNoiseHistV = tfs->make<TH1F>("MicroBoo vnoise", ";V Noise [ADC counts];", 1000,   -10., 10.);
  fMicroBooNoiseChanHist = tfs->make<TH1F>("MicroBoo NoiseChan", ";MicroBoo Noise channel;", fNoiseArrayPoints, 0, fNoiseArrayPoints);
  fGausNoiseHistZ = tfs->make<TH1F>("Gaussian znoise", ";Z Noise [ADC counts];", 1000,   -10., 10.);
  fGausNoiseHistU = tfs->make<TH1F>("Gaussian unoise", ";U Noise [ADC counts];", 1000,   -10., 10.);
  fGausNoiseHistV = tfs->make<TH1F>("Gaussian vnoise", ";V Noise [ADC counts];", 1000,   -10., 10.);
  fGausNoiseChanHist = tfs->make<TH1F>("Gaussian NoiseChan", ";Gaussian Noise channel;", fNoiseArrayPoints, 0, fNoiseArrayPoints);
  fCohNoiseHist = tfs->make<TH1F>("Cohnoise", ";Coherent Noise [ADC counts];", 1000,   -10., 10.);                           
  fCohNoiseChanHist = tfs->make<TH1F>("CohNoiseChan", ";CohNoise channel;", fCohNoiseArrayPoints, 0, fCohNoiseArrayPoints);// III = for each instance of this class.
  
  //generateNoise(); //This has been replaced by the same function in SimWireSBND. This is so the noise arrays are recalculated for each event.

  // Wirelength dependance function
  _wld_f = new TF1("_wld_f", "[0] + [1]*x", 0.0, 1000);
  wldparams[0] = 0.395;
  wldparams[1] = 0.001304;
  _wld_f->SetParameters(wldparams);

  _poisson = new TF1("_poisson", "[0]**(x) * exp(-[0]) / ROOT::Math::tgamma(x+1.)", 0, 30);
  _poisson->SetParameter(0, kPoissonMean); 

  if ( fLogLevel > 1 ) print() << endl;

}

SBNDuBooNEDataDrivenNoiseService::SBNDuBooNEDataDrivenNoiseService	(	fhicl::ParameterSet const &	pset,
		art::ActivityRegistry &
	)

Definition at line 105 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

: SBNDuBooNEDataDrivenNoiseService(pset) { }

SBNDuBooNEDataDrivenNoiseService::~SBNDuBooNEDataDrivenNoiseService

(

)

Definition at line 110 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

                                                                    {
  const string myname = "SBNDuBooNEDataDrivenNoiseService::dtor: ";
  if ( fLogLevel > 0 ) {
    cout << myname << "Deleting random engine with seed " << m_pran->getSeed() << endl;
  }
  delete m_pran;
}

Member Function Documentation

int SBNDuBooNEDataDrivenNoiseService::addNoise ( detinfo::DetectorClocksData const &  clockData, Channel  chan, AdcSignalVector &  sigs  ) const

overridevirtual

This part below has been moved from the generateMicroBooNoise section as it needs to be done differently for SBND due to different wirelengths.

Implements ChannelNoiseService.

Definition at line 149 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

                                                                                                                                    {
  CLHEP::RandFlat flat(*m_pran);
  CLHEP::RandGaussQ gaus(*m_pran);

  unsigned int microbooNoiseChan = flat.fire()*fNoiseArrayPoints;
  if ( microbooNoiseChan == fNoiseArrayPoints ) --microbooNoiseChan;
  fMicroBooNoiseChanHist->Fill(microbooNoiseChan);
  
  unsigned int gausNoiseChan = flat.fire()*fNoiseArrayPoints;
  if ( gausNoiseChan == fNoiseArrayPoints ) --gausNoiseChan;
  fGausNoiseChanHist->Fill(gausNoiseChan);
  
  unsigned int cohNoisechan = -999;
  unsigned int groupNum = -999;
  if ( fEnableCoherentNoise ) {
    groupNum = getGroupNumberFromOfflineChannel(chan);
    cohNoisechan = getCohNoiseChanFromGroup(groupNum);
    if ( cohNoisechan == fCohNoiseArrayPoints ) cohNoisechan = fCohNoiseArrayPoints-1;
    fCohNoiseChanHist->Fill(cohNoisechan);
  }

  art::ServiceHandle<geo::Geometry> geo;
  std::vector<geo::WireID> wireIDs = geo->ChannelToWire(chan);
  unsigned int wireID = wireIDs.front().Wire;
  unsigned int planeID = wireIDs.front().Plane;

  geo::WireGeo const& wire = geo->Wire(wireIDs.front());
  double wirelength = wire.Length(); //wirelength in cm.

  if(fIncludeJumpers){
    if( (planeID==0 && wireID >= fUFirstJumper && wireID <= fULastJumper) || (planeID==1 && wireID >= fVFirstJumper && wireID <= fVLastJumper) ){ //Add jumper term only for appropriate wires on U and V planes.
      double jumperLength = (fJumperCapacitance/16.75)*100; //Using wire value of 16.75 pF/m to convert jumper capacitance to equivalent wire length. x100 to convert to cm.
      wirelength = wirelength + jumperLength;
    }
  }
  //include for 0 wirelength tests.
  //wirelength = 0;


  ///This part below has been moved from the generateMicroBooNoise section as it needs to be done differently for SBND due to different wirelengths.

  ////////////////////////////// MicroBooNE noise model/////////////////////////////////
  // vars

  // Fetch sampling rate.
  float sampleRate = sampling_rate(clockData);
  // Fetch FFT service and # ticks.
  art::ServiceHandle<util::LArFFT> pfft;
  unsigned int ntick = pfft->FFTSize(); //waveform_size
  // width of frequencyBin in kHz
  double binWidth = 1.0/(ntick*sampleRate*1.0e-6);

  // Create noise spectrum in frequency.
  unsigned nbin = ntick/2 + 1;
  std::vector<TComplex> noiseFrequency(nbin, 0.);
  double pval = 0.;
  double phase = 0.;
  double rnd[3] = {0.};

  std::vector<double> noisevector(ntick,0.0);
  double fitpar[9] = {0.};
  
  // gain function in kHz
  TF1* _pfn_f1 = new TF1("_pfn_f1", "([0]*1/(x/1000*[8]/2) + ([1]*exp(-0.5*(((x/1000*[8]/2)-[2])/[3])**2)*exp(-0.5*pow(x/1000*[8]/(2*[4]),[5])))*[6]) + [7]", 0.0, 0.5*ntick*binWidth);
  // set data-driven parameters
 
  double wldValue = _wld_f->Eval(wirelength);

  fitpar[0] = fNoiseFunctionParameters.at(0);
  fitpar[1] = fNoiseFunctionParameters.at(1);
  fitpar[2] = fNoiseFunctionParameters.at(2);
  fitpar[3] = fNoiseFunctionParameters.at(3);
  fitpar[4] = fNoiseFunctionParameters.at(4);
  fitpar[5] = fNoiseFunctionParameters.at(5);
  fitpar[6] = wldValue; //wire length parameter
  fitpar[7] = fNoiseFunctionParameters.at(7); //baseline_noise
  fitpar[8] = 9596; //uBooNE nticks. Using SBND (or ProtoDUNE) nticks changes the model significantly, so we stick with the uBooNE nticks. 

  _pfn_f1->SetParameters(fitpar);
  _pfn_f1->SetNpx(1000);

  for ( unsigned int i=0; i<ntick/2+1; ++i ) {
    //MicroBooNE noise model
    double pfnf1val = _pfn_f1->Eval((i+0.5)*binWidth);
    // define FFT parameters
    double randPoisson = GetRandomTF1(_poisson);
    double randomizer = randPoisson/kPoissonMean;
    pval = pfnf1val * randomizer;
    // random phase angle
    flat.fireArray(2, rnd, 0, 1);
    phase = rnd[1]*2.*TMath::Pi();
    TComplex tc(pval*cos(phase),pval*sin(phase));
    noiseFrequency[i] += tc;
  }


  // Obtain time spectrum from frequency spectrum.
  std::vector<double> tmpnoise(noisevector.size());
  pfft->DoInvFFT(noiseFrequency, tmpnoise);
  noiseFrequency.clear();
  for ( unsigned int itck=0; itck<noisevector.size(); ++itck ) {
    noisevector[itck] = sqrt(ntick)*tmpnoise[itck];
  }
  // end of moved section.

  _pfn_f1->Delete();
  


  const geo::View_t view = geo->View(chan);
  for ( unsigned int itck=0; itck<sigs.size(); ++itck ) {
    double tnoise = 0;
    if ( view==geo::kU ) {
      if(fEnableWhiteNoise)    tnoise += fWhiteNoiseU*gaus.fire();
      if(fEnableMicroBooNoise) tnoise += noisevector[itck];
      if(fEnableGaussianNoise) tnoise += fGausNoiseU[gausNoiseChan][itck];
      if(fEnableCoherentNoise) tnoise += fCohNoiseU[cohNoisechan][itck];
    } 
    else if ( view==geo::kV ) {
      if(fEnableWhiteNoise)    tnoise += fWhiteNoiseV*gaus.fire();
      if(fEnableMicroBooNoise) tnoise += noisevector[itck];
      if(fEnableGaussianNoise) tnoise += fGausNoiseV[gausNoiseChan][itck];
      if(fEnableCoherentNoise) tnoise += fCohNoiseV[cohNoisechan][itck];
    } 
    else {
      if(fEnableWhiteNoise)    tnoise += fWhiteNoiseZ*gaus.fire();
      if(fEnableMicroBooNoise) tnoise += noisevector[itck];
      if(fEnableGaussianNoise) tnoise += fGausNoiseZ[gausNoiseChan][itck];
      if(fEnableCoherentNoise) tnoise += fCohNoiseZ[cohNoisechan][itck];
    }      
    sigs[itck] += tnoise;
  }
  return 0;
}

CLHEP::HepRandomEngine * SBNDuBooNEDataDrivenNoiseService::ConstructRandomEngine ( const bool  haveSeed )

private

Definition at line 120 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

                                                                                                 {
  string myname = "SBNDuBooNEDataDrivenNoiseService::ctor: ";
  string rname = "SBNDuBooNEDataDrivenNoiseService";

  if ( haveSeed ) {
    if ( fLogLevel > 0 ) cout << myname << "WARNING: Using hardwired seed." << endl;
    m_pran = new HepJamesRandom(fRandomSeed);
  } else {
    if ( fLogLevel > 0 ) cout << myname << "Using NuRandomService." << endl;
    art::ServiceHandle<NuRandomService> seedSvc;
    m_pran = new HepJamesRandom;
    if ( fLogLevel > 0 ) cout << myname << "    Initial seed: " << m_pran->getSeed() << endl;
    seedSvc->registerEngine(NuRandomService::CLHEPengineSeeder(m_pran), rname);
  }
  if ( fLogLevel > 0 ) cout << myname << "  Registered seed: " << m_pran->getSeed() << endl;
  
  return m_pran;
}

void SBNDuBooNEDataDrivenNoiseService::generateCoherentNoise ( detinfo::DetectorClocksData const &  clockData, AdcSignalVector &  noise, std::vector< float >  gausNorm, std::vector< float >  gausMean, std::vector< float >  gausSigma, float  cohExpNorm, float  cohExpWidth, float  cohExpOffset, TH1 *  aNoiseHist  ) const

private

Definition at line 433 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

                                                   {
  const string myname = "SBNDuBooNEDataDrivenNoiseService::generateCoherentGaussianNoise: ";
  if ( fLogLevel > 1 ) {
    cout << myname << "Generating Coherent Gaussian noise." << endl;  
  }
  //--- get number of gaussians ---  
  int a = gausNorm.size();
  int b = gausMean.size();
  int c = gausSigma.size();
  int NGausians = a<b?a:b;
  NGausians = NGausians<c?NGausians:c;
  //--- set function formula ---
  std::stringstream  name;
  name.str("");
  for(int i=0;i<NGausians;i++) {
        name<<"["<<3*i<<"]*exp(-0.5*pow((x-["<<3*i+1<<"])/["<<3*i+2<<"],2))+";
  }
  name<<"["<<3*NGausians<<"]*exp(-x/["<<3*NGausians+1<<"]) + ["<<3*NGausians+2<<"]";
  TF1 *funcCohNoise = new TF1("funcGausCohsNoise",name.str().c_str(), 0, 1200);
  funcCohNoise->SetNpx(12000);
  for(int i=0;i<NGausians;i++) {
    funcCohNoise->SetParameter(3*i, gausNorm.at(i));    
    funcCohNoise->SetParameter(3*i+1, gausMean.at(i));  
    funcCohNoise->SetParameter(3*i+2, gausSigma.at(i)); 
  }
  funcCohNoise->SetParameter(3*NGausians, cohExpNorm);
  funcCohNoise->SetParameter(3*NGausians+1, cohExpWidth);
  funcCohNoise->SetParameter(3*NGausians+2, cohExpOffset);
  
  // custom poisson  
  TF1* _poisson = new TF1("_poisson", "[0]**(x) * exp(-[0]) / ROOT::Math::tgamma(x+1.)", 0, 30);
  // poisson mean
  double params[1] = {0.};
  params[0] = 4; // hard-coded for now. To be updated with data
  _poisson->SetParameters(params);
  // Fetch sampling rate.
  float sampleRate = sampling_rate(clockData);
  // Fetch FFT service and # ticks.
  art::ServiceHandle<util::LArFFT> pfft;
  unsigned int ntick = pfft->FFTSize();
  CLHEP::RandFlat flat(*m_pran);
  // Create noise spectrum in frequency.
  unsigned nbin = ntick/2 + 1;
  std::vector<TComplex> noiseFrequency(nbin, 0.);
  double pval = 0.;
  double phase = 0.;
  double rnd[2] = {0.};
  // width of frequencyBin in kHz
  double binWidth = 1.0/(ntick*sampleRate*1.0e-6);
  for ( unsigned int i=0; i<ntick/2+1; ++i ) {
    // coherent noise spectrum 
    pval = funcCohNoise->Eval((double)i*binWidth);
    // randomize amplitude within 10%
    flat.fireArray(2, rnd, 0, 1);
    pval *= 0.9 + 0.2*rnd[0];
    phase = rnd[1]*2.*TMath::Pi(); 
    TComplex tc(pval*cos(phase),pval*sin(phase));
    noiseFrequency[i] += tc;
  }
  // Obtain time spectrum from frequency spectrum.
  noise.clear();
  noise.resize(ntick,0.0);
  std::vector<double> tmpnoise(noise.size());
  pfft->DoInvFFT(noiseFrequency, tmpnoise);
  noiseFrequency.clear();
  
  // Note: Assume that the frequency function is obtained from a fit 
  // of the foward FFT spectrum. In LArSoft, the forward
  // FFT (doFFT) does not scale the frequency spectrum, but the backward FFT (DoInvFFT) 
  // does scale the waveform with 1/Nticks. If the frequency function is a fit to the 
  // LArSoft FFT spectrum, no scaling factor is needed after a backward FFT. 
  // However, the noise model described here is a fit to the scaled FFT spectrum 
  // (scaled with 1./sqrt(Nticks)).
  // Therefore, after InvFFT, the waveform must be nomalized with sqrt(Nticks).
  
  for ( unsigned int itck=0; itck<noise.size(); ++itck ) {
    noise[itck] = sqrt(ntick)*tmpnoise[itck];
  }
  for ( unsigned int itck=0; itck<noise.size(); ++itck ) {
    aNoiseHist->Fill(noise[itck]);
  }
  
  //free memory
  delete funcCohNoise; funcCohNoise = 0;
}

void SBNDuBooNEDataDrivenNoiseService::generateGaussianNoise ( detinfo::DetectorClocksData const &  clockData, AdcSignalVector &  noise, std::vector< float >  gausNorm, std::vector< float >  gausMean, std::vector< float >  gausSigma, TH1 *  aNoiseHist  ) const

private

Definition at line 360 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

                                                   {
  const string myname = "SBNDuBooNEDataDrivenNoiseService::generateGaussianNoise: ";
  if ( fLogLevel > 1 ) {
    cout << myname << "Generating Gaussian noise." << endl;  
  }
  //--- get number of gaussians ---  
  int a = gausNorm.size();
  int b = gausMean.size();
  int c = gausSigma.size();
  int NGausians = a<b?a:b;
  NGausians = NGausians<c?NGausians:c;
  //--- set function formula ---
  std::stringstream  name;
  name.str("");
  for(int i=0;i<NGausians;i++) {
        name<<"["<<3*i<<"]*exp(-0.5*pow((x-["<<3*i+1<<"])/["<<3*i+2<<"],2))+";
  }
  name<<"0";
  TF1 *funcGausNoise = new TF1("funcGausInhNoise",name.str().c_str(), 0, 1200);
  funcGausNoise->SetNpx(12000);
  for(int i=0;i<NGausians;i++) {
    funcGausNoise->SetParameter(3*i, gausNorm.at(i));   
    funcGausNoise->SetParameter(3*i+1, gausMean.at(i)); 
    funcGausNoise->SetParameter(3*i+2, gausSigma.at(i));        
  }
  
  // Fetch sampling rate.
  float sampleRate = sampling_rate(clockData);
  // Fetch FFT service and # ticks.
  art::ServiceHandle<util::LArFFT> pfft;
  unsigned int ntick = pfft->FFTSize();
  CLHEP::RandFlat flat(*m_pran);
  // Create noise spectrum in frequency.
  unsigned nbin = ntick/2 + 1;
  std::vector<TComplex> noiseFrequency(nbin, 0.);
  double pval = 0.;
  double phase = 0.;
  double rnd[2] = {0.};
  // width of frequencyBin in kHz
  double binWidth = 1.0/(ntick*sampleRate*1.0e-6);
  for ( unsigned int i=0; i<ntick/2+1; ++i ) {
    // coherent noise spectrum 
    pval = funcGausNoise->Eval((double)i*binWidth);
    // randomize amplitude within 10%
    flat.fireArray(2, rnd, 0, 1);
    pval *= 0.9 + 0.2*rnd[0];
    // randomize phase angle
    phase = rnd[1]*2.*TMath::Pi();
    TComplex tc(pval*cos(phase),pval*sin(phase));
    noiseFrequency[i] += tc;
  }
  // Obtain time spectrum from frequency spectrum.
  noise.clear();
  noise.resize(ntick,0.0);
  std::vector<double> tmpnoise(noise.size());
  pfft->DoInvFFT(noiseFrequency, tmpnoise);
  noiseFrequency.clear();
  
  for ( unsigned int itck=0; itck<noise.size(); ++itck ) {
    noise[itck] = sqrt(ntick)*tmpnoise[itck];
  }
  for ( unsigned int itck=0; itck<noise.size(); ++itck ) {
    aNoiseHist->Fill(noise[itck]);
  }
  
  //free memory
  delete funcGausNoise; funcGausNoise = 0;
}

void SBNDuBooNEDataDrivenNoiseService::generateMicroBooNoise ( float  wirelength, float  ENOB, AdcSignalVector &  noise, TH1 *  aNoiseHist  ) const

private

void SBNDuBooNEDataDrivenNoiseService::generateNoise ( detinfo::DetectorClocksData const &  clockData )

overridevirtual

Reimplemented from ChannelNoiseService.

Definition at line 558 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

                                                                                              {
    
  if(fEnableGaussianNoise) {
    fGausNoiseU.resize(fNoiseArrayPoints);
    fGausNoiseV.resize(fNoiseArrayPoints);
    fGausNoiseZ.resize(fNoiseArrayPoints);
    for ( unsigned int i=0; i<fNoiseArrayPoints; ++i ) {
      generateGaussianNoise(clockData, fGausNoiseU[i], fGausNormU, fGausMeanU, fGausSigmaU, fGausNoiseHistU);
      generateGaussianNoise(clockData, fGausNoiseV[i], fGausNormV, fGausMeanV, fGausSigmaV, fGausNoiseHistV);
      generateGaussianNoise(clockData, fGausNoiseZ[i], fGausNormZ, fGausMeanZ, fGausSigmaZ, fGausNoiseHistZ);
    }
  }
  
  if(fEnableCoherentNoise) {
    // U plane
    makeCoherentGroupsByOfflineChannel(fNChannelsPerCoherentGroup[0]);
    fCohNoiseU.resize(fCohNoiseArrayPoints); 
    for ( unsigned int i=0; i<fCohNoiseArrayPoints; ++i ) {
      generateCoherentNoise(clockData, fCohNoiseU[i], fCohGausNorm, fCohGausMean, fCohGausSigma, 
                            fCohExpNorm, fCohExpWidth, fCohExpOffset, 
                            fCohNoiseHist);
    }
    
    // V plane
    makeCoherentGroupsByOfflineChannel(fNChannelsPerCoherentGroup[1]);
    fCohNoiseV.resize(fCohNoiseArrayPoints);
    for ( unsigned int i=0; i<fCohNoiseArrayPoints; ++i ) {
      generateCoherentNoise(clockData, fCohNoiseV[i], fCohGausNorm, fCohGausMean, fCohGausSigma, 
                            fCohExpNorm, fCohExpWidth, fCohExpOffset, 
                            fCohNoiseHist);
    }

    // Z plane
    makeCoherentGroupsByOfflineChannel(fNChannelsPerCoherentGroup[2]);
    fCohNoiseZ.resize(fCohNoiseArrayPoints);
    for ( unsigned int i=0; i<fCohNoiseArrayPoints; ++i ) {

      generateCoherentNoise(clockData, fCohNoiseZ[i], fCohGausNorm, fCohGausMean, fCohGausSigma, 
                            fCohExpNorm, fCohExpWidth, fCohExpOffset, 
                            fCohNoiseHist);
    }
  }
}

unsigned int SBNDuBooNEDataDrivenNoiseService::getCohNoiseChanFromGroup ( unsigned int  cohgroup ) const

private

Definition at line 552 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

                                                                                                   {
  return fGroupCoherentNoiseMap[cohgroup];
}

unsigned int SBNDuBooNEDataDrivenNoiseService::getGroupNumberFromOfflineChannel ( unsigned int  offlinechan ) const

private

Definition at line 547 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

                                                                                                              {
  return fChannelGroupMap[offlinechan];
}

double SBNDuBooNEDataDrivenNoiseService::GetRandomTF1 ( TF1 *  func ) const

private

Definition at line 139 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

                                                                    {
  TRandom* gRandomTemp = gRandom;
  gRandom = fTRandom3;
  double randomVal(func->GetRandom());
  gRandom = gRandomTemp;
  return randomVal;
}

void SBNDuBooNEDataDrivenNoiseService::makeCoherentGroupsByOfflineChannel ( unsigned int  nchpergroup )

private

Definition at line 525 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

                                                                                                  {
        CLHEP::RandFlat flat(*m_pran);
        CLHEP::RandGauss gaus(*m_pran);
        art::ServiceHandle<geo::Geometry> geo;
        const unsigned int nchan = geo->Nchannels();
        fChannelGroupMap.resize(nchan);
        unsigned int numberofgroups = 0;
        if(nchan%nchpergroup == 0) numberofgroups = nchan/nchpergroup;
        else numberofgroups = nchan/nchpergroup +1;
        unsigned int cohGroupNo = 0;
        for(unsigned int chan=0; chan<nchan; chan++) {
          cohGroupNo = chan/nchpergroup; //group number
          fChannelGroupMap[chan] = cohGroupNo; 
        }
        fGroupCoherentNoiseMap.resize(numberofgroups);
        for(unsigned int ng=0; ng<numberofgroups; ng++) {
          unsigned int cohNoiseChan = flat.fire()*fCohNoiseArrayPoints;
          fGroupCoherentNoiseMap[ng] = cohNoiseChan;
        }
}

ostream & SBNDuBooNEDataDrivenNoiseService::print ( std::ostream &  out = std::cout, std::string  prefix = ""  ) const

overridevirtual

Implements ChannelNoiseService.

Definition at line 286 of file SBNDuBooNEDataDrivenNoiseService_service.cc.

                                                                                  {
  out << prefix << "SBNDuBooNEDataDrivenNoiseService: " << endl;
  
  out << prefix << "          LogLevel: " <<  fLogLevel << endl;
  out << prefix << "        RandomSeed: " <<  fRandomSeed << endl;
  out << prefix << "  NoiseArrayPoints: " << fNoiseArrayPoints << endl;
  
  out << prefix << "  EnableWhiteNoise: " << fEnableWhiteNoise   << endl;  
  out << prefix << "       WhiteNoiseZ: " << fWhiteNoiseZ << endl;
  out << prefix << "       WhiteNoiseU: " << fWhiteNoiseU << endl;
  out << prefix << "       WhiteNoiseV: " << fWhiteNoiseV << endl; 
  
  out << prefix << "EnableGaussianNoise: " << fEnableGaussianNoise  << endl;
  out << prefix << "     GausNormU: [ ";  
  for(int i=0; i<(int)fGausNormU.size(); i++) { out <<  fGausNormU.at(i) << " ";}
  out << " ]" << endl;
  out << prefix << "     GausMeanU: [ ";  
  for(int i=0; i<(int)fGausMeanU.size(); i++) { out <<  fGausMeanU.at(i) << " ";}
  out << " ]" << endl;
  out << prefix << "     GausSigmaU: [ ";  
  for(int i=0; i<(int)fGausSigmaU.size(); i++) { out <<  fGausSigmaU.at(i) << " ";}
  out << " ]" << endl;
  out << prefix << "     GausNormV: [ ";  
  for(int i=0; i<(int)fGausNormV.size(); i++) { out <<  fGausNormV.at(i) << " ";}
  out << " ]" << endl;
  out << prefix << "     GausMeanV: [ ";  
  for(int i=0; i<(int)fGausMeanV.size(); i++) { out <<  fGausMeanV.at(i) << " ";}
  out << " ]" << endl;
  out << prefix << "     GausSigmaV: [ ";  
  for(int i=0; i<(int)fGausSigmaV.size(); i++) { out <<  fGausSigmaV.at(i) << " ";}
  out << " ]" << endl;
  out << prefix << "     GausNormZ: [ ";  
  for(int i=0; i<(int)fGausNormZ.size(); i++) { out <<  fGausNormZ.at(i) << " ";}
  out << " ]" << endl;
  out << prefix << "     GausMeanZ: [ ";  
  for(int i=0; i<(int)fGausMeanZ.size(); i++) { out <<  fGausMeanZ.at(i) << " ";}
  out << " ]" << endl;
  out << prefix << "     GausSigmaZ: [ ";  
  for(int i=0; i<(int)fGausSigmaZ.size(); i++) { out <<  fGausSigmaZ.at(i) << " ";}
  out << " ]" << endl;
  
  out << prefix << "EnableMicroBooNoise: " << fEnableMicroBooNoise  << endl;
  out << prefix << "     EffectiveNBits: " << fENOB  << endl;
  out << prefix << "  JumperCapacitance: " << fJumperCapacitance  << endl;
  out << prefix << "       UFirstJumper: " << fUFirstJumper  << endl;
  out << prefix << "        ULastJumper: " << fULastJumper  << endl;
  out << prefix << "       VFirstJumper: " << fVFirstJumper  << endl;
  out << prefix << "        VLastJumper: " << fVLastJumper  << endl;
  
  out << prefix << "MicroBoo model parameters: [ ";  
  for(int i=0; i<(int)fNoiseFunctionParameters.size(); i++) { out <<  fNoiseFunctionParameters.at(i) << " ";}
  out << " ]" << endl;
    
  out << prefix << "EnableCoherentNoise: " << fEnableCoherentNoise   << endl;
  out << prefix << "ExpNoiseArrayPoints: " << fExpNoiseArrayPoints << endl;
  out << prefix << "CohNoiseArrayPoints: " << fCohNoiseArrayPoints << endl;
  
  out << prefix << "     CohGausNorm: [ ";  
  for(int i=0; i<(int)fCohGausNorm.size(); i++) { out <<  fCohGausNorm.at(i) << " ";}
  out << " ]" << endl;
  out << prefix << "     CohGausMean: [ ";  
  for(int i=0; i<(int)fCohGausMean.size(); i++) { out <<  fCohGausMean.at(i) << " ";}
  out << " ]" << endl;
  out << prefix << "     CohGausSigma: [ ";  
  for(int i=0; i<(int)fCohGausSigma.size(); i++) { out <<  fCohGausSigma.at(i) << " ";}
  out << " ]" << endl;
  
  out << prefix << "  Actual random seed: " << m_pran->getSeed();
  return out;
}

Member Data Documentation

TF1* SBNDuBooNEDataDrivenNoiseService::_poisson

private

Definition at line 179 of file SBNDuBooNEDataDrivenNoiseService.h.

TF1* SBNDuBooNEDataDrivenNoiseService::_wld_f

private

Definition at line 176 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<unsigned int> SBNDuBooNEDataDrivenNoiseService::fChannelGroupMap

private

assign each channel a group number

Definition at line 93 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fCohExpNorm

private

noise scale factor for the exponential component component in coherent noise

Definition at line 137 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fCohExpOffset

private

Amplitude offset of the exponential background component in coherent noise.

Definition at line 139 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fCohExpWidth

private

width of the exponential component in coherent noise

Definition at line 138 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fCohGausMean

private

mean of the gaussian component in coherent noise

Definition at line 141 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fCohGausNorm

private

noise scale factor for the gaussian component in coherent noise

Definition at line 140 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fCohGausSigma

private

sigma of the gaussian component in coherent noise

Definition at line 142 of file SBNDuBooNEDataDrivenNoiseService.h.

unsigned int SBNDuBooNEDataDrivenNoiseService::fCohNoiseArrayPoints

private

number of points in randomly generated noise array

Definition at line 136 of file SBNDuBooNEDataDrivenNoiseService.h.

TH1* SBNDuBooNEDataDrivenNoiseService::fCohNoiseChanHist

private

distribution of accessed noise samples

Definition at line 174 of file SBNDuBooNEDataDrivenNoiseService.h.

TH1* SBNDuBooNEDataDrivenNoiseService::fCohNoiseHist

private

distribution of noise counts

Definition at line 173 of file SBNDuBooNEDataDrivenNoiseService.h.

AdcSignalVectorVector SBNDuBooNEDataDrivenNoiseService::fCohNoiseU

private

noise on each channel for each time for all planes

Definition at line 157 of file SBNDuBooNEDataDrivenNoiseService.h.

AdcSignalVectorVector SBNDuBooNEDataDrivenNoiseService::fCohNoiseV

private

noise on each channel for each time for all planes

Definition at line 158 of file SBNDuBooNEDataDrivenNoiseService.h.

AdcSignalVectorVector SBNDuBooNEDataDrivenNoiseService::fCohNoiseZ

private

noise on each channel for each time for all planes

Definition at line 156 of file SBNDuBooNEDataDrivenNoiseService.h.

bool SBNDuBooNEDataDrivenNoiseService::fEnableCoherentNoise

private

Definition at line 133 of file SBNDuBooNEDataDrivenNoiseService.h.

bool SBNDuBooNEDataDrivenNoiseService::fEnableGaussianNoise

private

Definition at line 110 of file SBNDuBooNEDataDrivenNoiseService.h.

bool SBNDuBooNEDataDrivenNoiseService::fEnableMicroBooNoise

private

enable MicroBooNE noise model

Definition at line 122 of file SBNDuBooNEDataDrivenNoiseService.h.

bool SBNDuBooNEDataDrivenNoiseService::fEnableWhiteNoise

private

Definition at line 104 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fENOB

private

Effective number of bits.

Definition at line 123 of file SBNDuBooNEDataDrivenNoiseService.h.

unsigned int SBNDuBooNEDataDrivenNoiseService::fExpNoiseArrayPoints

private

number of points in randomly generated noise array

Definition at line 135 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fGausMeanU

private

mean of the gaussian component in coherent noise

Definition at line 112 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fGausMeanV

private

mean of the gaussian component in coherent noise

Definition at line 115 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fGausMeanZ

private

mean of the gaussian component in coherent noise

Definition at line 118 of file SBNDuBooNEDataDrivenNoiseService.h.

TH1* SBNDuBooNEDataDrivenNoiseService::fGausNoiseChanHist

private

distribution of accessed noise samples

Definition at line 166 of file SBNDuBooNEDataDrivenNoiseService.h.

TH1* SBNDuBooNEDataDrivenNoiseService::fGausNoiseHistU

private

distribution of noise counts for U

Definition at line 164 of file SBNDuBooNEDataDrivenNoiseService.h.

TH1* SBNDuBooNEDataDrivenNoiseService::fGausNoiseHistV

private

distribution of noise counts for V

Definition at line 165 of file SBNDuBooNEDataDrivenNoiseService.h.

TH1* SBNDuBooNEDataDrivenNoiseService::fGausNoiseHistZ

private

distribution of noise counts for Z

Definition at line 163 of file SBNDuBooNEDataDrivenNoiseService.h.

AdcSignalVectorVector SBNDuBooNEDataDrivenNoiseService::fGausNoiseU

private

Definition at line 147 of file SBNDuBooNEDataDrivenNoiseService.h.

AdcSignalVectorVector SBNDuBooNEDataDrivenNoiseService::fGausNoiseV

private

Definition at line 148 of file SBNDuBooNEDataDrivenNoiseService.h.

AdcSignalVectorVector SBNDuBooNEDataDrivenNoiseService::fGausNoiseZ

private

Definition at line 146 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fGausNormU

private

noise scale factor for the gaussian component in coherent noise

Definition at line 111 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fGausNormV

private

noise scale factor for the gaussian component in coherent noise

Definition at line 114 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fGausNormZ

private

noise scale factor for the gaussian component in coherent noise

Definition at line 117 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fGausSigmaU

private

sigma of the gaussian component in coherent noise

Definition at line 113 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fGausSigmaV

private

sigma of the gaussian component in coherent noise

Definition at line 116 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fGausSigmaZ

private

sigma of the gaussian component in coherent noise

Definition at line 119 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<int> SBNDuBooNEDataDrivenNoiseService::fGroupCoherentNoiseMap

private

assign each group a noise

Definition at line 94 of file SBNDuBooNEDataDrivenNoiseService.h.

bool SBNDuBooNEDataDrivenNoiseService::fIncludeJumpers

private

Include jumper term.

Definition at line 124 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fJumperCapacitance

private

Capacitance of jumper cables in pF. Defaults to 0 if not included.

Definition at line 125 of file SBNDuBooNEDataDrivenNoiseService.h.

int SBNDuBooNEDataDrivenNoiseService::fLogLevel

private

Log message level: 0=quiet, 1=init only, 2+=every event.

Definition at line 101 of file SBNDuBooNEDataDrivenNoiseService.h.

TH1* SBNDuBooNEDataDrivenNoiseService::fMicroBooNoiseChanHist

private

distribution of accessed noise samples

Definition at line 171 of file SBNDuBooNEDataDrivenNoiseService.h.

TH1* SBNDuBooNEDataDrivenNoiseService::fMicroBooNoiseHistU

private

distribution of noise counts for U

Definition at line 169 of file SBNDuBooNEDataDrivenNoiseService.h.

TH1* SBNDuBooNEDataDrivenNoiseService::fMicroBooNoiseHistV

private

distribution of noise counts for V

Definition at line 170 of file SBNDuBooNEDataDrivenNoiseService.h.

TH1* SBNDuBooNEDataDrivenNoiseService::fMicroBooNoiseHistZ

private

distribution of noise counts for Z

Definition at line 168 of file SBNDuBooNEDataDrivenNoiseService.h.

AdcSignalVectorVector SBNDuBooNEDataDrivenNoiseService::fMicroBooNoiseU

private

Definition at line 152 of file SBNDuBooNEDataDrivenNoiseService.h.

AdcSignalVectorVector SBNDuBooNEDataDrivenNoiseService::fMicroBooNoiseV

private

Definition at line 153 of file SBNDuBooNEDataDrivenNoiseService.h.

AdcSignalVectorVector SBNDuBooNEDataDrivenNoiseService::fMicroBooNoiseZ

private

Definition at line 151 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<unsigned int> SBNDuBooNEDataDrivenNoiseService::fNChannelsPerCoherentGroup

private

Definition at line 134 of file SBNDuBooNEDataDrivenNoiseService.h.

unsigned int SBNDuBooNEDataDrivenNoiseService::fNoiseArrayPoints

private

number of points in randomly generated noise array

Definition at line 99 of file SBNDuBooNEDataDrivenNoiseService.h.

std::vector<float> SBNDuBooNEDataDrivenNoiseService::fNoiseFunctionParameters

private

Parameters in the MicroBooNE noise model.

Definition at line 130 of file SBNDuBooNEDataDrivenNoiseService.h.

int SBNDuBooNEDataDrivenNoiseService::fRandomSeed

private

Seed for random number service. If absent or zero, use SeedSvc.

Definition at line 100 of file SBNDuBooNEDataDrivenNoiseService.h.

TRandom3* SBNDuBooNEDataDrivenNoiseService::fTRandom3

private

Definition at line 187 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fUFirstJumper

private

Wire number of first wire on U layer to include a jumper cable. Defaults to 0 if not included.

Definition at line 126 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fULastJumper

private

Wire number of last wire on U layer to include a jumper cable. Defaults to 0 if not included.

Definition at line 127 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fVFirstJumper

private

Wire number of first wire on V layer to include a jumper cable. Defaults to 0 if not included.

Definition at line 128 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fVLastJumper

private

Wire number of last wire on V layer to include a jumper cable. Defaults to 0 if not included.

Definition at line 129 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fWhiteNoiseU

private

Level (per freq bin) for white noise for U.

Definition at line 106 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fWhiteNoiseV

private

Level (per freq bin) for white noise for V.

Definition at line 107 of file SBNDuBooNEDataDrivenNoiseService.h.

float SBNDuBooNEDataDrivenNoiseService::fWhiteNoiseZ

private

Level (per freq bin) for white noise for Z.

Definition at line 105 of file SBNDuBooNEDataDrivenNoiseService.h.

bool SBNDuBooNEDataDrivenNoiseService::haveSeed

private

Definition at line 183 of file SBNDuBooNEDataDrivenNoiseService.h.

CLHEP::HepRandomEngine* SBNDuBooNEDataDrivenNoiseService::m_pran

private

Definition at line 184 of file SBNDuBooNEDataDrivenNoiseService.h.

double SBNDuBooNEDataDrivenNoiseService::wldparams[2]

private

Definition at line 177 of file SBNDuBooNEDataDrivenNoiseService.h.

---

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

• SBNDuBooNEDataDrivenNoiseService.h
• SBNDuBooNEDataDrivenNoiseService_service.cc