SupernovaTrigger_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       SupernovaTrigger
// Module Type: filter
// File:        SupernovaTrigger_module.cc
//
// Generated at Mon Dec 17 15:29:53 2012 by Zukai Wang using artmod
// from art v1_02_06.
////////////////////////////////////////////////////////////////////////

#include "art/Framework/Core/EDFilter.h"
#include "art/Framework/Core/ModuleMacros.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/Boundary.h"
#include "DDTBaseDataProducts/BoundaryList.h"
#include "DDTBaseDataProducts/HitList.h"
#include "DDTBaseDataProducts/DAQHit.h"
#include "DDTBaseDataProducts/GroupedHitList.h"
#include "DDTBaseDataProducts/TriggerDecision.h"        
#include "DDTBaseDataProducts/EventHeader.h"    
#include "DDTUtilities/AssociationUtil.h"

#include "SuperNovaDDT/SNMessageInterface.h"
#include "SuperNovaDDT/SliceSelector.h"

#include <string>
#include <queue>
#include <algorithm>
#include <functional>

namespace novaddt {
  class SupernovaTrigger;
}

class novaddt::SupernovaTrigger : public art::EDFilter {
public:
  explicit SupernovaTrigger(fhicl::ParameterSet const & p);
  virtual ~SupernovaTrigger();
  virtual bool filter(art::Event & e) override;
  virtual void endJob() override;
private:
  uint64_t GetCandidates(const art::Event & e);
  uint64_t GetTime(const art::Event & e);
private:
  bool fVerbose;
  std::string fHeaderTag;
  std::string fSlicesTag;
  SliceSelector fSelector;

  bool   fGroupDoRemove;   // should we bother to remove large groups
  size_t fGroupCountMax;   // groups larger than this will not be counted
  int    fGroupDTmax;      // maximum time distance to group
  bool   fGroupNeighbours; // if TRUE, add cluster to group when close to last hit
};

novaddt::SupernovaTrigger::SupernovaTrigger(fhicl::ParameterSet const & p):
  fVerbose(p.get<bool>("verbose")),
  fHeaderTag   (p.get< std::string >("header_tag"  )), 
  fSlicesTag   (p.get< std::string >("slices_tag"  )),
  fSelector    (p.get<fhicl::ParameterSet>("slice_cuts")),
  fGroupDoRemove   (p.get<bool>("group.remove",false)),
  fGroupCountMax   (p.get<size_t>("group.size_max",5)),
  fGroupDTmax      (p.get<int>("group.DT_max",3)),
  fGroupNeighbours (p.get<bool>("group.neighbours",false))
{ 
    mf::LogInfo("SupernovaTrigger")<<"config:"
        <<"\n slices_tag: "<<fSlicesTag
        <<"\n header_tag: "<<fHeaderTag
        <<"\n slice_cuts: "<<fSelector
        <<"\n group: "
        <<"\n \t remove: "<<fGroupDoRemove
        <<"\n \t neighbours: "<<fGroupNeighbours
        <<"\n \t size_max: "<<fGroupCountMax
        <<"\n \t DT_max:   "<<fGroupDTmax;

}

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


uint64_t novaddt::SupernovaTrigger::GetCandidates(const art::Event & e)
{

  auto slices=e.getValidHandle<std::vector<novaddt::HitList>>(fSlicesTag);
  
  if(!fGroupDoRemove) 
    //no Groups removal needed, just simple counting
    return fSelector.countPassing(*slices);
  
  
  size_t Nselected = 0;      //count number of candidates
  size_t groupCount=0;
  
  uint64_t t0=0, t1=0;
  int dT;
  ///subtract large groups of candidates, clustered in time - 
  ///they are mostly remnants of unreconstructed muon tracks
  for(const auto& slice: *slices){
    auto cluster=CalcCluster(slice);
    if(fSelector.checkCluster(cluster)==false) continue;
    t1=cluster.t;
    dT=t1-t0;
    if(dT>fGroupDTmax){
      if(groupCount<fGroupCountMax)Nselected+=groupCount;
      groupCount=0;
    }
    ++groupCount;
    if(groupCount==1||fGroupNeighbours)t0=t1;
    mf::LogDebug("SupernovaTrigger")<<Nselected<<" "<<groupCount<<" "<<dT;
  }
  if(groupCount<fGroupCountMax)Nselected+=groupCount;
  
  mf::LogDebug("SupernovaTrigger")<<"counting slices:"
                                  <<"\nNSlices All="<<slices->size()
                                  <<"\nNSlices Sel="<<Nselected;
  //calculate hits in signal region
  return Nselected;
}

uint64_t novaddt::SupernovaTrigger::GetTime(const art::Event & e)
{
  const uint64_t msec=64000; //TDC ticks/msec
  art::Handle<novaddt::EventHeader> header;
  if(e.getByLabel<novaddt::EventHeader>(fHeaderTag, header))
    return header->timeStart/msec;
  else
    return e.event()*5;
}

bool novaddt::SupernovaTrigger::filter(art::Event & e)
{
  //service to send the data points
  art::ServiceHandle<novaddt::SNMessageInterface> msg;
  //send the data
  msg->PushPoint(GetTime(e),GetCandidates(e));
  return false;
}


void novaddt::SupernovaTrigger::endJob()
{
}
DEFINE_ART_MODULE(novaddt::SupernovaTrigger)