detsim::SimWireDUNE10kt Class Reference

Inheritance diagram for detsim::SimWireDUNE10kt:

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

Private Member Functions
void	GenNoise (std::vector< float > &array)

Private Attributes
std::string	fDriftEModuleLabel
	module making the ionization electrons More...
raw::Compress_t	fCompression
	compression type to use More...
unsigned int	fNoiseOn
	noise turned on or off for debugging; default is on More...
unsigned int	fNoiseModel
	noise model More...
float	fNoiseFact
	noise scale factor More...
float	fNoiseWidth
	exponential noise width (kHz) More...
float	fLowCutoff
	low frequency filter cutoff (kHz) More...
float	fNoiseFactZ
	noise scale factor for Z (collection) plane More...
float	fNoiseWidthZ
	exponential noise width (kHz) for Z (collection) plane More...
float	fLowCutoffZ
	low frequency filter cutoff (kHz) for Z (collection) plane More...
float	fNoiseFactU
	noise scale factor for U plane More...
float	fNoiseWidthU
	exponential noise width (kHz) for U plane More...
float	fLowCutoffU
	low frequency filter cutoff (kHz) for U plane More...
float	fNoiseFactV
	noise scale factor for V plane More...
float	fNoiseWidthV
	exponential noise width (kHz) for V plane More...
float	fLowCutoffV
	low frequency filter cutoff (kHz) for V plane More...
unsigned int	fZeroThreshold
	Zero suppression threshold. More...
int	fNearestNeighbor
	Maximum distance between hits above threshold before they are separated into different blocks. 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...
unsigned int	fNTimeSamples
	number of ADC readout samples in all readout frames (per event) More...
unsigned int	fNoiseArrayPoints
	number of points in randomly generated noise array More...
std::vector< double >	fChargeWork
std::vector< std::vector< float > >	fNoiseZ
	noise on each channel for each time for Z (collection) plane More...
std::vector< std::vector< float > >	fNoiseU
	noise on each channel for each time for U plane More...
std::vector< std::vector< float > >	fNoiseV
	noise on each channel for each time for V plane More...
TH1D *	fNoiseDist
	distribution of noise counts More...
const float	adcsaturation = 4095
bool	fSaveEmptyChannel
float	fCollectionPed
	ADC value of baseline for collection plane. More...
float	fInductionPed
	ADC value of baseline for induction plane. More...
CLHEP::HepRandomEngine &	fEngine

Additional Inherited Members
Public Types inherited from art::EDProducer
using	ModuleType = EDProducer
using	WorkerType = WorkerT< EDProducer >
Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >
Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >
Static Public Member Functions inherited from art::EDProducer
static void	commitEvent (EventPrincipal &ep, Event &e)
Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()
template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)
template<typename T , BranchType = InEvent>
void	consumesMany ()
template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)
template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Definition at line 63 of file SimWireDUNE10kt_module.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 122 of file SimWireDUNE10kt_module.cc.

    : EDProducer{pset}
      // 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"))
  {

    this->reconfigure(pset);

    produces< std::vector<raw::RawDigit>   >();
    if(fNSamplesReadout != fNTimeSamples ) {
      produces< std::vector<raw::RawDigit>   >("preSpill");
      produces< std::vector<raw::RawDigit>   >("postSpill");
    } 

    fCompression = raw::kNone;
    TString compression(pset.get< std::string >("CompressionType"));
    if(compression.Contains("Huffman",TString::kIgnoreCase)) fCompression = raw::kHuffman;    
    if(compression.Contains("ZeroSuppression",TString::kIgnoreCase)) fCompression = raw::kZeroSuppression;      
  }

Member Function Documentation

void detsim::SimWireDUNE10kt::beginJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 175 of file SimWireDUNE10kt_module.cc.

  { 

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

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

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

    if ( fNTicks%2 != 0 ) 
      MF_LOG_DEBUG("SimWireDUNE10kt") << "Warning: FFTSize not a power of 2. "
                                   << "May cause issues in (de)convolution.\n";

    if ( (int)fNSamplesReadout > fNTicks ) 
      mf::LogError("SimWireDUNE10kt") << "Cannot have number of readout samples "
                                      << "greater than FFTSize!";

    fChargeWork.resize(fNTicks, 0.);
    art::ServiceHandle<geo::Geometry> geo;
    
    //Generate noise if selected to be on
    if(fNoiseOn && fNoiseModel==1){

      //fNoise.resize(geo->Nchannels());
      fNoiseZ.resize(fNoiseArrayPoints);
      fNoiseU.resize(fNoiseArrayPoints);
      fNoiseV.resize(fNoiseArrayPoints);
      
      // GenNoise() will further resize each channel's 
      // fNoise vector to fNoiseArrayPoints long.
      
      for(unsigned int p = 0; p < fNoiseArrayPoints; ++p){
        fNoiseFact = fNoiseFactZ;
        fNoiseWidth = fNoiseWidthZ;
        fLowCutoff = fLowCutoffZ;

        GenNoise(fNoiseZ[p]);
        for(int i = 0; i < fNTicks; ++i)
          fNoiseDist->Fill(fNoiseZ[p][i]);
        
        fNoiseFact = fNoiseFactU;
        fNoiseWidth = fNoiseWidthU;
        fLowCutoff = fLowCutoffU;

        GenNoise(fNoiseU[p]);
        for(int i = 0; i < fNTicks; ++i)         
          fNoiseDist->Fill(fNoiseU[p][i]);


        fNoiseFact = fNoiseFactV;
        fNoiseWidth = fNoiseWidthV;
        fLowCutoff = fLowCutoffV;
 
    
        GenNoise(fNoiseV[p]);
        for(int i = 0; i < fNTicks; ++i)
          fNoiseDist->Fill(fNoiseV[p][i]);      
        
      }// end loop over wires
    } 
    return;

  }

void detsim::SimWireDUNE10kt::endJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 242 of file SimWireDUNE10kt_module.cc.

  {
  }

void detsim::SimWireDUNE10kt::GenNoise ( std::vector< float > &  array )

private

Definition at line 626 of file SimWireDUNE10kt_module.cc.

  {
    CLHEP::RandFlat flat(fEngine);

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

    double pval = 0.; 
    double lofilter = 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){
      // exponential noise spectrum 
      pval = fNoiseFact*exp(-(double)i*binWidth/fNoiseWidth);
      // low frequency cutoff     
      lofilter = 1.0/(1.0+exp(-(i-fLowCutoff/binWidth)/0.5));
      // randomize 10%
      flat.fireArray(2,rnd,0,1);
      pval *= lofilter*(0.9+0.2*rnd[0]);
      // random pahse angle
      phase = rnd[1]*2.*TMath::Pi();

      TComplex tc(pval*cos(phase),pval*sin(phase));
      noiseFrequency[i] += tc;
    }
  
    // std::cout << "filled noise freq" << std::endl;

    // 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::SimWireDUNE10kt::produce ( art::Event &  evt )

virtual

Implements art::EDProducer.

Definition at line 247 of file SimWireDUNE10kt_module.cc.

  {
    // get the geometry to be able to figure out signal types and chan -> plane mappings
    art::ServiceHandle<geo::Geometry> geo;
    unsigned int signalSize = fNTicks;

    // vectors for working
    std::vector<short>    adcvec(signalSize, 0);        
    std::vector<short>    adcvecPreSpill(signalSize, 0);        
    std::vector<short>    adcvecPostSpill(signalSize, 0);       
    std::vector<const sim::SimChannel*> chanHandle;
    evt.getView(fDriftEModuleLabel,chanHandle);

    //Get fIndShape and fColShape from SignalShapingService, on the fly
    art::ServiceHandle<util::SignalShapingServiceDUNE> sss;

    // 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*> channels(geo->Nchannels());
    for(size_t c = 0; c < chanHandle.size(); ++c){
      channels[chanHandle[c]->Channel()] = chanHandle[c];
    }
    
    // whether or not to do the prespill and postspill digitization:
    const bool prepost = (fNSamplesReadout != fNTimeSamples);

    // 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
    std::unique_ptr< std::vector<raw::RawDigit>   >  digcol(new std::vector<raw::RawDigit>);
    std::unique_ptr< std::vector<raw::RawDigit>   >  digcolPreSpill(prepost? new std::vector<raw::RawDigit>: nullptr);
    std::unique_ptr< std::vector<raw::RawDigit>   >  digcolPostSpill(prepost? new std::vector<raw::RawDigit>: nullptr);
    
    unsigned int chan = 0; 
    fChargeWork.clear();
    fChargeWork.resize(fNTicks, 0.);
    
    std::vector<double> fChargeWorkPreSpill, fChargeWorkPostSpill;

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

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

    std::map<int,double>::iterator mapIter;

    digcol->reserve(geo->Nchannels());
    if (prepost) {
      digcolPreSpill->reserve(geo->Nchannels());
      digcolPostSpill->reserve(geo->Nchannels());
    }
    
    auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
    for(chan = 0; chan < geo->Nchannels(); chan++) {
      
      fChargeWork.clear();
      // fChargeWork.resize(fNTicks, 0.);
      fChargeWork.resize(fNTimeSamples, 0.);


      if (prepost) {
        fChargeWorkPreSpill.clear();
        fChargeWorkPostSpill.clear();
        fChargeWorkPreSpill.resize(fNTicks,0);
        fChargeWorkPostSpill.resize(fNTicks,0);
      }

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

      const geo::View_t view = geo->View(chan);

      if( sc ){

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


        // Convolve charge with appropriate response function 
        if(prepost) {
          fChargeWorkPreSpill.assign(fChargeWork.begin(), fChargeWork.begin()+fNSamplesReadout);
          fChargeWorkPostSpill.assign(fChargeWork.begin()+2*fNSamplesReadout, fChargeWork.end());

          fChargeWork.erase( fChargeWork.begin()+2*fNSamplesReadout, fChargeWork.end() );
          fChargeWork.erase( fChargeWork.begin(), fChargeWork.begin()+fNSamplesReadout );

          fChargeWorkPreSpill.resize(fNTicks,0);
          fChargeWorkPostSpill.resize(fNTicks,0);
          sss->Convolute(clockData, chan, fChargeWorkPreSpill);
          sss->Convolute(clockData, chan, fChargeWorkPostSpill);
        }
        fChargeWork.resize(fNTicks,0);
        sss->Convolute(clockData, chan,fChargeWork);


      }
      
      float ped_mean = fCollectionPed;
      geo::SigType_t sigtype = geo->SignalType(chan);
      if (sigtype == geo::kInduction){
        ped_mean = fInductionPed;
      }
      else if (sigtype == geo::kCollection){
        ped_mean = fCollectionPed;
      }
      // noise was already generated for each wire in the event
      // raw digit vec is already in channel order
      // pick a new "noise channel" for every channel  - this makes sure    
      // the noise has the right coherent characteristics to be on one channel

    
      int noisechan = nearbyint(flat.fire()*(1.*(fNoiseArrayPoints-1)+0.1));
      int noisechanpre = nearbyint(flat.fire()*(1.*(fNoiseArrayPoints-1)+0.1));
      int noisechanpost = nearbyint(flat.fire()*(1.*(fNoiseArrayPoints-1)+0.1));
    
      // optimize for speed -- access vectors as arrays 

      double *fChargeWork_a=0;
      double *fChargeWorkPreSpill_a=0;
      double *fChargeWorkPostSpill_a=0;
      short *adcvec_a=0;
      short *adcvecPreSpill_a=0;
      short *adcvecPostSpill_a=0;
      float *noise_a_U=0;
      float *noise_a_V=0;
      float *noise_a_Z=0;
      float *noise_a_Upre=0;
      float *noise_a_Vpre=0;
      float *noise_a_Zpre=0;
      float *noise_a_Upost=0;
      float *noise_a_Vpost=0;
      float *noise_a_Zpost=0;

      if (signalSize>0) {
        fChargeWork_a = fChargeWork.data();
        adcvec_a = adcvec.data();
        if (prepost) {
          fChargeWorkPreSpill_a = fChargeWorkPreSpill.data();
          fChargeWorkPostSpill_a = fChargeWorkPostSpill.data();
          adcvecPreSpill_a = adcvecPreSpill.data();
          adcvecPostSpill_a = adcvecPostSpill.data();
        }
        if (fNoiseOn && fNoiseModel==1) {
          noise_a_U=(fNoiseU[noisechan]).data();
          noise_a_V=(fNoiseV[noisechan]).data();
          noise_a_Z=(fNoiseZ[noisechan]).data();
          if (prepost) {
            noise_a_Upre=(fNoiseU[noisechanpre]).data();
            noise_a_Vpre=(fNoiseV[noisechanpre]).data();
            noise_a_Zpre=(fNoiseZ[noisechanpre]).data();
            noise_a_Upost=(fNoiseU[noisechanpost]).data();
            noise_a_Vpost=(fNoiseV[noisechanpost]).data();
            noise_a_Zpost=(fNoiseZ[noisechanpost]).data();
          }
        }
      }

      float tmpfv=0;  // this is here so we do our own rounding from floats to short ints (saves CPU time)
      float tnoise=0;
      float tnoisepre=0;
      float tnoisepost=0;

      if (view != geo::kU && view != geo::kV && view != geo::kZ) {
        mf::LogError("SimWireDUNE10kt") << "ERROR: CHANNEL NUMBER " << chan << " OUTSIDE OF PLANE";
      }

      //std::cout << "Xin " << fNoiseOn << " " << fNoiseModel << std::endl;

      if(fNoiseOn && fNoiseModel==1) {
        for(unsigned int i = 0; i < signalSize; ++i){
          if(view==geo::kU)       { tnoise = noise_a_U[i]; }
          else if (view==geo::kV) { tnoise = noise_a_V[i]; }
          else                    { tnoise = noise_a_Z[i]; }
          tmpfv = tnoise + fChargeWork_a[i];
          //allow for ADC saturation
          if ( tmpfv > adcsaturation - ped_mean)
            tmpfv = adcsaturation- ped_mean;
          //don't allow for "negative" saturation
          if ( tmpfv < 0 - ped_mean)
            tmpfv = 0- ped_mean;
          adcvec_a[i] = (tmpfv >=0) ? (short) (tmpfv+0.5) : (short) (tmpfv-0.5);
        }
        if (prepost) {
          for(unsigned int i = 0; i < signalSize; ++i){
            if(view==geo::kU)      { tnoisepre = noise_a_Upre[i]; tnoisepost = noise_a_Upost[i];  }
            else if(view==geo::kV) { tnoisepre = noise_a_Vpre[i]; tnoisepost = noise_a_Vpost[i]; }
            else                   { tnoisepre = noise_a_Zpre[i]; tnoisepost = noise_a_Zpost[i]; }
            
            tmpfv = tnoisepre + fChargeWorkPreSpill_a[i];
            //allow for ADC saturation
            if ( tmpfv > adcsaturation - ped_mean){
              tmpfv = adcsaturation- ped_mean;
            }
            //don't allow for "negative" saturation
            if ( tmpfv < 0- ped_mean ){
              tmpfv = 0- ped_mean;
            }
            adcvecPreSpill_a[i] = (tmpfv >=0) ? (short) (tmpfv+0.5) : (short) (tmpfv-0.5); 

            tmpfv = tnoisepost + fChargeWorkPostSpill_a[i];
            //allow for ADC saturation
            if ( tmpfv > adcsaturation - ped_mean){
              tmpfv = adcsaturation- ped_mean;
            }
            //don't allow for "negative" saturation
            if ( tmpfv < 0 - ped_mean){
              tmpfv = 0- ped_mean;
            }
            adcvecPostSpill_a[i] = (tmpfv >=0) ? (short) (tmpfv+0.5) : (short) (tmpfv-0.5); 
          }
        }
      }else if (fNoiseOn && fNoiseModel==2){
        float fASICGain      = sss->GetASICGain(chan);  
        double fShapingTime   = sss->GetShapingTime(chan);
        std::map< double, int > fShapingTimeOrder;
        fShapingTimeOrder = { {0.5, 0}, {1.0, 1}, {2.0, 2}, {3.0, 3} };
        DoubleVec              fNoiseFactVec;
        auto tempNoiseVec = sss->GetNoiseFactVec();
        if ( fShapingTimeOrder.find( fShapingTime ) != fShapingTimeOrder.end() ){
          size_t i = 0;
          fNoiseFactVec.resize(2);
          for (auto& item : tempNoiseVec) {
            fNoiseFactVec[i]   = item.at( fShapingTimeOrder.find( fShapingTime )->second );
            fNoiseFactVec[i] *= fASICGain/4.7;
            ++i;
          }
        }
        else {//Throw exception...
          throw cet::exception("SimWireMicroBooNE")
            << "\033[93m"
            << "Shaping Time received from signalservices_microboone.fcl is not one of allowed values"
            << std::endl
            << "Allowed values: 0.5, 1.0, 2.0, 3.0 usec"
            << "\033[00m"
            << std::endl;
        }
        //      std::cout << "Xin " << fASICGain << " " << fShapingTime << " " << fNoiseFactVec[0] << " " << fNoiseFactVec[1] << std::endl;
                
        CLHEP::RandGaussQ rGauss_Ind(fEngine, 0.0, fNoiseFactVec[0]);
        CLHEP::RandGaussQ rGauss_Col(fEngine, 0.0, fNoiseFactVec[1]);


        for(unsigned int i = 0; i < signalSize; ++i){
          if(view==geo::kU)       { tnoise = rGauss_Ind.fire(); }
          else if (view==geo::kV) { tnoise = rGauss_Ind.fire(); }
          else                    { tnoise = rGauss_Col.fire(); }
          tmpfv = tnoise + fChargeWork_a[i];
          //allow for ADC saturation
          if ( tmpfv > adcsaturation - ped_mean)
            tmpfv = adcsaturation- ped_mean;
          //don't allow for "negative" saturation
          if ( tmpfv < 0 - ped_mean)
            tmpfv = 0- ped_mean;
          adcvec_a[i] = (tmpfv >=0) ? (short) (tmpfv+0.5) : (short) (tmpfv-0.5); 
        }
        if (prepost) {
          for(unsigned int i = 0; i < signalSize; ++i){
            if(view==geo::kU)      { tnoisepre = rGauss_Ind.fire(); tnoisepost = rGauss_Ind.fire(); }
            else if(view==geo::kV) { tnoisepre = rGauss_Ind.fire(); tnoisepost = rGauss_Ind.fire(); }
            else                   { tnoisepre = rGauss_Col.fire(); tnoisepost = rGauss_Col.fire(); }

            tmpfv = tnoisepre + fChargeWorkPreSpill_a[i];
            //allow for ADC saturation
            if ( tmpfv > adcsaturation - ped_mean){
              tmpfv = adcsaturation- ped_mean;
            }
            //don't allow for "negative" saturation
            if ( tmpfv < 0 - ped_mean){
              tmpfv = 0- ped_mean;
            }
            adcvecPreSpill_a[i] = (tmpfv >=0) ? (short) (tmpfv+0.5) : (short) (tmpfv-0.5); 

            tmpfv = tnoisepost + fChargeWorkPostSpill_a[i];
            //allow for ADC saturation
            if ( tmpfv > adcsaturation - ped_mean){
              tmpfv = adcsaturation- ped_mean;
            }
            //don't allow for "negative" saturation
            if ( tmpfv < 0 - ped_mean){
              tmpfv = 0- ped_mean;
            }
            adcvecPostSpill_a[i] = (tmpfv >=0) ? (short) (tmpfv+0.5) : (short) (tmpfv-0.5); 
          }
        }
      }
      else {   // no noise, so just round the values to nearest short ints and store them
        for(unsigned int i = 0; i < signalSize; ++i){
          tmpfv = fChargeWork_a[i];
          //allow for ADC saturation
          if ( tmpfv > adcsaturation- ped_mean )
            tmpfv = adcsaturation- ped_mean;
          //don't allow for "negative" saturation
          if ( tmpfv < 0 - ped_mean)
            tmpfv = 0- ped_mean;
          adcvec_a[i] = (tmpfv >=0) ? (short) (tmpfv+0.5) : (short) (tmpfv-0.5);
        }
        if (prepost) {
          for(unsigned int i = 0; i < signalSize; ++i){
            tmpfv = fChargeWorkPreSpill_a[i];
            //allow for ADC saturation
          if ( tmpfv > adcsaturation - ped_mean)
            tmpfv = adcsaturation- ped_mean;
          //don't allow for "negative" saturation
          if ( tmpfv < 0 - ped_mean) {
            tmpfv = 0- ped_mean; }
            adcvecPreSpill_a[i] = (tmpfv >=0) ? (short) (tmpfv+0.5) : (short) (tmpfv-0.5); 
            tmpfv = fChargeWorkPostSpill_a[i];
            //allow for ADC saturation
          if ( tmpfv > adcsaturation - ped_mean)
            tmpfv = adcsaturation- ped_mean;
          //don't allow for "negative" saturation
          if ( tmpfv < 0 - ped_mean) {
            tmpfv = 0- ped_mean; }
            adcvecPostSpill_a[i] = (tmpfv >=0) ? (short) (tmpfv+0.5) : (short) (tmpfv-0.5); 
          }
        }
      }

      // resize the adcvec to be the correct number of time samples, 
      // just drop the extra samples

      // 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.

      //std::cout << "Channel view: " << view << std::endl;

      adcvec.resize(fNSamplesReadout);
      raw::Compress(adcvec, fCompression, fZeroThreshold, fNearestNeighbor); 
      raw::RawDigit rd(chan, fNSamplesReadout, adcvec, fCompression);
      //rd.SetPedestal(ped_mean);
      adcvec.resize(signalSize);        // Then, resize adcvec back to full length.  Do not initialize to zero (slow)

      if(fSaveEmptyChannel || adcvec[1]>0)
        digcol->push_back(rd);            // add this digit to the collection

      // add the digit to the collection (in-place constructon)
      // digcol->emplace_back(chan, fNSamplesReadout, adcvec, fCompression);
      // adcvec.resize(signalSize);        // Then, resize adcvec back to full length.  Do not initialize to zero (slow)

      // do all this for the prespill and postspill samples if need be
      if (prepost) {
        adcvecPreSpill.resize(fNSamplesReadout);
        adcvecPostSpill.resize(fNSamplesReadout);
        raw::Compress(adcvecPreSpill, fCompression, fZeroThreshold, fNearestNeighbor); 
        raw::Compress(adcvecPostSpill, fCompression, fZeroThreshold, fNearestNeighbor); 
        raw::RawDigit rdPreSpill(chan, fNSamplesReadout, adcvecPreSpill, fCompression);
        raw::RawDigit rdPostSpill(chan, fNSamplesReadout, adcvecPostSpill, fCompression);
        // rdPreSpill.SetPedestal(ped_mean);
        // rdPostSpill.SetPedestal(ped_mean);
        adcvecPreSpill.resize(signalSize);
        adcvecPostSpill.resize(signalSize);

        if(fSaveEmptyChannel || adcvecPreSpill[1]>0)    
          digcolPreSpill->push_back(rdPreSpill);
        if(fSaveEmptyChannel || adcvecPostSpill[1]>0)
          digcolPostSpill->push_back(rdPostSpill);
        // raw::Compress(adcvecPreSpill, fCompression, fZeroThreshold, fNearestNeighbor); 
        // raw::Compress(adcvecPostSpill, fCompression, fZeroThreshold, fNearestNeighbor); 
        // digcolPreSpill->emplace_back(chan, fNSamplesReadout, adcvecPreSpill, fCompression);
        // digcolPostSpill->emplace_back(chan, fNSamplesReadout, adcvecPostSpill, fCompression);
        // adcvecPreSpill.resize(signalSize);
        // adcvecPostSpill.resize(signalSize);
      }

    }// end loop over channels      

    evt.put(std::move(digcol));
    if(prepost) {
      evt.put(std::move(digcolPreSpill), "preSpill");
      evt.put(std::move(digcolPostSpill), "postSpill");
    }

    return;
  }

void detsim::SimWireDUNE10kt::reconfigure

(

fhicl::ParameterSet const &

p

)

Definition at line 144 of file SimWireDUNE10kt_module.cc.

  {
    fDriftEModuleLabel= p.get< std::string         >("DriftEModuleLabel");


    fNoiseFactZ        = p.get< double              >("NoiseFactZ");
    fNoiseWidthZ       = p.get< double              >("NoiseWidthZ");
    fLowCutoffZ        = p.get< double              >("LowCutoffZ");
    fNoiseFactU        = p.get< double              >("NoiseFactU");
    fNoiseWidthU       = p.get< double              >("NoiseWidthU");
    fLowCutoffU        = p.get< double              >("LowCutoffU");
    fNoiseFactV        = p.get< double              >("NoiseFactV");
    fNoiseWidthV       = p.get< double              >("NoiseWidthV");
    fLowCutoffV        = p.get< double              >("LowCutoffV");
    fZeroThreshold    = p.get< unsigned int        >("ZeroThreshold");
    fNearestNeighbor         = p.get< int                 >("NearestNeighbor");
    fNoiseArrayPoints = p.get< unsigned int        >("NoiseArrayPoints");
    fNoiseOn           = p.get< unsigned int       >("NoiseOn");
    fNoiseModel           = p.get< unsigned int       >("NoiseModel");
    fCollectionPed    = p.get< float               >("CollectionPed");
    fInductionPed     = p.get< float               >("InductionPed");
    auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
    auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob(clockData);
    fSampleRate       = sampling_rate(clockData);
    fNSamplesReadout  = detProp.ReadOutWindowSize();
    fNTimeSamples  = detProp.NumberTimeSamples();
    fSaveEmptyChannel    = p.get< bool >("SaveEmptyChannel");  
    return;
  }

Member Data Documentation

const float detsim::SimWireDUNE10kt::adcsaturation = 4095

private

Definition at line 113 of file SimWireDUNE10kt_module.cc.

std::vector<double> detsim::SimWireDUNE10kt::fChargeWork

private

Definition at line 103 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fCollectionPed

private

ADC value of baseline for collection plane.

Definition at line 116 of file SimWireDUNE10kt_module.cc.

raw::Compress_t detsim::SimWireDUNE10kt::fCompression

private

compression type to use

Definition at line 80 of file SimWireDUNE10kt_module.cc.

std::string detsim::SimWireDUNE10kt::fDriftEModuleLabel

private

module making the ionization electrons

Definition at line 79 of file SimWireDUNE10kt_module.cc.

CLHEP::HepRandomEngine& detsim::SimWireDUNE10kt::fEngine

private

Definition at line 118 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fInductionPed

private

ADC value of baseline for induction plane.

Definition at line 117 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fLowCutoff

private

low frequency filter cutoff (kHz)

Definition at line 85 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fLowCutoffU

private

low frequency filter cutoff (kHz) for U plane

Definition at line 91 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fLowCutoffV

private

low frequency filter cutoff (kHz) for V plane

Definition at line 94 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fLowCutoffZ

private

low frequency filter cutoff (kHz) for Z (collection) plane

Definition at line 88 of file SimWireDUNE10kt_module.cc.

int detsim::SimWireDUNE10kt::fNearestNeighbor

private

Maximum distance between hits above threshold before they are separated into different blocks.

Definition at line 96 of file SimWireDUNE10kt_module.cc.

unsigned int detsim::SimWireDUNE10kt::fNoiseArrayPoints

private

number of points in randomly generated noise array

Definition at line 101 of file SimWireDUNE10kt_module.cc.

TH1D* detsim::SimWireDUNE10kt::fNoiseDist

private

distribution of noise counts

Definition at line 109 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fNoiseFact

private

noise scale factor

Definition at line 83 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fNoiseFactU

private

noise scale factor for U plane

Definition at line 89 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fNoiseFactV

private

noise scale factor for V plane

Definition at line 92 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fNoiseFactZ

private

noise scale factor for Z (collection) plane

Definition at line 86 of file SimWireDUNE10kt_module.cc.

unsigned int detsim::SimWireDUNE10kt::fNoiseModel

private

noise model

Definition at line 82 of file SimWireDUNE10kt_module.cc.

unsigned int detsim::SimWireDUNE10kt::fNoiseOn

private

noise turned on or off for debugging; default is on

Definition at line 81 of file SimWireDUNE10kt_module.cc.

std::vector< std::vector<float> > detsim::SimWireDUNE10kt::fNoiseU

private

noise on each channel for each time for U plane

Definition at line 106 of file SimWireDUNE10kt_module.cc.

std::vector< std::vector<float> > detsim::SimWireDUNE10kt::fNoiseV

private

noise on each channel for each time for V plane

Definition at line 107 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fNoiseWidth

private

exponential noise width (kHz)

Definition at line 84 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fNoiseWidthU

private

exponential noise width (kHz) for U plane

Definition at line 90 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fNoiseWidthV

private

exponential noise width (kHz) for V plane

Definition at line 93 of file SimWireDUNE10kt_module.cc.

float detsim::SimWireDUNE10kt::fNoiseWidthZ

private

exponential noise width (kHz) for Z (collection) plane

Definition at line 87 of file SimWireDUNE10kt_module.cc.

std::vector< std::vector<float> > detsim::SimWireDUNE10kt::fNoiseZ

private

noise on each channel for each time for Z (collection) plane

Definition at line 105 of file SimWireDUNE10kt_module.cc.

unsigned int detsim::SimWireDUNE10kt::fNSamplesReadout

private

number of ADC readout samples in 1 readout frame

Definition at line 99 of file SimWireDUNE10kt_module.cc.

int detsim::SimWireDUNE10kt::fNTicks

private

number of ticks of the clock

Definition at line 97 of file SimWireDUNE10kt_module.cc.

unsigned int detsim::SimWireDUNE10kt::fNTimeSamples

private

number of ADC readout samples in all readout frames (per event)

Definition at line 100 of file SimWireDUNE10kt_module.cc.

double detsim::SimWireDUNE10kt::fSampleRate

private

sampling rate in ns

Definition at line 98 of file SimWireDUNE10kt_module.cc.

bool detsim::SimWireDUNE10kt::fSaveEmptyChannel

private

Definition at line 115 of file SimWireDUNE10kt_module.cc.

unsigned int detsim::SimWireDUNE10kt::fZeroThreshold

private

Zero suppression threshold.

Definition at line 95 of file SimWireDUNE10kt_module.cc.

---

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

• dunesim/dunesim/DetSim/SimWireDUNE10kt_module.cc