TriCellTrigger_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       TriCellTrigger
// Module Type: filter
// File:        TriCellTrigger_module.cc
//
// Generated at Wed Sep 12 16:15:01 2012 by Nova DDT using artmod
// from art v1_01_01.
////////////////////////////////////////////////////////////////////////

#include "art/Framework/Core/EDFilter.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "canvas/Persistency/Common/FindOneP.h"
#include "canvas/Persistency/Common/Assns.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/Track.h"
#include "DDTBaseDataProducts/TriggerDecision.h"
#include "DDTUtilities/AssociationUtil.h"

#include <string>
#include <algorithm>

namespace novaddt {
  class TriCellTrigger;
}

class novaddt::TriCellTrigger : public art::EDFilter {

public:
  explicit TriCellTrigger(fhicl::ParameterSet const & p);
  virtual ~TriCellTrigger();

  virtual bool filter(art::Event & e);

private:

  std::string  _trackModuleLabel;   ///< label of module making the HitList
  std::string  _trackInstanceLabel; ///< instance label making the HitList
  float        _minFraction;        ///< minimum fraction of usable hits in 
                                    ///< a slice for the trigger to be written out
  unsigned int _minPlanesCrossed;   ///< minimum planes crossed in a slice to be used
  unsigned     _triggerCounts;      ///< prescaling variable
  unsigned     _prescale;           ///< holds prescaling variable from fcl file
  unsigned     _event_prescale;     ///< holds event prescaling variable from fcl file
};

//---------------------------------------------------------------------    
novaddt::TriCellTrigger::TriCellTrigger(fhicl::ParameterSet const & p)
  : _trackModuleLabel  (p.get<std::string >("TrackModuleLabel"      ))
  , _trackInstanceLabel(p.get<std::string >("TrackInstanceLabel", ""))
  , _minFraction       (p.get<float       >("MinFraction"           ))
  , _minPlanesCrossed  (p.get<unsigned int>("MinPlanesCrossed"      ))
  , _triggerCounts     (0)
  , _prescale          (p.get<unsigned    >("prescale"              ))
  , _event_prescale    (p.get<unsigned    >("EventPrescale"         ))
{
  produces< std::vector<novaddt::TriggerDecision> >();
  produces< art::Assns<novaddt::TriggerDecision, novaddt::HitList> >();
}

//---------------------------------------------------------------------    
novaddt::TriCellTrigger::~TriCellTrigger()
{
  // Clean up dynamic memory and other resources here.
}

//---------------------------------------------------------------------    
bool novaddt::TriCellTrigger::filter(art::Event & e)
{
  // get the hit lists for this slice
  art::Handle<std::vector<novaddt::Track> > th;
  e.getByLabel(_trackModuleLabel, _trackInstanceLabel, th);

  // make the vector we are going to write out to the event
  std::unique_ptr<std::vector<novaddt::TriggerDecision>> td(new std::vector<novaddt::TriggerDecision>);
  std::unique_ptr<art::Assns<novaddt::TriggerDecision, novaddt::HitList> > assn(new art::Assns<novaddt::TriggerDecision, novaddt::HitList >);

  std::map<unsigned short, std::set<unsigned short>> planesAndCells;
  
  // get the hit list for each track
  art::FindOneP<novaddt::HitList> fohl(th, e, _trackModuleLabel);
  for(size_t t = 0; t < th->size(); ++t){

    planesAndCells.clear();
  
    art::Ptr<novaddt::HitList> hl = fohl.at(t);
    // first fill the map of planes and cells
    for(auto const& i : *hl){
      planesAndCells[i.Plane().val].insert(i.Cell().val);

      LOG_DEBUG("TriCellTrigger") << "plane: " << i.Plane().val
                                  << " cell: " << i.Cell().val;
    }

    // if this track doesn't cross enough planes, 
    // or have enough hits continue to the next one and try that
    if(std::abs(th->at(t).EndZ() - th->at(t).StartZ()) < _minPlanesCrossed ||
       hl->size()                                      < _minPlanesCrossed) continue;

    // now loop over the planes and cells to determine
    // the fraction in this list that have both neighbors also hit
    float totalCells = 0.;
    float goodCells  = 0.;

    for(auto const& pcitr : planesAndCells){
      // get the set for the current plane
      // sets are presorted, go c++
      std::set<unsigned short> cellSet = pcitr.second;
      
      // put the iterator over the set to the second entry
      auto citr = cellSet.cbegin();
      totalCells += 1.;
      ++citr;

      // loop over the cells and look to see if there is 
      // a cell in this plane that has both its neighbors also
      // hit on this track
      // is it faster to sort the set first and then search?
      while( citr != cellSet.cend() ){
        if( cellSet.find(*citr - 1) != cellSet.end() &&
            cellSet.find(*citr + 1) != cellSet.end() ){
          goodCells += 1.;
        }
        totalCells += 1.;

        ++citr;
      }// end iterator over cells for this plane

    }// end loop to count the tri-cell groupings

    if(goodCells > _minFraction*totalCells)
    {
      ++_triggerCounts;
      if (_triggerCounts % _prescale == _prescale - 1)
      {
        td->emplace_back(hl->front().TDC().val, 
                         hl->back().TDC().val - hl->front().TDC().val, 
                         daqdataformats::trigID::TRIG_ID_DATA_CALMU,
                         _prescale*_event_prescale);

        util::CreateAssn(*this, e, *td, hl, *assn);

        LOG_DEBUG("TriCellTrigger") << "make the trigger decision "
                                    << td->back().start()
                                    << " " << td->back().duration()
                                    << " " << goodCells
                                    << " " << totalCells
                                    << " " << hl->size();
      }

    }// end if we have a good trigger with this GHL

  } // end loop over grouped hit list

  bool goodTrigger = (td->size() > 0);

  e.put(std::move(td));
  e.put(std::move(assn));

  return goodTrigger;
}

DEFINE_ART_MODULE(novaddt::TriCellTrigger)