SlowMonopoleFilt_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       SlowMonopoleFilt
// Module Type: filter
// File:        SlowMonopoleFilt_module.cc
//
// Generated at Mon Aug 11 16:08:14 2014 by Martin Frank using artmod
// from cetpkgsupport v1_06_02.
////////////////////////////////////////////////////////////////////////

#include "art/Framework/Core/EDFilter.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Principal/Run.h"
#include "art/Framework/Principal/SubRun.h"
#include "canvas/Utilities/InputTag.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

#include "DDTBaseDataProducts/HitList.h"
#include "DDTBaseDataProducts/TriggerDecision.h"

#include "DDTMonopole/SlowMonopoleTrigger.h"
#include "DDTTools/DDTExtensions.h"
#include "DDTTools/DDTHelpers.h"
#include "RawData/RawDigit.h"
#include "RawData/RawTrigger.h"
#include "RecoBase/CellHit.h"
#include "RecoBase/Cluster.h"

#include <boost/format.hpp>

#include <memory>
#include <utility>


namespace mono {
  class SlowMonopoleFilt;
  typedef std::pair<uint32_t, uint32_t> TimeWindow;
}


class mono::SlowMonopoleFilt : public art::EDFilter {
public:
  explicit SlowMonopoleFilt(fhicl::ParameterSet const & p);

  // Plugins should not be copied or assigned.
  SlowMonopoleFilt(SlowMonopoleFilt const &) = delete;
  SlowMonopoleFilt(SlowMonopoleFilt &&) = delete;
  SlowMonopoleFilt & operator = (SlowMonopoleFilt const &) = delete;
  SlowMonopoleFilt & operator = (SlowMonopoleFilt &&) = delete;
  bool filter(art::Event & e) override;

private:
  TimeWindow calculate_time_window
  (novaddt::TriggerDecision const& td,
   unsigned buffer, novaddt::TDC event_time) const;

  void append_cluster
  (std::map<std::string, rb::Cluster> const& input_clusters,
   std::unique_ptr<std::vector<rb::Cluster> > & output_clusters,
   std::string const cluster_name) const;
};



mono::SlowMonopoleFilt::SlowMonopoleFilt(fhicl::ParameterSet const & /*p*/)
{
  produces<std::vector<rb::Cluster> >();
  produces<std::vector<novaddt::TriggerDecision> >();
}



bool mono::SlowMonopoleFilt::filter(art::Event & e)
{
  //
  // Extract Objects from the Event
  //
  // High ADC Filtered Hits
  art::Handle<novaddt::HitList> ddt_hits;
  e.getByLabel("smmhighadcfilter", "HEHits", ddt_hits);

  // Raw Trigger Header
  art::Handle<std::vector<rawdata::RawTrigger> > raw_triggers;
  e.getByLabel("daq", raw_triggers);
  assert(raw_triggers->size() == 1);

  // Offline Cell Hits
  art::Handle<std::vector<rb::CellHit> > hits;
  e.getByLabel("calhit", hits);
  std::vector<art::Ptr<rb::CellHit> > hitptrs;
  for (unsigned i = 0; i < hits->size(); ++i)
    hitptrs.emplace_back(hits, i);

  int16_t adc_cut = 150;
  unsigned long long
    event_time(raw_triggers->at(0).fTriggerTimingMarker_TimeStart);


  
  //
  // Run Offline Versions of Trigger
  //
  Configuration config;
  config.max_plane_gap_cut     = 30;
  config.sparsification_factor = 10;
  SlowMonopoleTrigger smt(*ddt_hits, event_time, config);

  std::unique_ptr<std::vector<novaddt::TriggerDecision> >
    trigger_decisions
    (new std::vector<novaddt::TriggerDecision>(smt.trigger_decisions()));

  std::cout << "MF: Trigger Decision Report"
            << "\nMF:  Run " << e.run() << "  Event " << e.event() 
            << "\nMF:  Trigger Decisions Size = " << trigger_decisions->size()
            << std::endl;


  
  //
  // Extract Clusters from Triggers
  //
  unsigned time_buffer = smt.trigger_decision_time_buffer();

  std::unique_ptr<std::vector<rb::Cluster> > 
    clusters(new std::vector<rb::Cluster>);

  if (trigger_decisions->size() > 0)
  {
    TimeWindow time_window =
      calculate_time_window(trigger_decisions->at(0), time_buffer, event_time);
    rb::Cluster cluster = ddthelpers::cluster_hits
      (hitptrs, time_window.first, time_window.second, adc_cut);
    // clusters->push_back(mf_cluster);
  }

  std::map<std::string, rb::Cluster> essential_clusters;
  for (auto const& essential_hit_list : smt.essential_hit_lists())
  {
    for (auto const& essential_hit : essential_hit_list.second)
    {
      // use a subset of hits:
      // art::PtrVector<rb::CellHit> cluster_hits = mf_cluster.AllCells();
      // use all of the hits:
      std::vector<art::Ptr<rb::CellHit> > cluster_hits = hitptrs;
        
      auto matched_offline_hit = std::find_if
        (cluster_hits.begin(), cluster_hits.end(),
         [&](art::Ptr<rb::CellHit> const& cell_hit)
         { 
           return ddthelpers::is_equal(essential_hit, cell_hit, event_time); 
         });
        
      if (matched_offline_hit != cluster_hits.end())
      {
        essential_clusters[essential_hit_list.first].
          Add(*matched_offline_hit);
      }
      else {
        std::cerr << "MF: No matching hit found for:" << std::endl;
        ddthelpers::print(essential_hit, event_time);
      //        assert(false);
      }
    }
  }

  // Color Order:
  // defined in RecoBaseDrawer::GetClusterColor
  // https://cdcvs.fnal.gov/redmine/projects/novaart/repository/entry/trunk/EventDisplay/RecoBaseDrawer.cxx#L1130
  // 1. blue
  // 2. green
  // 3. red
  // 4. yellow

  append_cluster(essential_clusters, clusters, "some_label");
  
  e.put(std::move(trigger_decisions));
  e.put(std::move(clusters));
  
  return true;
}



mono::TimeWindow mono::SlowMonopoleFilt::calculate_time_window
(novaddt::TriggerDecision const& td,
 unsigned buffer, novaddt::TDC event_time) const
{
  auto t_start = td.start()                 + 2 * buffer - event_time;
  auto t_end   = td.start() + td.duration() - 2 * buffer - event_time;

  return std::make_pair(t_start, t_end);
}



void mono::SlowMonopoleFilt::append_cluster
(std::map<std::string, rb::Cluster> const& input_clusters,
 std::unique_ptr<std::vector<rb::Cluster> > & output_clusters,
 std::string const cluster_name) const
{
  auto cluster = input_clusters.find(cluster_name);

  if (cluster != input_clusters.end())
  {
    if (cluster->second.NCell() > 0)
      output_clusters->push_back(cluster->second);
  }
}



DEFINE_ART_MODULE(mono::SlowMonopoleFilt)