daq::TPCDecoderFilter1D Class Reference

TPCDecoderFilter1D class definiton. More...

Inheritance diagram for daq::TPCDecoderFilter1D:

Public Member Functions
	TPCDecoderFilter1D (fhicl::ParameterSet const &pset)
	Constructor. More...
	~TPCDecoderFilter1D ()
	Destructor. More...
virtual void	configure (const fhicl::ParameterSet &) override
	Interface for configuring the particular algorithm tool. More...
virtual void	process_fragment (detinfo::DetectorClocksData const &, const artdaq::Fragment &) override
	Given a set of recob hits, run DBscan to form 3D clusters. More...
const icarus_signal_processing::VectorInt	getChannelIDs () const override
	Recover the channels for the processed fragment. More...
const icarus_signal_processing::ArrayBool	getSelectionVals () const override
	Recover the selection values. More...
const icarus_signal_processing::ArrayBool	getROIVals () const override
	Recover the ROI values. More...
const icarus_signal_processing::ArrayFloat	getRawWaveforms () const override
	Recover the pedestal subtracted waveforms. More...
const icarus_signal_processing::ArrayFloat	getPedCorWaveforms () const override
	Recover the pedestal subtracted waveforms. More...
const icarus_signal_processing::ArrayFloat	getIntrinsicRMS () const override
	Recover the "intrinsic" RMS. More...
const icarus_signal_processing::ArrayFloat	getCorrectedMedians () const override
	Recover the correction median values. More...
const icarus_signal_processing::ArrayFloat	getWaveLessCoherent () const override
	Recover the waveforms less coherent noise. More...
const icarus_signal_processing::ArrayFloat	getMorphedWaveforms () const override
	Recover the morphological filter waveforms. More...
const icarus_signal_processing::VectorFloat	getPedestalVals () const override
	Recover the pedestals for each channel. More...
const icarus_signal_processing::VectorFloat	getFullRMSVals () const override
	Recover the full RMS before coherent noise. More...
const icarus_signal_processing::VectorFloat	getTruncRMSVals () const override
	Recover the truncated RMS noise. More...
const icarus_signal_processing::VectorInt	getNumTruncBins () const override
	Recover the number of bins after truncation. More...
Public Member Functions inherited from daq::IDecoderFilter
virtual	~IDecoderFilter () noexcept=default
	Virtual Destructor. More...

Private Types
using	FloatPairVec = std::vector< std::pair< float, float >>
using	FragmentIDPair = std::pair< unsigned int, unsigned int >
using	FragmentIDVec = std::vector< FragmentIDPair >
using	FragmentIDMap = std::map< unsigned int, unsigned int >

Private Attributes
uint32_t	fFragment_id_offset
float	fSigmaForTruncation
size_t	fCoherentNoiseGrouping
size_t	fCoherentNoiseOffset
size_t	fStructuringElement
size_t	fMorphWindow
std::vector< float >	fThreshold
bool	fUseFFTFilter
bool	fDiagnosticOutput
FloatPairVec	fFFTSigmaValsVec
FloatPairVec	fFFTCutoffValsVec
std::vector< std::string >	fFilterModeVec
FragmentIDMap	fFragmentIDMap
icarus_signal_processing::VectorInt	fChannelIDVec
icarus_signal_processing::ArrayBool	fSelectVals
icarus_signal_processing::ArrayBool	fROIVals
icarus_signal_processing::ArrayFloat	fRawWaveforms
icarus_signal_processing::ArrayFloat	fPedCorWaveforms
icarus_signal_processing::ArrayFloat	fIntrinsicRMS
icarus_signal_processing::ArrayFloat	fCorrectedMedians
icarus_signal_processing::ArrayFloat	fWaveLessCoherent
icarus_signal_processing::ArrayFloat	fMorphedWaveforms
icarus_signal_processing::VectorFloat	fPedestalVals
icarus_signal_processing::VectorFloat	fFullRMSVals
icarus_signal_processing::VectorFloat	fTruncRMSVals
icarus_signal_processing::VectorInt	fNumTruncBins
icarus_signal_processing::VectorInt	fRangeBins
icarus_signal_processing::VectorFloat	fThresholdVec
icarus_signal_processing::FilterFunctionVec	fFilterFunctionVec
const geo::Geometry *	fGeometry
const icarusDB::IICARUSChannelMap *	fChannelMap
icarus_signal_processing::FFTFilterFunctionVec	fFFTFilterFunctionVec

Detailed Description

TPCDecoderFilter1D class definiton.

Definition at line 44 of file TPCDecoderFilter1D_tool.cc.

Member Typedef Documentation

using daq::TPCDecoderFilter1D::FloatPairVec = std::vector<std::pair<float,float>>

private

Definition at line 141 of file TPCDecoderFilter1D_tool.cc.

using daq::TPCDecoderFilter1D::FragmentIDMap = std::map<unsigned int, unsigned int>

private

Definition at line 159 of file TPCDecoderFilter1D_tool.cc.

using daq::TPCDecoderFilter1D::FragmentIDPair = std::pair<unsigned int, unsigned int>

private

Definition at line 157 of file TPCDecoderFilter1D_tool.cc.

using daq::TPCDecoderFilter1D::FragmentIDVec = std::vector<FragmentIDPair>

private

Definition at line 158 of file TPCDecoderFilter1D_tool.cc.

Constructor & Destructor Documentation

daq::TPCDecoderFilter1D::TPCDecoderFilter1D ( fhicl::ParameterSet const &  pset )

explicit

Constructor.

Parameters

pset

Definition at line 192 of file TPCDecoderFilter1D_tool.cc.

{
    std::cout << "TPCDecoderFilter1D is calling configure method" << std::endl;
    this->configure(pset);

    fSelectVals.clear();
    fROIVals.clear();
    fRawWaveforms.clear();
    fPedCorWaveforms.clear();
    fIntrinsicRMS.clear();
    fCorrectedMedians.clear();
    fWaveLessCoherent.clear();
    fMorphedWaveforms.clear();

    fPedestalVals.clear();
    fFullRMSVals.clear();
    fTruncRMSVals.clear();
    fNumTruncBins.clear();
    fRangeBins.clear();

    return;
}

daq::TPCDecoderFilter1D::~TPCDecoderFilter1D

(

)

Destructor.

Definition at line 217 of file TPCDecoderFilter1D_tool.cc.

{
}

Member Function Documentation

void daq::TPCDecoderFilter1D::configure ( const fhicl::ParameterSet &  pset )

overridevirtual

Interface for configuring the particular algorithm tool.

Parameters

ParameterSet

The input set of parameters for configuration

Implements daq::IDecoderFilter.

Definition at line 222 of file TPCDecoderFilter1D_tool.cc.

{
    fFragment_id_offset    = pset.get<uint32_t                >("fragment_id_offset"      );
    fSigmaForTruncation    = pset.get<float                   >("NSigmaForTrucation",  3.5);
    fCoherentNoiseGrouping = pset.get<size_t                  >("CoherentGrouping",     64);
    fCoherentNoiseOffset   = pset.get<size_t                  >("CoherentOffset",        0);
    fStructuringElement    = pset.get<size_t                  >("StructuringElement",   20);
    fMorphWindow           = pset.get<size_t                  >("FilterWindow",         10);
    fThreshold             = pset.get<std::vector<float>      >("Threshold",           std::vector<float>()={5.0,3.5,3.5});
    fUseFFTFilter          = pset.get<bool                    >("UseFFTFilter",        true);
    fDiagnosticOutput      = pset.get<bool                    >("DiagnosticOutput",    false);
    fFilterModeVec         = pset.get<std::vector<std::string>>("FilterModeVec",       std::vector<std::string>()={"e","g","d"});

    fFFTSigmaValsVec       = pset.get<FloatPairVec            >("FFTSigmaVals",        FloatPairVec()={{1.5,20.}, {1.5,20.}, {2.0,20.}});
    fFFTCutoffValsVec      = pset.get<FloatPairVec            >("FFTCutoffVals",       FloatPairVec()={{8.,800.}, {8.,800.}, {0.0,800.}});

    FragmentIDVec tempIDVec = pset.get< FragmentIDVec >("FragmentIDVec", FragmentIDVec());

    for(const auto& idPair : tempIDVec) fFragmentIDMap[idPair.first] = idPair.second;

    fGeometry   = art::ServiceHandle<geo::Geometry const>{}.get();
    fChannelMap = art::ServiceHandle<icarusDB::IICARUSChannelMap const>{}.get();

    fFFTFilterFunctionVec.clear();

    if (fUseFFTFilter)
    {
        for(int plane = 0; plane < 3; plane++)
        {
            if (plane < 3) fFFTFilterFunctionVec.emplace_back(std::make_unique<icarus_signal_processing::WindowFFTFilter>(fFFTSigmaValsVec[plane], fFFTCutoffValsVec[plane]));
            else           fFFTFilterFunctionVec.emplace_back(std::make_unique<icarus_signal_processing::NoFFTFilter>());

            mf::LogInfo("TPCDecoderFilter1D") << "FFT setup for plane " << plane << ", SigmaVals: " << fFFTSigmaValsVec[plane].first << "/" << fFFTSigmaValsVec[plane].second << ", cutoff: " << fFFTCutoffValsVec[plane].first << "/" << fFFTCutoffValsVec[plane].second << std::endl;
        }
    }

    return;
}

const icarus_signal_processing::VectorInt daq::TPCDecoderFilter1D::getChannelIDs ( ) const

inlineoverridevirtual

Recover the channels for the processed fragment.

Implements daq::IDecoderFilter.

Definition at line 77 of file TPCDecoderFilter1D_tool.cc.

{return fChannelIDVec;}

const icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::getCorrectedMedians ( ) const

inlineoverridevirtual

Recover the correction median values.

Implements daq::IDecoderFilter.

Definition at line 107 of file TPCDecoderFilter1D_tool.cc.

{return fCorrectedMedians;};

const icarus_signal_processing::VectorFloat daq::TPCDecoderFilter1D::getFullRMSVals ( ) const

inlineoverridevirtual

Recover the full RMS before coherent noise.

Implements daq::IDecoderFilter.

Definition at line 127 of file TPCDecoderFilter1D_tool.cc.

{return fFullRMSVals;};

const icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::getIntrinsicRMS ( ) const

inlineoverridevirtual

Recover the "intrinsic" RMS.

Implements daq::IDecoderFilter.

Definition at line 102 of file TPCDecoderFilter1D_tool.cc.

{return fIntrinsicRMS;};

const icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::getMorphedWaveforms ( ) const

inlineoverridevirtual

Recover the morphological filter waveforms.

Implements daq::IDecoderFilter.

Definition at line 117 of file TPCDecoderFilter1D_tool.cc.

{return fMorphedWaveforms;};

const icarus_signal_processing::VectorInt daq::TPCDecoderFilter1D::getNumTruncBins ( ) const

inlineoverridevirtual

Recover the number of bins after truncation.

Implements daq::IDecoderFilter.

Definition at line 137 of file TPCDecoderFilter1D_tool.cc.

{return fNumTruncBins;};

const icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::getPedCorWaveforms ( ) const

inlineoverridevirtual

Recover the pedestal subtracted waveforms.

Implements daq::IDecoderFilter.

Definition at line 97 of file TPCDecoderFilter1D_tool.cc.

{return fPedCorWaveforms;};

const icarus_signal_processing::VectorFloat daq::TPCDecoderFilter1D::getPedestalVals ( ) const

inlineoverridevirtual

Recover the pedestals for each channel.

Implements daq::IDecoderFilter.

Definition at line 122 of file TPCDecoderFilter1D_tool.cc.

{return fPedestalVals;};

const icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::getRawWaveforms ( ) const

inlineoverridevirtual

Recover the pedestal subtracted waveforms.

Implements daq::IDecoderFilter.

Definition at line 92 of file TPCDecoderFilter1D_tool.cc.

{return fRawWaveforms;};

const icarus_signal_processing::ArrayBool daq::TPCDecoderFilter1D::getROIVals ( ) const

inlineoverridevirtual

Recover the ROI values.

Implements daq::IDecoderFilter.

Definition at line 87 of file TPCDecoderFilter1D_tool.cc.

{return fROIVals;};

const icarus_signal_processing::ArrayBool daq::TPCDecoderFilter1D::getSelectionVals ( ) const

inlineoverridevirtual

Recover the selection values.

Implements daq::IDecoderFilter.

Definition at line 82 of file TPCDecoderFilter1D_tool.cc.

{return fSelectVals;};

const icarus_signal_processing::VectorFloat daq::TPCDecoderFilter1D::getTruncRMSVals ( ) const

inlineoverridevirtual

Recover the truncated RMS noise.

Implements daq::IDecoderFilter.

Definition at line 132 of file TPCDecoderFilter1D_tool.cc.

{return fTruncRMSVals;};

const icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::getWaveLessCoherent ( ) const

inlineoverridevirtual

Recover the waveforms less coherent noise.

Implements daq::IDecoderFilter.

Definition at line 112 of file TPCDecoderFilter1D_tool.cc.

{return fWaveLessCoherent;};

void daq::TPCDecoderFilter1D::process_fragment ( detinfo::DetectorClocksData const &  , const artdaq::Fragment &  fragment  )

overridevirtual

Given a set of recob hits, run DBscan to form 3D clusters.

Parameters

fragment

The artdaq fragment to process

Implements daq::IDecoderFilter.

Definition at line 261 of file TPCDecoderFilter1D_tool.cc.

{
    cet::cpu_timer theClockTotal;

    theClockTotal.start();

    // convert fragment to Nevis fragment
    icarus::PhysCrateFragment physCrateFragment(fragment);

    size_t nBoardsPerFragment   = physCrateFragment.nBoards();
    size_t nChannelsPerBoard    = physCrateFragment.nChannelsPerBoard();
    size_t nSamplesPerChannel   = physCrateFragment.nSamplesPerChannel();
//    size_t nChannelsPerFragment = nBoardsPerFragment * nChannelsPerBoard;

    // Recover the Fragment id:
    artdaq::detail::RawFragmentHeader::fragment_id_t fragmentID = fragment.fragmentID();

    if (fDiagnosticOutput) std::cout << "==> Recovered fragmentID: " << std::hex << fragmentID << std::dec << " ";

    // Look for special case of diagnostic running
    if (!fChannelMap->hasFragmentID(fragmentID))
    {
        if (fFragmentIDMap.find(fragmentID) == fFragmentIDMap.end()) //throw std::runtime_error("You can't save yourself");
        {
            theClockTotal.stop();
            if (fDiagnosticOutput) std::cout << " **** no match found ****" << std::endl;

            return;
        }

        if (fDiagnosticOutput) std::cout << "No match, use fhicl list? Have fragmentID: " << fragmentID << ", make it: " << std::hex << fFragmentIDMap[fragmentID] << std::dec << std::endl;

        fragmentID = fFragmentIDMap[fragmentID];

        if (!fChannelMap->hasFragmentID(fragmentID))
        {
            if (fDiagnosticOutput) std::cout << "WTF? This really can't happen, right?" << std::endl;
            return;
        }

    }

    if (fDiagnosticOutput) std::cout << std::endl;

    // Recover the crate name for this fragment
    const std::string& crateName = fChannelMap->getCrateName(fragmentID);

    // Get the board ids for this fragment
    const icarusDB::ReadoutIDVec& readoutIDVec = fChannelMap->getReadoutBoardVec(fragmentID);

    icarusDB::ReadoutIDVec boardIDVec(readoutIDVec.size());

    // Note we want these to be in "slot" order...
    for(const auto& boardID : readoutIDVec)
    {
        // Look up the channels associated to this board
        if (!fChannelMap->hasBoardID(boardID))
        {
            if (fDiagnosticOutput)
            {
                std::cout << "*** COULD NOT FIND BOARD ***" << std::endl;
                std::cout << "    - boardID: " << std::hex << boardID << ", board map size: " << readoutIDVec.size() << ", nBoardsPerFragment: " << nBoardsPerFragment << std::endl;
            }

            return;
        }

        unsigned int boardSlot = fChannelMap->getBoardSlot(boardID);

        boardIDVec[boardSlot] = boardID;
    }

    if (fDiagnosticOutput)
    {
        std::cout << "   - # boards: " << boardIDVec.size() << ", boards: ";
        for(const auto& id : boardIDVec) std::cout << id << " ";
        std::cout << std::endl;
    }

    // Make sure these always get defined to be as large as can be
    const size_t maxChannelsPerFragment(576);

    if (fSelectVals.empty())        fSelectVals       = icarus_signal_processing::ArrayBool(maxChannelsPerFragment,  icarus_signal_processing::VectorBool(nSamplesPerChannel));
    if (fROIVals.empty())           fROIVals          = icarus_signal_processing::ArrayBool(maxChannelsPerFragment,  icarus_signal_processing::VectorBool(nSamplesPerChannel));
    if (fRawWaveforms.empty())      fRawWaveforms     = icarus_signal_processing::ArrayFloat(maxChannelsPerFragment, icarus_signal_processing::VectorFloat(nSamplesPerChannel));
    if (fPedCorWaveforms.empty())   fPedCorWaveforms  = icarus_signal_processing::ArrayFloat(maxChannelsPerFragment, icarus_signal_processing::VectorFloat(nSamplesPerChannel));
    if (fIntrinsicRMS.empty())      fIntrinsicRMS     = icarus_signal_processing::ArrayFloat(maxChannelsPerFragment, icarus_signal_processing::VectorFloat(nSamplesPerChannel));
    if (fCorrectedMedians.empty())  fCorrectedMedians = icarus_signal_processing::ArrayFloat(maxChannelsPerFragment, icarus_signal_processing::VectorFloat(nSamplesPerChannel));
    if (fWaveLessCoherent.empty())  fWaveLessCoherent = icarus_signal_processing::ArrayFloat(maxChannelsPerFragment, icarus_signal_processing::VectorFloat(nSamplesPerChannel));
    if (fMorphedWaveforms.empty())  fMorphedWaveforms = icarus_signal_processing::ArrayFloat(maxChannelsPerFragment, icarus_signal_processing::VectorFloat(nSamplesPerChannel));

    if (fChannelIDVec.empty())      fChannelIDVec     = icarus_signal_processing::VectorInt(maxChannelsPerFragment);
    if (fPedestalVals.empty())      fPedestalVals     = icarus_signal_processing::VectorFloat(maxChannelsPerFragment);
    if (fFullRMSVals.empty())       fFullRMSVals      = icarus_signal_processing::VectorFloat(maxChannelsPerFragment);
    if (fTruncRMSVals.empty())      fTruncRMSVals     = icarus_signal_processing::VectorFloat(maxChannelsPerFragment);
    if (fNumTruncBins.empty())      fNumTruncBins     = icarus_signal_processing::VectorInt(maxChannelsPerFragment);
    if (fRangeBins.empty())         fRangeBins        = icarus_signal_processing::VectorInt(maxChannelsPerFragment);

    if (fThresholdVec.empty())      fThresholdVec     = icarus_signal_processing::VectorFloat(maxChannelsPerFragment / fCoherentNoiseGrouping);

    if (fFilterFunctionVec.empty()) fFilterFunctionVec.resize(maxChannelsPerFragment);
   
    // Allocate the de-noising object
    icarus_signal_processing::Denoiser1D           denoiser;
    icarus_signal_processing::WaveformTools<float> waveformTools;

    cet::cpu_timer theClockPedestal;

    theClockPedestal.start();

    // The first task is to recover the data from the board data block, determine and subtract the pedestals
    // and store into vectors useful for the next steps
    for(size_t board = 0; board < boardIDVec.size(); board++)
    {
        // Some diagnostics test are removing boards so put in check here to watch for this
        if (board >= nBoardsPerFragment)
        {
            mf::LogInfo("TPCDecoderFilter1D") << " Asking for board beyond number in fragment, want board " << board << ", maximum is " << nBoardsPerFragment << std::endl;
            continue;
        }

        const icarusDB::ChannelPlanePairVec& channelPlanePairVec = fChannelMap->getChannelPlanePair(boardIDVec[board]);

        uint32_t boardSlot = physCrateFragment.DataTileHeader(board)->StatusReg_SlotID();

        if (fDiagnosticOutput)
        {
            std::cout << "********************************************************************************" << std::endl;
            std::cout << "FragmentID: " << std::hex << fragmentID << ", Crate: " << crateName << std::dec << ", boardID: " << boardIDVec[boardSlot] << ", slot: " << boardSlot << "/" << nBoardsPerFragment << ", size " << channelPlanePairVec.size() << "/" << nChannelsPerBoard << ", ";
            std::cout << std::endl;
        }

        // This is where we would recover the base channel for the board from database/module
        size_t boardOffset = nChannelsPerBoard * board;

        // Get the pointer to the start of this board's block of data
        const icarus::A2795DataBlock::data_t* dataBlock = physCrateFragment.BoardData(board);

        // Copy to input data array
        for(size_t chanIdx = 0; chanIdx < nChannelsPerBoard; chanIdx++)
        {
            // Get the channel number on the Fragment
            size_t channelOnBoard = boardOffset + chanIdx;

            icarus_signal_processing::VectorFloat& rawDataVec = fRawWaveforms[channelOnBoard];

            for(size_t tick = 0; tick < nSamplesPerChannel; tick++)
                rawDataVec[tick] = -dataBlock[chanIdx + tick * nChannelsPerBoard];

            icarus_signal_processing::VectorFloat& pedCorDataVec = fPedCorWaveforms[channelOnBoard];

            // Keep track of the channel
            fChannelIDVec[channelOnBoard] = channelPlanePairVec[chanIdx].first;

            // Handle the filter function to use for this channel
            unsigned int plane = channelPlanePairVec[chanIdx].second;

            // Set the threshold which toggles between planes
            fThresholdVec[channelOnBoard / fCoherentNoiseGrouping] = fThreshold[plane];

            if (plane > 2)
            {
                std::cout << "*** COMPLETELY SCREWUP YOU IMBECILE! plane is " << plane << " for chanIdx " << chanIdx << std::endl;
                continue;
            }

            switch(fFilterModeVec[plane][0])
            {
                case 'd' :
                    fFilterFunctionVec[channelOnBoard] = std::make_unique<icarus_signal_processing::Dilation1D>(fStructuringElement);
                    break;
                case 'e' :
                    fFilterFunctionVec[channelOnBoard] = std::make_unique<icarus_signal_processing::Erosion1D>(fStructuringElement);
                    break;
                case 'g' :
                    fFilterFunctionVec[channelOnBoard] = std::make_unique<icarus_signal_processing::Gradient1D>(fStructuringElement);
                    break;
                case 'a' :
                    fFilterFunctionVec[channelOnBoard] = std::make_unique<icarus_signal_processing::Average1D>(fStructuringElement);
                    break;
                case 'm' :
                    fFilterFunctionVec[channelOnBoard] = std::make_unique<icarus_signal_processing::Median1D>(fStructuringElement);
                    break;
                default:
                    std::cout << "***** FOUND NO MATCH FOR TYPE: " << fFilterModeVec[plane] << ", plane " << plane << " DURING INITIALIZATION OF FILTER FUNCTIONS IN TPCDecoderFilter1D" << std::endl;
                    break;
            }

            // Now determine the pedestal and correct for it
            waveformTools.getPedestalCorrectedWaveform(rawDataVec,
                                                       pedCorDataVec,
                                                       fSigmaForTruncation,
                                                       fPedestalVals[channelOnBoard],
                                                       fFullRMSVals[channelOnBoard],
                                                       fTruncRMSVals[channelOnBoard],
                                                       fNumTruncBins[channelOnBoard],
                                                       fRangeBins[channelOnBoard]);

            // Convolve with a filter function
            if (fUseFFTFilter) (*fFFTFilterFunctionVec[plane])(pedCorDataVec);

            if (fDiagnosticOutput)
            {
                std::vector<geo::WireID> widVec = fGeometry->ChannelToWire(channelPlanePairVec[chanIdx].first);

                if (widVec.empty()) std::cout << channelPlanePairVec[chanIdx].first << "/" << chanIdx  << "=" << fFullRMSVals[channelOnBoard] << " * ";
                else std::cout << fChannelIDVec[channelOnBoard] << "-" << widVec[0].Cryostat << "/" << widVec[0].TPC << "/" << widVec[0].Plane << "/" << widVec[0].Wire << "=" << fFullRMSVals[channelOnBoard] << " * ";
            }
        }

        if (fDiagnosticOutput) std::cout << std::endl;
    
        // Run the coherent filter
//        denoiser.removeCoherentNoise1D_Ave(fWaveLessCoherent.begin()  + boardOffset,
//                                           fPedCorWaveforms.begin()   + boardOffset,
//                                           fMorphedWaveforms.begin()  + boardOffset,
//                                           fIntrinsicRMS.begin()      + boardOffset,
//                                           fSelectVals.begin()        + boardOffset,
//                                           fROIVals.begin()           + boardOffset,
//                                           fCorrectedMedians.begin()  + boardOffset,
//                                           fFilterFunctionVec.begin() + boardOffset,
//                                           fThresholdVec.begin()      + boardOffset,
//                                           nChannelsPerBoard,
//                                           fCoherentNoiseGrouping,
//                                           fMorphWindow);

        denoiser(fWaveLessCoherent.begin()  + boardOffset,
                 fPedCorWaveforms.begin()   + boardOffset,
                 fMorphedWaveforms.begin()  + boardOffset,
                 fIntrinsicRMS.begin()      + boardOffset,
                 fSelectVals.begin()        + boardOffset,
                 fROIVals.begin()           + boardOffset,
                 fCorrectedMedians.begin()  + boardOffset,
                 fFilterFunctionVec.begin() + boardOffset,
                 fThresholdVec,
                 nChannelsPerBoard,
                 fCoherentNoiseGrouping,
                 fCoherentNoiseOffset,
                 fMorphWindow);
    }

    // We need to make sure the channelID information is not preserved when less than 9 boards in the fragment
    if (nBoardsPerFragment < 9)
    {
        std::fill(fChannelIDVec.begin() + nBoardsPerFragment * nChannelsPerBoard, fChannelIDVec.end(), -1);
    }

    theClockPedestal.stop();

    double pedestalTime = theClockPedestal.accumulated_real_time();

    cet::cpu_timer theClockDenoise;

    theClockDenoise.start();

    // Let's just try something here...
//    icarus_signal_processing::ArrayFloat inputWaveforms = fPedCorWaveforms;
//
//    for(size_t groupSize = 64; groupSize > 16; groupSize /= 2)//    database::ReadoutIDVec& boardIDVec = fragItr->second;


//    {
//        // Run the coherent filter
//        denoiser.removeCoherentNoise1D(fWaveLessCoherent,inputWaveforms,fMorphedWaveforms,fIntrinsicRMS,fSelectVals,fROIVals,fCorrectedMedians,
//                                       fFilterModeVec[0],groupSize,fStructuringElement,fMorphWindow,fThreshold);
//
//        inputWaveforms = fWaveLessCoherent;
//    }


//    // Run the coherent filter
//    denoiser.removeCoherentNoise1D(fWaveLessCoherent.begin(),fPedCorWaveforms.begin(),fMorphedWaveforms.begin(),fIntrinsicRMS.begin(),fSelectVals.begin(),fROIVals.begin(),fCorrectedMedians.begin(),
//                                   fFilterFunctionVec.begin(),fPedCorWaveforms.size(),fCoherentNoiseGrouping,fStructuringElement,fMorphWindow,fThreshold);

    theClockDenoise.stop();

    double denoiseTime = theClockDenoise.accumulated_real_time();

    theClockDenoise.start();

//    // One last task to remove remaining offsets from th coherent corrected waveforms
//    for(size_t idx = 0; idx < fWaveLessCoherent.size(); idx++)
//    {
//        // Final pedestal correction to remove last offsets
//        float cohPedestal;
//        int   numTrunc;
//        int   range;
//
//        // waveform
//        icarus_signal_processing::VectorFloat& waveform = fWaveLessCoherent[idx];
//
//        waveformTools.getTruncatedMean(waveform, cohPedestal, numTrunc, range);
//
//        if (fDiagnosticOutput) std::cout << "**> channel: " << fChannelIDVec[idx] << ", numTrunc: " << numTrunc << ", range: " << range << ", orig ped: " << fPedestalVals[idx] << ", new: " << cohPedestal << std::endl;
//
//        // Do the pedestal correction
//        std::transform(waveform.begin(),waveform.end(),waveform.begin(),std::bind(std::minus<float>(),std::placeholders::_1,cohPedestal));
//    }

    theClockDenoise.stop();

    double cohPedSubTime = theClockDenoise.accumulated_real_time() - denoiseTime;


    theClockTotal.stop();

    double totalTime = theClockTotal.accumulated_real_time();

    mf::LogDebug("TPCDecoderFilter1D") << "    *totalTime: " << totalTime << ", pedestal: " << pedestalTime << ", noise: " << denoiseTime << ", ped cor: " << cohPedSubTime << std::endl;

    return;
}

Member Data Documentation

icarus_signal_processing::VectorInt daq::TPCDecoderFilter1D::fChannelIDVec

private

Definition at line 164 of file TPCDecoderFilter1D_tool.cc.

const icarusDB::IICARUSChannelMap* daq::TPCDecoderFilter1D::fChannelMap

private

Definition at line 185 of file TPCDecoderFilter1D_tool.cc.

size_t daq::TPCDecoderFilter1D::fCoherentNoiseGrouping

private

Definition at line 145 of file TPCDecoderFilter1D_tool.cc.

size_t daq::TPCDecoderFilter1D::fCoherentNoiseOffset

private

Definition at line 146 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::fCorrectedMedians

private

Definition at line 170 of file TPCDecoderFilter1D_tool.cc.

bool daq::TPCDecoderFilter1D::fDiagnosticOutput

private

Definition at line 151 of file TPCDecoderFilter1D_tool.cc.

FloatPairVec daq::TPCDecoderFilter1D::fFFTCutoffValsVec

private

Definition at line 153 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::FFTFilterFunctionVec daq::TPCDecoderFilter1D::fFFTFilterFunctionVec

private

Definition at line 188 of file TPCDecoderFilter1D_tool.cc.

FloatPairVec daq::TPCDecoderFilter1D::fFFTSigmaValsVec

private

Definition at line 152 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::FilterFunctionVec daq::TPCDecoderFilter1D::fFilterFunctionVec

private

Definition at line 182 of file TPCDecoderFilter1D_tool.cc.

std::vector<std::string> daq::TPCDecoderFilter1D::fFilterModeVec

private

Definition at line 155 of file TPCDecoderFilter1D_tool.cc.

uint32_t daq::TPCDecoderFilter1D::fFragment_id_offset

private

Definition at line 143 of file TPCDecoderFilter1D_tool.cc.

FragmentIDMap daq::TPCDecoderFilter1D::fFragmentIDMap

private

Definition at line 161 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::VectorFloat daq::TPCDecoderFilter1D::fFullRMSVals

private

Definition at line 175 of file TPCDecoderFilter1D_tool.cc.

const geo::Geometry* daq::TPCDecoderFilter1D::fGeometry

private

Definition at line 184 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::fIntrinsicRMS

private

Definition at line 169 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::fMorphedWaveforms

private

Definition at line 172 of file TPCDecoderFilter1D_tool.cc.

size_t daq::TPCDecoderFilter1D::fMorphWindow

private

Definition at line 148 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::VectorInt daq::TPCDecoderFilter1D::fNumTruncBins

private

Definition at line 177 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::fPedCorWaveforms

private

Definition at line 168 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::VectorFloat daq::TPCDecoderFilter1D::fPedestalVals

private

Definition at line 174 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::VectorInt daq::TPCDecoderFilter1D::fRangeBins

private

Definition at line 178 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::fRawWaveforms

private

Definition at line 167 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::ArrayBool daq::TPCDecoderFilter1D::fROIVals

private

Definition at line 166 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::ArrayBool daq::TPCDecoderFilter1D::fSelectVals

private

Definition at line 165 of file TPCDecoderFilter1D_tool.cc.

float daq::TPCDecoderFilter1D::fSigmaForTruncation

private

Definition at line 144 of file TPCDecoderFilter1D_tool.cc.

size_t daq::TPCDecoderFilter1D::fStructuringElement

private

Definition at line 147 of file TPCDecoderFilter1D_tool.cc.

std::vector<float> daq::TPCDecoderFilter1D::fThreshold

private

Definition at line 149 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::VectorFloat daq::TPCDecoderFilter1D::fThresholdVec

private

Definition at line 180 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::VectorFloat daq::TPCDecoderFilter1D::fTruncRMSVals

private

Definition at line 176 of file TPCDecoderFilter1D_tool.cc.

bool daq::TPCDecoderFilter1D::fUseFFTFilter

private

Definition at line 150 of file TPCDecoderFilter1D_tool.cc.

icarus_signal_processing::ArrayFloat daq::TPCDecoderFilter1D::fWaveLessCoherent

private

Definition at line 171 of file TPCDecoderFilter1D_tool.cc.

---

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

• TPCDecoderFilter1D_tool.cc