Inheritance diagram for caldata::CalWireDUNEDPhase:

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

virtual	~CalWireDUNEDPhase ()

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	SubtractBaseline (std::vector< float > &holder)

Private Attributes
int	fPostsample
	number of postsample bins More...

int	fDoBaselineSub
	number of postsample bins More...

std::string	fDigitModuleLabel
	constants More...

std::string	fSpillName

unsigned short	fPreROIPad
	ROI padding. More...

unsigned short	fPostROIPad
	ROI padding. More...

double	fSigThrFact
	Signal shreshold factor. More...

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 47 of file CalWireDUNEDPhase_module.cc.

Constructor & Destructor Documentation

caldata::CalWireDUNEDPhase::CalWireDUNEDPhase ( fhicl::ParameterSet const & pset )

explicit

Definition at line 82 of file CalWireDUNEDPhase_module.cc.

                                                                     : EDProducer{pset}
   {
     this->reconfigure(pset);
 
     produces< std::vector<recob::Wire> >(fSpillName);
     produces<art::Assns<raw::RawDigit, recob::Wire>>(fSpillName);
   }

caldata::CalWireDUNEDPhase::~CalWireDUNEDPhase ( )

virtual

Definition at line 91 of file CalWireDUNEDPhase_module.cc.

92 {

93 }

Member Function Documentation

void caldata::CalWireDUNEDPhase::beginJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 120 of file CalWireDUNEDPhase_module.cc.

121 {

122 }

void caldata::CalWireDUNEDPhase::endJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 125 of file CalWireDUNEDPhase_module.cc.

126 {

127 }

void caldata::CalWireDUNEDPhase::produce ( art::Event & evt )

virtual

Implements art::EDProducer.

Definition at line 130 of file CalWireDUNEDPhase_module.cc.

   {      
     // get the geometry
     // art::ServiceHandle<geo::Geometry> geom;
 
     // get the FFT service to have access to the FFT size
     art::ServiceHandle<util::LArFFT> fFFT;
     int transformSize = fFFT->FFTSize();
 
     // Get signal shaping service.
     art::ServiceHandle<util::SignalShapingServiceDUNEDPhase> sss;
     double DeconNorm = sss->GetDeconNorm();
     
     // make a collection of Wires
     std::unique_ptr<std::vector<recob::Wire> > wirecol(new std::vector<recob::Wire>);
     // ... and an association set
     std::unique_ptr<art::Assns<raw::RawDigit,recob::Wire> > WireDigitAssn
       (new art::Assns<raw::RawDigit,recob::Wire>);
     
     // Read in the digit List object(s). 
     art::InputTag itag1(fDigitModuleLabel, fSpillName);
     auto digitVecHandle = evt.getHandle< std::vector<raw::RawDigit> >(itag1);
 
     // if (!digitVecHandle->size()) return;
     if (digitVecHandle->size())
     {
     mf::LogInfo("CalWireDUNEDPhase") << "CalWireDUNEDPhase:: digitVecHandle size is " << digitVecHandle->size();
 
     // Use the handle to get a particular (0th) element of collection.
     art::Ptr<raw::RawDigit> digitVec0(digitVecHandle, 0);
         
     unsigned int dataSize = digitVec0->Samples(); //size of raw data vectors
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
     auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt, clockData);
     int readoutwindowsize = detProp.ReadOutWindowSize();
     if (int(dataSize) != readoutwindowsize){
       throw art::Exception(art::errors::Configuration)
         << "ReadOutWindowSize "<<readoutwindowsize<<" does not match data size "<<dataSize<<". Please set services.DetectorPropertiesService.NumberTimeSamples and services.DetectorPropertiesService.ReadOutWindowSize in fcl file to "<<dataSize;
     }
      
     raw::ChannelID_t channel = raw::InvalidChannelID; // channel number
     unsigned int bin(0);     // time bin loop variable
     
     filter::ChannelFilter *chanFilt = new filter::ChannelFilter();  
 
     std::vector<float> holder;                // holds signal data
     std::vector<short> rawadc(transformSize);  // vector holding uncompressed adc values
     std::vector<TComplex> freqHolder(transformSize+1); // temporary frequency data
     
     // loop over all wires    
     wirecol->reserve(digitVecHandle->size());
     for(size_t rdIter = 0; rdIter < digitVecHandle->size(); ++rdIter){ // ++ move
       holder.clear();
       
       // get the reference to the current raw::RawDigit
       art::Ptr<raw::RawDigit> digitVec(digitVecHandle, rdIter);
       channel = digitVec->Channel();
 
       // skip bad channels
       if(!chanFilt->BadChannel(channel)) {
         holder.resize(transformSize);
         
         // uncompress the data
         raw::Uncompress(digitVec->ADCs(), rawadc, digitVec->Compression());
         
         // loop over all adc values and subtract the pedestal
         for(bin = 0; bin < dataSize; ++bin) 
           holder[bin]=(rawadc[bin]-digitVec->GetPedestal());
         //Xin fill the remaining bin with data
         for (bin = dataSize;bin<holder.size();bin++){
           holder[bin] = (rawadc[bin-dataSize]-digitVec->GetPedestal());
         }
 
         // Do deconvolution.
         sss->Deconvolute(clockData, channel, holder);
         for(bin = 0; bin < holder.size(); ++bin) holder[bin]=holder[bin]/DeconNorm;
       } // end if not a bad channel 
       
       holder.resize(dataSize,1e-5);
 
       //This restores the DC component to signal removed by the deconvolution.
       if(fPostsample) {
         double average=0.0;
         for(bin=0; bin < (unsigned int)fPostsample; ++bin) 
           average+=holder[holder.size()-1-bin]/(double)fPostsample;
         for(bin = 0; bin < holder.size(); ++bin) holder[bin]-=average;
       }  
        // adaptive baseline subtraction
       if(fDoBaselineSub) SubtractBaseline(holder);
       
       // work out the ROI 
       recob::Wire::RegionsOfInterest_t ROIVec;
       std::vector<std::pair<unsigned int, unsigned int>> holderInfo;
       std::vector<std::pair<unsigned int, unsigned int>> rois;
       
       double max = 0;
       double deconNoise = sss->GetDeconNoise(channel);
       // find out all ROI
       unsigned int roiStart = 0;
       for(bin = 0; bin < dataSize; ++bin) {
         double SigVal = holder[bin];
         if (SigVal > max) max = SigVal;
         if(roiStart == 0) {
           if (SigVal > fSigThrFact*deconNoise) roiStart = bin; // n sigma above noise
         }else{
           if (SigVal < deconNoise){
             rois.push_back(std::make_pair(roiStart, bin));
             roiStart = 0;
           }
         }
       }
       if (roiStart!=0){
         rois.push_back(std::make_pair(roiStart, dataSize-1));
         roiStart = 0;
       }
       
       // pad them
       // if (channel==512){
       //        for (bin = 0; bin< holder.size();++bin){
       //          if (fabs(holder[bin]) > 2)
       //              std::cout << "Xin1: " << holder[bin] << std::endl;
       //        }
       // }
       //std::cout << "Xin: "  << max << " "<< channel << " " << deconNoise << " " << rois.size() << std::endl;
 
       if(rois.size() == 0) continue;
       holderInfo.clear();
       for(unsigned int ii = 0; ii < rois.size(); ++ii) {
         // low ROI end
         int low = rois[ii].first - fPreROIPad;
         if(low < 0) low = 0;
         rois[ii].first = low;
         // high ROI end
         unsigned int high = rois[ii].second + fPostROIPad;
         if(high >= dataSize) high = dataSize-1;
         rois[ii].second = high;
         
       }
       // merge them
       if(rois.size() >= 1) {
         // temporary vector for merged ROIs
                 
         for (unsigned int ii = 0; ii<rois.size();ii++){
           unsigned int roiStart = rois[ii].first;
           unsigned int roiEnd = rois[ii].second;
                   
           int flag1 = 1;
           unsigned int jj=ii+1;
           while(flag1){ 
             if (jj<rois.size()){
               if(rois[jj].first <= roiEnd  ) {
                 roiEnd = rois[jj].second;
                 ii = jj;
                 jj = ii+1;
               }else{
                 flag1 = 0;
               }
             }else{
               flag1 = 0;
             }
           }
           std::vector<float> sigTemp;
           for(unsigned int kk = roiStart; kk < roiEnd; ++kk) {
             sigTemp.push_back(holder[kk]);
           } // jj
           //      std::cout << "Xin: " << roiStart << std::endl;
           ROIVec.add_range(roiStart, std::move(sigTemp));
           //trois.push_back(std::make_pair(roiStart,roiEnd));       
         }
       }// else{
       //        unsigned int roiStart = rois[0].first;
       //        unsigned int roiEnd = rois[0].second;
       //        std::vector<float> sigTemp;
       //          for(unsigned int kk = roiStart; kk < roiEnd; ++kk) {
       //            sigTemp.push_back(holder[kk]);
       //          } // jj
       //          //      std::cout << "Xin: " << roiStart << std::endl;
       //          ROIVec.add_range(roiStart, std::move(sigTemp));
       // }
       
       // save them
       wirecol->push_back(recob::WireCreator(std::move(ROIVec),*digitVec).move());
 
 
 
 
       // Make a single ROI that spans the entire data size
       //wirecol->push_back(recob::WireCreator(holder,*digitVec).move());
       // add an association between the last object in wirecol
       // (that we just inserted) and digitVec
       if (!util::CreateAssn(*this, evt, *wirecol, digitVec, *WireDigitAssn, fSpillName)) {
         throw art::Exception(art::errors::ProductRegistrationFailure)
           << "Can't associate wire #" << (wirecol->size() - 1)
           << " with raw digit #" << digitVec.key();
       } // if failed to add association
     }
     
     if(wirecol->size() == 0)
       mf::LogWarning("CalWireDUNEDPhase") << "No wires made for this event.";
 
 
 
         delete chanFilt;
    }
     evt.put(std::move(wirecol), fSpillName);
     evt.put(std::move(WireDigitAssn), fSpillName);
 
     return;
   }

void caldata::CalWireDUNEDPhase::reconfigure ( fhicl::ParameterSet const & p )

Definition at line 96 of file CalWireDUNEDPhase_module.cc.

   {
     std::vector<unsigned short> uin;    // std::vector<unsigned short> vin;
     // std::vector<unsigned short> zin;
 
     fDigitModuleLabel = p.get< std::string >("DigitModuleLabel", "daq");
     fPostsample       = p.get< int >        ("PostsampleBins");
     fDoBaselineSub    = p.get< bool >       ("DoBaselineSub");
     uin               = p.get< std::vector<unsigned short> >   ("PlaneROIPad");
     fSigThrFact       = p.get< double>      ("SigThrFact", 3.0);
      // put the ROI pad sizes into more convenient vectors
     fPreROIPad  = uin[0];
     fPostROIPad = uin[1];
     fSpillName.clear();
     
     size_t pos = fDigitModuleLabel.find(":");
     if( pos!=std::string::npos ) {
       fSpillName = fDigitModuleLabel.substr( pos+1 );
       fDigitModuleLabel = fDigitModuleLabel.substr( 0, pos );
     }
     
   }

void caldata::CalWireDUNEDPhase::SubtractBaseline ( std::vector< float > & holder )

private

Definition at line 340 of file CalWireDUNEDPhase_module.cc.

   {
     
     float min = 0,max=0;
     for (unsigned int bin = 0; bin < holder.size(); bin++){
       if (holder[bin] > max) max = holder[bin];
       if (holder[bin] < min) min = holder[bin];
     }
     int nbin = max - min;
     if (nbin!=0){
       TH1F *h1 = new TH1F("h1","h1",nbin,min,max);
       for (unsigned int bin = 0; bin < holder.size(); bin++){
         h1->Fill(holder[bin]);
       }
       float ped = h1->GetMaximum();
       float ave=0,ncount = 0;
       for (unsigned int bin = 0; bin < holder.size(); bin++){
         if (fabs(holder[bin]-ped)<2){
           ave +=holder[bin];
           ncount ++;
         }
       }
       if (ncount==0) ncount=1;
       ave = ave/ncount;
       for (unsigned int bin = 0; bin < holder.size(); bin++){
         holder[bin] -= ave;
       }
       h1->Delete();
     }
   }