RemoveOneDSlices_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       RemoveOneDSlices
// Module Type: producer
// File:        RemoveOneDSlices_module.cc
//
// Generated at Wed June 5 by Matthew Tamsett based on SpaceSlice
// 
////////////////////////////////////////////////////////////////////////

#include "art/Framework/Core/EDFilter.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Principal/Event.h"

#include "DDTBaseDataProducts/BaseProducts.h"
#include "DDTBaseDataProducts/HitList.h"
#include "DDTBaseDataProducts/DAQHit.h"
#include "DDTBaseDataProducts/CompareDAQHit.h"

#include "DAQChannelMap/DAQChannelMap.h"
//---------------------------------------------------------------------
namespace novaddt {
    class RemoveOneDSlices;
}
//---------------------------------------------------------------------
class novaddt::RemoveOneDSlices : public art::EDFilter{
    public:
        explicit RemoveOneDSlices(fhicl::ParameterSet const & p);
        virtual ~RemoveOneDSlices();
        virtual bool filter(art::Event & event);
        void endJob() override;
    private:
        // Declare member data here.
        std::string     fInputLabel;
        std::string     fInputInstance;
        uint            fMinHitsPerView;
        // functions
        void countHitsPerViewOutlyingCells(HitList & hits,
                                           uint & x_hits, 
                                           uint & y_hits);
        void printDDTSlice(HitList & hits);
        // Counters
        int _nEvents        = 0;
        int _nInputSlices   = 0;
        int _nOutputSlices  = 0;
};
//---------------------------------------------------------------------
novaddt::RemoveOneDSlices::RemoveOneDSlices(fhicl::ParameterSet const & p)
:
    fInputLabel     (p.get< std::string >("InputLabel"   )),
    fInputInstance  (p.get< std::string >("InputInstance")),
    fMinHitsPerView (p.get< uint >("MinHitsPerView"))
    
    // Initialize member data here.
{
    std::cout << "=== novaddt::RemoveOneDSlices instantiate" << std::endl;
    std::cout << "\t input hits label:          " << fInputLabel      << std::endl;
    std::cout << "\t input hits instance:       " << fInputInstance   << std::endl;
    std::cout << "\t min hits per view:         " << fMinHitsPerView  << std::endl;
    // Call appropriate Produces<>() functions here.
    produces<std::vector<HitList>>("TwoDSlices");
}
//---------------------------------------------------------------------
novaddt::RemoveOneDSlices::~RemoveOneDSlices()
{
    // Clean up dynamic memory and other resources here.
}
//---------------------------------------------------------------------
bool  novaddt::RemoveOneDSlices::filter(art::Event & event)
{
    LOG_DEBUG("RemoveOneDSlices") << "=== novaddt::RemoveOneDSlices filter. Event: " 
              << event.id().event() 
              << std::endl;
    _nEvents++;
    art::Handle<std::vector<HitList> > hit_lists;
    event.getByLabel(fInputLabel, fInputInstance, hit_lists);
    LOG_DEBUG("RemoveOneDSlices") << "\t got " << hit_lists->size() << " hit lists" << std::endl;
    
    //make a hit lists out of hits/hit lists that pass the spatial noise removal
    std::unique_ptr< std::vector<HitList> >final_product(new std::vector<HitList>);
    
    for(unsigned int i=0; i<hit_lists->size(); ++i){
        _nInputSlices++;
        HitList product = hit_lists->at(i);
        LOG_DEBUG("RemoveOneDSlices") << "\t hit list[" << i << "]: " << product.size() << " hits" << std::endl;
        //printDDTSlice(product);        
        // count hits per view
        uint x_hits = 0;
        uint y_hits = 0;
        countHitsPerViewOutlyingCells(product, x_hits, y_hits);
                
        //printDDTSlice(product);
        if ((x_hits >= fMinHitsPerView) &&
            (y_hits >= fMinHitsPerView)) final_product->push_back(product);
        
    } // end of loop on hits lists
    //put the hits into the event for later use
    LOG_DEBUG("RemoveOneDSlices") << "\t produced " << final_product->size() << " hit lists" << std::endl;
    _nOutputSlices+=final_product->size();
    event.put(std::move(final_product),"TwoDSlices");

    return true;
}
//---------------------------------------------------------------------
void  novaddt::RemoveOneDSlices::countHitsPerViewOutlyingCells(HitList & hits,
                                                               uint & x_hits,
                                                               uint & y_hits)
{
    for (unsigned int i_hit = 0; i_hit < hits.size(); ++i_hit){
        DAQHit hit = hits[i_hit];        
        // check that the current cells view
        if (hit.View().val == daqchannelmap::X_VIEW){
            x_hits++;
        } else {
            y_hits++;
        }        
    } // end of loop on hits
    
    LOG_DEBUG("RemoveOneDSlices") << "\t\t - end of loop, current slice x hits: " 
                      << x_hits << ", y hits: "
                      << y_hits << std::endl;
}
//---------------------------------------------------------------------
void novaddt::RemoveOneDSlices::printDDTSlice(HitList & hits)
{
    // print them
    LOG_DEBUG("RemoveOneDSlices") << "\t\t - Hit list: " << hits.size()
              << std::endl;
    // sort them
    sort(hits.begin(), hits.end(), novaddt::CompareDAQHit<novaddt::Cell>());
    // loop over hits in each slice
    for(unsigned int j = 0; j < hits.size(); ++j){
        novaddt::DAQHit hit(hits[j]);
        std::string view = "y";
        if( hit.View().val == daqchannelmap::X_VIEW ){
            view = "x";
        }
        LOG_DEBUG("RemoveOneDSlices") << "\t\t\thit[" << j
                  << "]: TDC: "   << hit.TDC().val
                  << ", ADC: "    << hit.ADC().val
                  << ", plane: "  << hit.Plane().val
                  << ", "         << view
                  << "-cell: "    << hit.Cell().val
                  << std::endl;            
    } // end of loop on hits        
}
//---------------------------------------------------------------------
void novaddt::RemoveOneDSlices::endJob()
{
    std::cout << "=== novaddt::RemoveOneDSlices endJob" << std::endl;
    std::cout << "\tNumber of events:             " << _nEvents       << std::endl;
    std::cout << "\tNumber of slices:             " << _nInputSlices  << std::endl;
    std::cout << "\tNumber of slices filtered:    " << _nOutputSlices << std::endl;
}
//---------------------------------------------------------------------
DEFINE_ART_MODULE(novaddt::RemoveOneDSlices)