#include <AdcMultiThreshSignalFinder.h>

Inheritance diagram for AdcMultiThreshSignalFinder:

Classes
struct	ROICandidate_t

Public Member Functions
	AdcMultiThreshSignalFinder (fhicl::ParameterSet const &ps)

	~AdcMultiThreshSignalFinder () override

DataMap	update (AdcChannelData &acd) const override

Private Attributes
int	m_LogLevel

bool	m_UseStd

AdcSignal	m_Thresh1

AdcIndex	m_NsaAbove1

AdcSignal	m_Thresh2

AdcIndex	m_NsaAbove2

AdcSignal	m_ThreshMax

AdcSignal	m_ThreshMin

AdcIndex	m_BinsBefore

AdcIndex	m_BinsAfter

Additional Inherited Members
Private Types inherited from AdcChannelTool
using	Index = unsigned int

Private Member Functions inherited from TpcDataTool
virtual DataMap	updateTpcData (TpcData &) const

virtual DataMap	viewTpcData (const TpcData &) const

virtual int	forwardTpcData () const

Private Member Functions inherited from AdcChannelTool
virtual	~AdcChannelTool ()=default

virtual DataMap	view (const AdcChannelData &acd) const

virtual DataMap	updateMap (AdcChannelDataMap &acds) const

virtual DataMap	viewMap (const AdcChannelDataMap &acds) const

virtual bool	updateWithView () const

virtual bool	viewWithUpdate () const

virtual DataMap	beginEvent (const DuneEventInfo &) const

virtual DataMap	endEvent (const DuneEventInfo &) const

virtual DataMap	close (const DataMap *dmin=nullptr)

Static Private Member Functions inherited from AdcChannelTool
static int	interfaceNotImplemented ()

Detailed Description

Definition at line 30 of file AdcMultiThreshSignalFinder.h.

Constructor & Destructor Documentation

AdcMultiThreshSignalFinder::AdcMultiThreshSignalFinder ( fhicl::ParameterSet const & ps )

Definition at line 45 of file AdcMultiThreshSignalFinder_tool.cc.

                                                                                  : 
   m_LogLevel(ps.get<int>("LogLevel")), 
   m_UseStd(ps.get<bool>("UseStandardDeviation")),
   m_Thresh1(ps.get<AdcSignal>("Threshold1")),
   m_NsaAbove1(ps.get<AdcIndex>("SamplesAboveThreshold1")),
   m_Thresh2(ps.get<AdcSignal>("Threshold2")),
   m_NsaAbove2(ps.get<AdcIndex>("SamplesAboveThreshold2")),
   m_ThreshMax(ps.get<AdcSignal>("ThresholdMax")),
   m_ThreshMin(ps.get<AdcSignal>("ThresholdMin")),
   m_BinsBefore(ps.get<AdcIndex>("BinsBefore")),
   m_BinsAfter(ps.get<AdcIndex>("BinsAfter")) {
   const string myname = "AdcMultiThreshSignalFinder::ctor: ";
   if ( m_LogLevel > 0 ) {
     cout << myname << "          Configuration: " << endl;
     cout << myname << "               LogLevel: " << m_LogLevel   << endl;
     cout << myname << "   UseStandardDeviation: " << m_UseStd     << endl;
     cout << myname << "             Threshold1: " << m_Thresh1    << endl;
     cout << myname << " SamplesAboveThreshold1: " << m_NsaAbove1  << endl;
     cout << myname << "             Threshold2: " << m_Thresh2    << endl;
     cout << myname << " SamplesAboveThreshold2: " << m_NsaAbove2  << endl;
     cout << myname << "           ThresholdMax: " << m_ThreshMax  << endl;
     cout << myname << "           ThresholdMin: " << m_ThreshMin  << endl;
     cout << myname << "             BinsBefore: " << m_BinsBefore << endl;
     cout << myname << "              BinsAfter: " << m_BinsAfter  << endl;
   }
 }

AdcMultiThreshSignalFinder::~AdcMultiThreshSignalFinder ( )

override

Definition at line 75 of file AdcMultiThreshSignalFinder_tool.cc.

75 {

76 }

Member Function Documentation

DataMap AdcMultiThreshSignalFinder::update ( AdcChannelData & acd ) const

overridevirtual

Reimplemented from AdcChannelTool.

Definition at line 80 of file AdcMultiThreshSignalFinder_tool.cc.

                                                                      {
   const string myname = "AdcMultiThreshSignalFinder:build: ";
   if ( m_LogLevel >= 2 ) cout << myname << "Building ROIs for channel "
                               << data.channel() << "." << endl;
   data.rois.clear();
   
   //Create dummy DataMap to return
   DataMap res(0);
   res.setInt("Test", 0);
 
   //Raw ADC.
   AdcSignalVector sigs;
   sigs = data.samples;
 
   // Build ROIs before padding and merging.
   AdcFilterVector& signal = data.signal;
   AdcRoiVector& rois      = data.rois;
   signal.clear();
   signal.resize(sigs.size(), false);
 
   AdcSignal sigth1   = m_Thresh1;
   AdcSignal sigth2   = m_Thresh2;
   AdcSignal sigthmax = m_ThreshMax;
   AdcSignal sigthmin = m_ThreshMin;
   AdcIndex nsig      = sigs.size();
 
   if ( nsig < 1 ) {
     if ( m_LogLevel >= 2 ) cout << myname << "Channel " << data.channel()
                                 << " has no samples." << endl;
     return res;
   }
 
   AdcSignal ped    = data.pedestal;
   AdcSignal pedrms = data.pedestalRms;
 
   if( m_LogLevel >= 2 )
     cout << myname << "Channel "<< data.channel()
          << " pedestal "<<ped<<" "<<pedrms << endl;
 
   if(m_UseStd)
   {
     if( ped == AdcChannelData::badSignal() )
       {
         cout << myname << "  Channel "<< data.channel()
              <<" pedestal is not valid" << endl;
         return res;
 
       }
 
     // sligthly increase if 0
     if( pedrms == 0 ) pedrms = 0.1;
     
     sigth1   = m_Thresh1 * pedrms;
     sigth2   = m_Thresh2 * pedrms;
     sigthmax = m_ThreshMax * pedrms;
     sigthmin = m_ThreshMin * pedrms;
   }
 
   if( m_LogLevel >= 3 )
     {
       cout << myname << "  sigth1:   " << sigth1   << endl;
       cout << myname << "  sigth2:   " << sigth2   << endl;
       cout << myname << "  sigthmax: " << sigthmax << endl;
       cout << myname << "  sigthmin: " << sigthmin << endl;
     }
   
   ROICandidate_t roiCandidate;
   roiCandidate.init();
   AdcIndex nsaTh2 = 0;
   AdcIndex nsaTh3 = 0;
   
   // loop over samples
   for( AdcIndex isig=0; isig<nsig; ++isig ) 
     {
       AdcSignal sig = sigs[isig];
 
       if( sig >= sigth1 )
         {
           if( !roiCandidate.isRoi )
             {
               roiCandidate.isRoi    = true;
               roiCandidate.StartRoi = isig;
             }
           
           if( sig > roiCandidate.MaxValue )
             roiCandidate.MaxValue = sig;
 
           roiCandidate.NsaTh1++;
           roiCandidate.EndRoi = isig;
           
           //
           if( sig >= sigth2 )
             {
               nsaTh2++;
               if( nsaTh2 > roiCandidate.NsaTh2 )
                 roiCandidate.NsaTh2 = nsaTh2;
             }
           else
             {
               if( nsaTh2 > roiCandidate.NsaTh2 )
                 roiCandidate.NsaTh2 = nsaTh2;
               nsaTh2 = 0;
             }
           
           //
           if( sig >= sigthmax )
             {
               nsaTh3++;
               if( nsaTh3 > roiCandidate.NsaTh3 )
                 roiCandidate.NsaTh3 = nsaTh3;
             }
           else
             {
               if( nsaTh3 > roiCandidate.NsaTh3 )
                 roiCandidate.NsaTh3 = nsaTh3;
               nsaTh3 = 0;
             }
           
           continue; // go to a next ADC sample
         }
       
       // else ... check and finalize an ROI candidate
       if( roiCandidate.isRoi ) 
         {
           // check that we meet all the cut requirements
           bool ok = (( roiCandidate.NsaTh1 >= m_NsaAbove1 ) && 
                      ( roiCandidate.NsaTh2 >= m_NsaAbove2 ) && 
                      ( roiCandidate.NsaTh3 >= 1 ));
           
           
           if( ok ) // finalize ROI
             {
               if( m_LogLevel >= 3 )
                 {
                   cout<< myname <<" Candidate: "
                       <<roiCandidate.NsaTh1<<" "
                       <<roiCandidate.NsaTh2<<" "
                       <<roiCandidate.NsaTh3<<" "
                       <<roiCandidate.MaxValue<<endl;
                 }
           
               // expand roi until we pass the min theshold
               // use only signed int to move backwards to avoid infinit loop when at 0
               int istart = (int)roiCandidate.StartRoi;
               for( int ii=istart; ii>=0; --ii )
                 {
                   if( sigs[ii] <= m_ThreshMin ) break;
                   if( roiCandidate.StartRoi>0 ) roiCandidate.StartRoi--;
                 } 
               for( AdcIndex ii = roiCandidate.EndRoi; ii < nsig; ++ii)
                 {
                   if( sigs[ii] <= m_ThreshMin ) break;
                   roiCandidate.EndRoi++;
                 }
 
               
               // pad ROI
               roiCandidate.StartRoi = roiCandidate.StartRoi > m_BinsBefore ? roiCandidate.StartRoi-m_BinsBefore : 0;
               
               roiCandidate.EndRoi += m_BinsAfter;
               if( roiCandidate.EndRoi >= nsig )
                 roiCandidate.EndRoi = nsig - 1;
               
               // flag the ROIs
               for(AdcIndex isigroi = roiCandidate.StartRoi; 
                   isigroi <= roiCandidate.EndRoi; ++isigroi)
                 {
                   signal[isigroi] = true;
                 }
             }
         }
       
       // clear everything
       roiCandidate.init(); 
       nsaTh2 = 0; nsaTh3 = 0;
     } // end of sample loop
       
   
   // Fill from ROIs.
   data.roisFromSignal();
   
   // Display final ROIs.
   if ( m_LogLevel >= 3 ) 
     {
       cout << myname << "  ROIs (size = " << rois.size() << "):" << endl;
       for ( const AdcRoi& roi : rois ) {
         cout << myname << setw(8) << roi.first << " " << setw(8) << roi.second << endl;
       }
     } 
   else if ( m_LogLevel >= 2 ) 
     {
       cout << myname << "  ROI count: " << data.rois.size() << endl;
     }
   
   //
   return res;
 }