Clusterer_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       Clusterer
// Module Type: filter
// File:        Clusterer_module.cc
//
// Generated at Mon Feb  4 15:13:21 2013 by Jan Zirnstein using artmod
// from art v1_02_06.
////////////////////////////////////////////////////////////////////////

#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 "DDTUtilities/AssociationUtil.h"
#include "DDTBaseDataProducts/HitList.h"
#include "DDTBaseDataProducts/Cluster.h"

namespace novaddt {
  class Clusterer;
}

class novaddt::Clusterer : public art::EDFilter {
public:
  explicit Clusterer(fhicl::ParameterSet const & p);
  virtual ~Clusterer();

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

private:

  std::string _hlabel;
  std::string _instan;
  bool _trigflag;

};


novaddt::Clusterer::Clusterer(fhicl::ParameterSet const & p)
:
// Initialize member data here.
  _hlabel(p.get< std::string>("hlist_label")),
  _instan(p.get< std::string>("hlist_instance")),
  _trigflag(false)
{
  // Call appropriate Produces<>() functions here.
  produces< std::vector<novaddt::Cluster> >();
  produces< art::Assns<novaddt::Cluster, novaddt::HitList> >();
}

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

bool novaddt::Clusterer::filter(art::Event & e)
{
  // Grab the vector of hitlists from the EDS
  art::Handle<std::vector<novaddt::HitList>> lists;
  e.getByLabel(_hlabel, _instan, lists);

  // This is what is being put into the EDS
  std::unique_ptr<std::vector<novaddt::Cluster>> product(new std::vector<Cluster>);
  std::unique_ptr<art::Assns<novaddt::Cluster, novaddt::HitList> > 
    assn(new art::Assns<novaddt::Cluster, novaddt::HitList >);

  // How many groups of hits are we dealing with?
  unsigned int ngroups = lists->size();
  if (!ngroups) {
        _trigflag = false;
        e.put(std::move(product));
        e.put(std::move(assn));
        return _trigflag;
  }

  // Loop over each group, make a cluster
  for(size_t i = 0; i != ngroups; ++i){
    //       novaddt::HitList hits = (*i);
    art::Ptr<novaddt::HitList> hl(lists,i);
    novaddt::TDC        lowt = (*hl)[0].TDC();
    novaddt::TDC        hight= (*hl)[0].TDC();
    novaddt::Plane      lowp = (*hl)[0].Plane();
    novaddt::Plane      highp= (*hl)[0].Plane();
    uint32_t            asum = 0;
    novaddt::Cell       lowxc = (*hl)[0].Cell();
    novaddt::Cell       lowyc = (*hl)[0].Cell();
    novaddt::Cell       highxc= (*hl)[0].Cell();
    novaddt::Cell       highyc= (*hl)[0].Cell();

    for(auto const& hit: *hl){
      // Figure out earliest and latest time
      if  (hit.TDC().val < lowt)  lowt  = hit.TDC().val;
      else if(hight < hit.TDC().val) hight = hit.TDC().val;
          
      // Figure out smallest and largest cell in each view
      if (daqchannelmap::X_VIEW==hit.View().val){
        if     (hit.Cell().val < lowxc)  lowxc  = hit.Cell().val;
        else if(highxc < hit.Cell().val) highxc = hit.Cell().val;
      }
      if (daqchannelmap::Y_VIEW==hit.View().val){
        if     (hit.Cell().val < lowyc)  lowyc  = hit.Cell().val;
        else if(highyc < hit.Cell().val) highyc = hit.Cell().val;
      }
          
      // Figure out starting and ending plane of Cluster
      if     (hit.Plane().val < lowp)  lowp  = hit.Plane().val;
      else if(highp < hit.Plane().val) highp = hit.Plane().val;

      // Increment the ADC sum by the ADC value of the hit
      asum = asum + hit.ADC().val;

    } // End of loop over hits in a hitlist

    // Make the Cluster
    novaddt::Cluster clust(lowxc, lowyc, highxc, highyc, lowp, highp, lowt, hight, asum);

    // Add the Cluster to the vector if it's 3D (might change this later)
    if (!(lowxc.val == highxc.val || lowyc.val == highyc.val)){
      product->push_back(clust);
      //Making Association with the hit list with the cluster 
      util::CreateAssn(*this, e, *(product.get()), hl,*(assn.get()));
    }

  } // End of loops over hitlists

  // Check the size of the vector of Clusters
  _trigflag = (product->size() > 0);

  // Put the vector of Clusters into the event
  //e.put(std::move(product),"Clusters");
  e.put(std::move(product));
  e.put(std::move(assn));

  // Return appropriate flag
  return _trigflag;
}

DEFINE_ART_MODULE(novaddt::Clusterer)