detsim::SimWire Class Reference

Inheritance diagram for detsim::SimWire:

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

Private Member Functions
void	produce (art::Event &evt) override
void	beginJob () override
void	ConvoluteResponseFunctions ()
	convolute electronics and field response More...
void	SetFieldResponse ()
	response of wires to field More...
void	SetElectResponse ()
	response of electronics More...
void	GenNoise (std::vector< float > &array, CLHEP::HepRandomEngine &engine)

Private Attributes
std::string	fDriftEModuleLabel
	module making the ionization electrons More...
raw::Compress_t	fCompression
	compression type to use More...
int	fNTicks
	number of ticks of the clock More...
double	fSampleRate
	sampling rate in ns More...
unsigned int	fNSamplesReadout
	number of ADC readout samples in 1 readout frame More...
double	fCol3DCorrection
double	fInd3DCorrection
unsigned int	fNElectResp
	number of entries from response to use More...
double	fInputFieldRespSamplingPeriod
	Sampling period in the input field response. More...
double	fShapeTimeConst
	time constants for exponential shaping More...
double	fADCPerPCAtLowestASICGain
	ADCs/pC at lowest gain setting of 4.7 mV/fC. More...
double	fASICGainInMVPerFC
	actual gain setting used in mV/fC More...
int	fNoiseNchToSim
	number of noise channels to generate More...
std::string	fNoiseModelChoice
	choice for noise model More...
std::string	fNoiseFluctChoice
	choice for noise freq component mag fluctuations More...
std::vector< int >	fFieldRespTOffset
	field response time offset in ticks More...
std::vector< int >	fCalibRespTOffset
	calib response time offset in ticks More...
std::vector< float >	fColFieldParams
	collection plane field function parameterization More...
std::vector< float >	fIndFieldParams
	induction plane field function parameterization More...
std::vector< double >	fColFieldResponse
	response function for the field @ collection plane More...
std::vector< double >	fIndFieldResponse
	response function for the field @ induction plane More...
std::vector< TComplex >	fColShape
	response function for the field @ collection plane More...
std::vector< TComplex >	fIndShape
	response function for the field @ induction plane More...
std::vector< double >	fElectResponse
	response function for the electronics More...
std::vector< std::vector< float > >	fNoise
	noise on each channel for each time More...
std::vector< double >	fNoiseModelPar
	noise model params More...
std::vector< double >	fNoiseFluctPar
	Poisson noise fluctuations params. More...
TH1D *	fIndFieldResp
	response function for the field @ induction plane More...
TH1D *	fColFieldResp
	response function for the field @ collection plane More...
TH1D *	fElectResp
	response function for the electronics More...
TH1D *	fColTimeShape
	convoluted shape for field x electronics @ col plane More...
TH1D *	fIndTimeShape
	convoluted shape for field x electronics @ ind plane More...
TH1D *	fNoiseDist
	distribution of noise counts More...
TF1 *	fNoiseFluct
	Poisson dist for fluctuations in magnitude of noise freq components. More...
CLHEP::HepRandomEngine &	fEngine
	Random-number engine owned by art. More...

Detailed Description

Definition at line 69 of file SimWire_module.cc.

Constructor & Destructor Documentation

detsim::SimWire::SimWire ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 132 of file SimWire_module.cc.

    : EDProducer{pset}
    , fDriftEModuleLabel{pset.get<std::string>("DriftEModuleLabel")}
    , fCompression{pset.get<std::string>("CompressionType") == "Huffman" ? raw::kHuffman :
                                                                           raw::kNone}
    , fCol3DCorrection{pset.get<double>("Col3DCorrection")}
    , fInd3DCorrection{pset.get<double>("Ind3DCorrection")}
    , fInputFieldRespSamplingPeriod{pset.get<double>("InputFieldRespSamplingPeriod")}
    , fShapeTimeConst{pset.get<double>("ShapeTimeConst")}
    , fADCPerPCAtLowestASICGain{pset.get<double>("ADCPerPCAtLowestASICGain")}
    , fASICGainInMVPerFC{pset.get<double>("ASICGainInMVPerFC")}
    , fNoiseNchToSim{pset.get<int>("NoiseNchToSim")}
    , fNoiseModelChoice{pset.get<std::string>("NoiseModelChoice")}
    , fNoiseFluctChoice{pset.get<std::string>("NoiseFluctChoice")}
    , fFieldRespTOffset{pset.get<std::vector<int>>("FieldRespTOffset")}
    , fCalibRespTOffset{pset.get<std::vector<int>>("CalibRespTOffset")}
    , fColFieldParams{pset.get<std::vector<float>>("ColFieldParams")}
    , fIndFieldParams{pset.get<std::vector<float>>("IndFieldParams")}
    , fNoiseModelPar{pset.get<std::vector<double>>("NoiseModelPar")}
    , fNoiseFluctPar{pset.get<std::vector<double>>("NoiseFluctPar")}
    // create a default random engine; obtain the random seed from NuRandomService,
    // unless overridden in configuration with key "Seed"
    , fEngine(art::ServiceHandle<rndm::NuRandomService> {}->createEngine(*this, pset, "Seed"))

Member Function Documentation

void detsim::SimWire::beginJob ( )

overrideprivate

Definition at line 172 of file SimWire_module.cc.

  {
    // ... get access to the TFile service
    art::ServiceHandle<art::TFileService const> tfs;

    fNoiseDist = tfs->make<TH1D>("Noise", ";Noise (ADC);", 1000, -10., 10.);

    art::ServiceHandle<util::LArFFT const> fFFT;
    fNTicks = fFFT->FFTSize();

    // ... Poisson dist function for fluctuating magnitude of noise frequency component
    if ( fNoiseFluctChoice == "SimplePoisson" ) {
      // .. simple modified Poisson with (x-1)! in denominator
      double params[1];
      fNoiseFluct = new TF1("_poisson", "[0]**(x) * exp(-[0]) / ROOT::Math::tgamma(x)", 0, 5.);
      params[0] = fNoiseFluctPar[0];  // Poisson mean
      fNoiseFluct->SetParameters(params);
    } else if ( fNoiseFluctChoice == "WeightedPoisson" ) {
      // .. weighted Poisson in ArgoNeuT DDN model
      double params[3];
      fNoiseFluct = new TF1("_poisson", "[0]*pow([1]/[2], x/[2])*exp(-[1]/[2])/ROOT::Math::tgamma(x/[2]+1.)", 0, 5.);
      params[0] = fNoiseFluctPar[0];
      params[1] = fNoiseFluctPar[1];
      params[2] = fNoiseFluctPar[2];
      fNoiseFluct->SetParameters(params);
    } else {
      throw cet::exception("SimWire::beginJob") << fNoiseFluctChoice
        << " is an unknown noise fluctuation choice" << std::endl;
    }

    // ... generate the noise in advance depending on value of fNoiseNchToSim:
    //     positive - generate N=fNoiseNchToSim channels & randomly pick from pool when adding to signal
    //     zero     - no noise
    //     negative - generate unique noise for each channel for each event
    if (fNoiseNchToSim>0) {
      if (fNoiseNchToSim>10000) {
        throw cet::exception("SimWire::beginJob") << fNoiseNchToSim
          << " noise channels requested exceeds 10000" << std::endl;
      }
      fNoise.resize(fNoiseNchToSim);
      for (unsigned int p = 0; p < fNoise.size(); ++p) {
        GenNoise(fNoise[p], fEngine);
        for (int i = 0; i < fNTicks; ++i) {
          fNoiseDist->Fill(fNoise[p][i]);
        }
      }
    }


    // ... set field response and electronics response, then convolute them
    SetFieldResponse();
    SetElectResponse();
    ConvoluteResponseFunctions();
  }

void detsim::SimWire::ConvoluteResponseFunctions ( )

private

convolute electronics and field response

Definition at line 338 of file SimWire_module.cc.

  {
    double tick, ticks, peak;

    std::vector<double> col(fNTicks, 0.);
    std::vector<double> ind(fNTicks, 0.);
    std::vector<TComplex> kern(fNTicks/2 + 1);
    std::vector<double> delta(fNTicks, 0.);

    art::ServiceHandle<util::LArFFT> fFFT;

    // ... do collection plane
    fColShape.resize(fNTicks/2+1);
    fFFT->DoFFT(fElectResponse, fColShape);

    fFFT->DoFFT(fColFieldResponse, kern);
    for(unsigned int i=0; i<kern.size(); ++i)
      fColShape[i] *= kern[i];

    fFFT->DoInvFFT(fColShape, col);

    delta[0] = 1.0;
    peak = fFFT->PeakCorrelation(delta, col);
    tick = 0.;
    ticks =  tick - peak;
    fFFT->ShiftData(fColShape, ticks);
    fFFT->DoInvFFT(fColShape, col);

    // ... do induction plane
    fIndShape.resize(fNTicks/2+1);
    fFFT->DoFFT(fElectResponse, fIndShape);

    kern.clear();
    kern.resize(fNTicks/2 + 1);
    fFFT->DoFFT(fIndFieldResponse, kern);
    for(unsigned int i=0; i<kern.size(); ++i)
      fIndShape[i] *= kern[i];

    fFFT->DoInvFFT(fIndShape, ind);

    delta.resize(0);
    delta.resize(fNTicks,0);
    delta[0] = 1.0;
    peak = fFFT->PeakCorrelation(delta, ind);
    tick = 0.;
    ticks =  tick - peak;
    fFFT->ShiftData(fIndShape, ticks);
    fFFT->DoInvFFT(fIndShape, ind);

    // ... write the time-domain shapes out to a file
    art::ServiceHandle<art::TFileService const> tfs;
    fColTimeShape = tfs->make<TH1D>(
      "ConvolutedCollection",";ticks; Electronics#timesCollection",fNTicks,0,fNTicks);
    fIndTimeShape = tfs->make<TH1D>(
      "ConvolutedInduction",";ticks; Electronics#timesInduction",fNTicks,0,fNTicks);

    // ... check that you did the right thing
    for(unsigned int i = 0; i < ind.size(); ++i){
      fColTimeShape->Fill(i, col[i]);
      fIndTimeShape->Fill(i, ind[i]);
    }

    fColTimeShape->Write();
    fIndTimeShape->Write();

  }

void detsim::SimWire::GenNoise ( std::vector< float > &  array, CLHEP::HepRandomEngine &  engine  )

private

Definition at line 407 of file SimWire_module.cc.

  {
    CLHEP::RandFlat flat(engine);

    noise.clear();
    noise.resize(fNTicks, 0.);
    std::vector<TComplex> noiseFrequency(fNTicks/2+1, 0.); // noise in frequency space

    double pval = 0.;
    double phase = 0.;
    double rnd[2] = {0.};

    // .. width of frequencyBin in kHz
    double binWidth = 1.0/(fNTicks*fSampleRate*1.0e-6);

    for (int i=0; i< fNTicks/2+1; ++i) {

      double x=(i+0.5)*binWidth;

      if ( fNoiseModelChoice == "Legacy" ) {
        // ... Legacy exponential model kept here for reference:
        //     par[0]=NoiseFact, par[1]=NoiseWidth, par[2]=LowCutoff, par[3-7]=0
        //     example parameter values for fcl: NoiseModelPar:[ 1.32e-1,120,7.5,0,0,0,0,0 ]
        pval = fNoiseModelPar[0] * exp(-(double)i * binWidth / fNoiseModelPar[1]);
        double lofilter = 1.0 / (1.0 + exp(-(i - fNoiseModelPar[2] / binWidth) / 0.5));
        flat.fireArray(1, rnd, 0, 1);
        pval *= lofilter * (0.9 + 0.2 * rnd[0]);
      } else if ( fNoiseModelChoice == "ModUBooNE" ) {
        // ... Modified uBooNE model with additive exp to account for low freq region:
        //     example parameter values for fcl: NoiseModelPar:[
        //                                         4450.,-530.,280.,110.,
        //                                         -0.85,18.,0.064,74. ]
        pval = fNoiseModelPar[0]*exp(-0.5*pow((x-fNoiseModelPar[1])/fNoiseModelPar[2],2))
                         *exp(-0.5*pow(x/fNoiseModelPar[3],fNoiseModelPar[4]))
                         +fNoiseModelPar[5]+exp(-fNoiseModelPar[6]*(x-fNoiseModelPar[7]));
        double randomizer = fNoiseFluct->GetRandom();
        pval = pval * randomizer/fNTicks;
      } else if ( fNoiseModelChoice == "ArgoNeuT" ) {
        // ... ArgoNeuT data driven model:
        //     In fcl set parameters to: NoiseModelPar:[
        //                                 5000,-5.52058e2,2.81587e2,-5.66561e1,
        //                                 4.10817e1,1.76284e1,1e-1,5.97838e1 ]
        pval = fNoiseModelPar[0]*exp(-0.5*pow((x-fNoiseModelPar[1])/fNoiseModelPar[2],2))
                         *((fNoiseModelPar[3]/(x+fNoiseModelPar[4]))+1)
                         +fNoiseModelPar[5]+exp(-fNoiseModelPar[6]*(x-fNoiseModelPar[7]));
        double randomizer = fNoiseFluct->GetRandom();
        pval = pval * randomizer/fNTicks;
      } else {
        throw cet::exception("SimWire::GenNoise") << fNoiseModelChoice
          << " is an unknown choice for the noise model" << std::endl;
      }

      flat.fireArray(1,rnd,0,1);
      phase = rnd[0]*2.*TMath::Pi();

      TComplex tc(pval*cos(phase),pval*sin(phase));
      noiseFrequency[i] += tc;
    }

    // .. inverse FFT MCSignal
    art::ServiceHandle<util::LArFFT> fFFT;
    fFFT->DoInvFFT(noiseFrequency, noise);

    noiseFrequency.clear();

    // .. multiply each noise value by fNTicks as the InvFFT
    //    divides each bin by fNTicks assuming that a forward FFT
    //    has already been done.
    for (unsigned int i = 0; i < noise.size(); ++i)
      noise[i] *= 1. * fNTicks;
  }

void detsim::SimWire::produce ( art::Event &  evt )

overrideprivate

Definition at line 229 of file SimWire_module.cc.

  {

    art::ServiceHandle<geo::Geometry const> geo;

    // ... generate unique noise for each channel in each event
    if (fNoiseNchToSim<0) {
      fNoise.clear();
      fNoise.resize(geo->Nchannels());
      for(unsigned int p = 0; p < geo->Nchannels(); ++p){
        GenNoise(fNoise[p], fEngine);
      }
    }

    // ... make a vector of const sim::SimChannel* that has same number
    //     of entries as the number of channels in the detector
    //     and set the entries for the channels that have signal on them
    //     using the chanHandle
    std::vector<const sim::SimChannel*> chanHandle;
    evt.getView(fDriftEModuleLabel,chanHandle);

    std::vector<const sim::SimChannel*> channels(geo->Nchannels());
    for(size_t c = 0; c < chanHandle.size(); ++c){
      channels[chanHandle[c]->Channel()] = chanHandle[c];
    }

    // ... make an unique_ptr of sim::SimDigits that allows ownership of the produced
    //     digits to be transferred to the art::Event after the put statement below
    auto digcol = std::make_unique<std::vector<raw::RawDigit>>();

    art::ServiceHandle<util::LArFFT> fFFT;

    // ... Add all channels
    CLHEP::RandFlat flat(fEngine);

    std::map<int,double>::iterator mapIter;
    for(unsigned int chan = 0; chan < geo->Nchannels(); chan++) {

      std::vector<short> adcvec(fNTicks, 0);
      std::vector<double> fChargeWork(fNTicks, 0.);

      if( channels[chan] ){

        // .. get the sim::SimChannel for this channel
        const sim::SimChannel* sc = channels[chan];

        // .. loop over the tdcs and grab the number of electrons for each
        for(int t = 0; t < fNTicks; ++t)
          fChargeWork[t] = sc->Charge(t);

        int time_offset = 0;

        // .. Convolve charge with appropriate response function
        if(geo->SignalType(chan) == geo::kInduction){
          fFFT->Convolute(fChargeWork,fIndShape);
          time_offset = fFieldRespTOffset[1]+fCalibRespTOffset[1];
        } else {
          fFFT->Convolute(fChargeWork,fColShape);
          time_offset = fFieldRespTOffset[0]+fCalibRespTOffset[0];
        }

        // .. Apply field response offset
        std::vector<int> temp;
        if (time_offset <=0){
          temp.assign(fChargeWork.begin(),fChargeWork.begin()-time_offset);
          fChargeWork.erase(fChargeWork.begin(),fChargeWork.begin()-time_offset);
          fChargeWork.insert(fChargeWork.end(),temp.begin(),temp.end());
        }else{
          temp.assign(fChargeWork.end()-time_offset,fChargeWork.end());
          fChargeWork.erase(fChargeWork.end()-time_offset,fChargeWork.end());
          fChargeWork.insert(fChargeWork.begin(),temp.begin(),temp.end());
        }

      }

      // ... Add noise to signal depending on value of fNoiseNchToSim
      if(fNoiseNchToSim!=0){
        int noisechan = chan;
        if(fNoiseNchToSim>0){
          noisechan = TMath::Nint(flat.fire()*(1.*(fNoise.size()-1)+0.1));
        }
        for(int i = 0; i < fNTicks; ++i){
          adcvec[i] = (short)TMath::Nint(fNoise[noisechan][i] + fChargeWork[i]);
        }
      } else {
        for(int i = 0; i < fNTicks; ++i){
          adcvec[i] = (short)TMath::Nint(fChargeWork[i]);
        }
      }

      adcvec.resize(fNSamplesReadout);

      // ... compress the adc vector using the desired compression scheme,
      //     if raw::kNone is selected nothing happens to adcvec
      //     This shrinks adcvec, if fCompression is not kNone.
      raw::Compress(adcvec, fCompression);

      // ... add this digit to the collection
      digcol->emplace_back(chan, fNTicks, move(adcvec), fCompression);

    }//end loop over channels

    evt.put(std::move(digcol));

    return;
  }

void detsim::SimWire::SetElectResponse ( )

private

response of electronics

Definition at line 534 of file SimWire_module.cc.

  {
    fElectResponse.resize(fNTicks, 0.);
    std::vector<double> time(fNTicks,0.);

    // ... Gain and shaping time variables from fcl file:    
    double Ao = 1.0;
    double To = fShapeTimeConst;  //peaking time

    // ... this is actually sampling time, in ns
    mf::LogInfo("SimWire::SetElectResponse") << "Check sampling intervals: " 
                                             << fInputFieldRespSamplingPeriod << " ns" 
                                             << "Check number of samples: " << fNTicks;

    // ... The following sets the microboone electronics response function in 
    //     time-space. Function comes from BNL SPICE simulation of DUNE35t 
    //     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. 
    double max = 0;

    for (size_t i = 0; i < fElectResponse.size(); ++i) {

      // ... convert time to microseconds, to match fElectResponse[i] definition
      time[i] = (1.*i)*fInputFieldRespSamplingPeriod *1e-3; 
      fElectResponse[i] = 
        4.31054*exp(-2.94809*time[i]/To)*Ao - 2.6202*exp(-2.82833*time[i]/To)*cos(1.19361*time[i]/To)*Ao
        -2.6202*exp(-2.82833*time[i]/To)*cos(1.19361*time[i]/To)*cos(2.38722*time[i]/To)*Ao
        +0.464924*exp(-2.40318*time[i]/To)*cos(2.5928*time[i]/To)*Ao
        +0.464924*exp(-2.40318*time[i]/To)*cos(2.5928*time[i]/To)*cos(5.18561*time[i]/To)*Ao
        +0.762456*exp(-2.82833*time[i]/To)*sin(1.19361*time[i]/To)*Ao
        -0.762456*exp(-2.82833*time[i]/To)*cos(2.38722*time[i]/To)*sin(1.19361*time[i]/To)*Ao
        +0.762456*exp(-2.82833*time[i]/To)*cos(1.19361*time[i]/To)*sin(2.38722*time[i]/To)*Ao
        -2.6202*exp(-2.82833*time[i]/To)*sin(1.19361*time[i]/To)*sin(2.38722*time[i]/To)*Ao 
        -0.327684*exp(-2.40318*time[i]/To)*sin(2.5928*time[i]/To)*Ao + 
        +0.327684*exp(-2.40318*time[i]/To)*cos(5.18561*time[i]/To)*sin(2.5928*time[i]/To)*Ao
        -0.327684*exp(-2.40318*time[i]/To)*cos(2.5928*time[i]/To)*sin(5.18561*time[i]/To)*Ao
        +0.464924*exp(-2.40318*time[i]/To)*sin(2.5928*time[i]/To)*sin(5.18561*time[i]/To)*Ao;

      if (fElectResponse[i] > max) max = fElectResponse[i];
    
    }// end loop over time buckets

    // ... "normalize" fElectResponse[i], before the convolution   
  
    for (auto& element : fElectResponse) {
      element /= max;
      element *= fADCPerPCAtLowestASICGain * 1.60217657e-7;
      element *= fASICGainInMVPerFC / 4.7; // relative to lowest gain setting of 4.7 mV/fC
    }

    fNElectResp = fElectResponse.size();

    // ... write the response out to a file

    art::ServiceHandle<art::TFileService const> tfs;
    fElectResp = tfs->make<TH1D>(
      "ElectronicsResponse",";t (ns);Electronics Response",fNElectResp,0,fNElectResp);
    for (unsigned int i = 0; i < fNElectResp; ++i) {
      fElectResp->Fill(i, fElectResponse[i]);
    }

    fElectResp->Write();
  }

void detsim::SimWire::SetFieldResponse ( )

private

response of wires to field

Definition at line 481 of file SimWire_module.cc.

  {

    // ... Files to write the response functions to
    art::ServiceHandle<art::TFileService const> tfs;
    fIndFieldResp = tfs->make<TH1D>("InductionFieldResponse",";t (ns);Induction Response",fNTicks,0,fNTicks);
    fColFieldResp = tfs->make<TH1D>("CollectionFieldResponse",";t (ns);Collection Response",fNTicks,0,fNTicks);

    fColFieldResponse.resize(fNTicks, 0.);
    fIndFieldResponse.resize(fNTicks, 0.);

    // ... First set response for collection plane
    int nbinc = fColFieldParams[0];

    double integral = 0.;
    for (int i = 1; i < nbinc; ++i) {
      fColFieldResponse[i] = i * i;
      integral += fColFieldResponse[i];
    }

    for (int i = 0; i < nbinc; ++i) {
      fColFieldResponse[i] *= fColFieldParams[1]/integral;
      fColFieldResp->Fill(i, fColFieldResponse[i]);
    }

    // ... Now set response for induction plane
    int nbini = fIndFieldParams[0];
    unsigned short lastbini = 2 * nbini;

    integral = 0;
    for (unsigned short i = 0; i < lastbini; ++i) {
      double ang = i * TMath::Pi() / nbini;
      fIndFieldResponse[i] = sin(ang);
      if (fIndFieldResponse[i] > 0) {
        integral += fIndFieldResponse[i];
      } else {
        fIndFieldResponse[i] *= fIndFieldParams[2]; // scale the negative lobe by 10% (from ArgoNeuT)
      }
    }
    ++lastbini;

    for (unsigned short i = 0; i < lastbini; ++i) {
      fIndFieldResponse[i] *= fIndFieldParams[1]/integral;
      fIndFieldResp->Fill(i, fIndFieldResponse[i]);
    }

    // ... Save the field responses
    fColFieldResp->Write();
    fIndFieldResp->Write();
  }

Member Data Documentation

double detsim::SimWire::fADCPerPCAtLowestASICGain

private

ADCs/pC at lowest gain setting of 4.7 mV/fC.

Definition at line 97 of file SimWire_module.cc.

double detsim::SimWire::fASICGainInMVPerFC

private

actual gain setting used in mV/fC

Definition at line 98 of file SimWire_module.cc.

std::vector<int> detsim::SimWire::fCalibRespTOffset

private

calib response time offset in ticks

Definition at line 104 of file SimWire_module.cc.

double detsim::SimWire::fCol3DCorrection

private

correction factor to account for 3D path of electrons thru wires

Definition at line 90 of file SimWire_module.cc.

std::vector<float> detsim::SimWire::fColFieldParams

private

collection plane field function parameterization

Definition at line 105 of file SimWire_module.cc.

TH1D* detsim::SimWire::fColFieldResp

private

response function for the field @ collection plane

Definition at line 117 of file SimWire_module.cc.

std::vector<double> detsim::SimWire::fColFieldResponse

private

response function for the field @ collection plane

Definition at line 107 of file SimWire_module.cc.

std::vector<TComplex> detsim::SimWire::fColShape

private

response function for the field @ collection plane

Definition at line 109 of file SimWire_module.cc.

TH1D* detsim::SimWire::fColTimeShape

private

convoluted shape for field x electronics @ col plane

Definition at line 119 of file SimWire_module.cc.

raw::Compress_t detsim::SimWire::fCompression

private

compression type to use

Definition at line 85 of file SimWire_module.cc.

std::string detsim::SimWire::fDriftEModuleLabel

private

module making the ionization electrons

Definition at line 84 of file SimWire_module.cc.

TH1D* detsim::SimWire::fElectResp

private

response function for the electronics

Definition at line 118 of file SimWire_module.cc.

std::vector<double> detsim::SimWire::fElectResponse

private

response function for the electronics

Definition at line 111 of file SimWire_module.cc.

CLHEP::HepRandomEngine& detsim::SimWire::fEngine

private

Random-number engine owned by art.

Definition at line 124 of file SimWire_module.cc.

std::vector<int> detsim::SimWire::fFieldRespTOffset

private

field response time offset in ticks

Definition at line 103 of file SimWire_module.cc.

double detsim::SimWire::fInd3DCorrection

private

correction factor to account for 3D path of electrons thru wires

Definition at line 92 of file SimWire_module.cc.

std::vector<float> detsim::SimWire::fIndFieldParams

private

induction plane field function parameterization

Definition at line 106 of file SimWire_module.cc.

TH1D* detsim::SimWire::fIndFieldResp

private

response function for the field @ induction plane

Definition at line 116 of file SimWire_module.cc.

std::vector<double> detsim::SimWire::fIndFieldResponse

private

response function for the field @ induction plane

Definition at line 108 of file SimWire_module.cc.

std::vector<TComplex> detsim::SimWire::fIndShape

private

response function for the field @ induction plane

Definition at line 110 of file SimWire_module.cc.

TH1D* detsim::SimWire::fIndTimeShape

private

convoluted shape for field x electronics @ ind plane

Definition at line 120 of file SimWire_module.cc.

double detsim::SimWire::fInputFieldRespSamplingPeriod

private

Sampling period in the input field response.

Definition at line 95 of file SimWire_module.cc.

unsigned int detsim::SimWire::fNElectResp

private

number of entries from response to use

Definition at line 94 of file SimWire_module.cc.

std::vector<std::vector<float> > detsim::SimWire::fNoise

private

noise on each channel for each time

Definition at line 112 of file SimWire_module.cc.

TH1D* detsim::SimWire::fNoiseDist

private

distribution of noise counts

Definition at line 121 of file SimWire_module.cc.

TF1* detsim::SimWire::fNoiseFluct

private

Poisson dist for fluctuations in magnitude of noise freq components.

Definition at line 122 of file SimWire_module.cc.

std::string detsim::SimWire::fNoiseFluctChoice

private

choice for noise freq component mag fluctuations

Definition at line 101 of file SimWire_module.cc.

std::vector<double> detsim::SimWire::fNoiseFluctPar

private

Poisson noise fluctuations params.

Definition at line 114 of file SimWire_module.cc.

std::string detsim::SimWire::fNoiseModelChoice

private

choice for noise model

Definition at line 100 of file SimWire_module.cc.

std::vector<double> detsim::SimWire::fNoiseModelPar

private

noise model params

Definition at line 113 of file SimWire_module.cc.

int detsim::SimWire::fNoiseNchToSim

private

number of noise channels to generate

Definition at line 99 of file SimWire_module.cc.

unsigned int detsim::SimWire::fNSamplesReadout

private

number of ADC readout samples in 1 readout frame

Definition at line 89 of file SimWire_module.cc.

int detsim::SimWire::fNTicks

private

number of ticks of the clock

Definition at line 87 of file SimWire_module.cc.

double detsim::SimWire::fSampleRate

private

sampling rate in ns

Definition at line 88 of file SimWire_module.cc.

double detsim::SimWire::fShapeTimeConst

private

time constants for exponential shaping

Definition at line 96 of file SimWire_module.cc.

---

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

• SimWire_module.cc