CVNCosmicMapper_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// \file    CVNCosmicMapper_module.cc
// \brief   Producer module for creating CVN PixelMap objects
// \author  Dominick Rocco - rocco@physics.umn.edu
////////////////////////////////////////////////////////////////////////

// C/C++ includes
#include <iostream>
#include <sstream>

// Framework includes
#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Services/Optional/TFileDirectory.h"
#include "art/Framework/Services/Optional/TFileService.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "canvas/Persistency/Common/FindManyP.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "canvas/Persistency/Common/Assns.h"

// NOvASoft includes
#include "RecoBase/CellHit.h"
#include "RecoBase/Cluster.h"

#include "Utilities/AssociationUtil.h"

#include "CVN/art/PixelMapProducer.h"
#include "CVN/func/PixelMap.h"
#include "CVN/func/TrainingData.h"



namespace cvn {

  class CVNCosmicMapper : public art::EDProducer {
  public:
    explicit CVNCosmicMapper(fhicl::ParameterSet const& pset);
    ~CVNCosmicMapper();

    void produce(art::Event& evt);
    void beginJob();
    void endJob();



  private:
   
    /// Read CellHits from this input
    const art::ProductToken<std::vector<rb::CellHit>> fCellHitToken;



    /// Ratio of Cosmic pixel maps to Nu pixel maps to create
    //unsigned short fCosmicToNuRatio;

    /// Width of pixel map in cells
    unsigned short fCellWidth;

    /// Length of pixel map in planes
    unsigned short fPlaneLength;

    /// Maximum gap in planes at front of cluster to prevent pruning of upstream
    /// hits
    unsigned int fMaxPlaneGap;

    /// Size of time window used in map
    int fTimeWinSize;
 
    /// Where to start first time window
    int fTimeWinOffset;

    /// amount of overlap between windows
    int fTimeWinOverlap;

    /// number of time windows to make
    unsigned int fNumClusters;

    /// write clusters to file
    bool fWriteClusters;
  };



  //.......................................................................
  CVNCosmicMapper::CVNCosmicMapper(fhicl::ParameterSet const& pset):
  fCellHitToken(consumes<std::vector<rb::CellHit>>(pset.get<std::string>("CellHitInput"))),
  fCellWidth     (pset.get<unsigned short> ("CellWidth")),
  fPlaneLength   (pset.get<unsigned short> ("PlaneLength")),
  fMaxPlaneGap   (pset.get<unsigned int>   ("MaxPlaneGap")),
  fTimeWinSize   (pset.get<int>            ("TimeWinSize")),
  fTimeWinOffset (pset.get<int>            ("TimeWinOffset")),
  fTimeWinOverlap(pset.get<int>            ("TimeWinOverlap")),
  fNumClusters   (pset.get<unsigned int>   ("NumClusters")),
  fWriteClusters (pset.get<bool>           ("WriteClusters"))
  {

    produces< std::vector<cvn::PixelMap> > ();
    if (fWriteClusters) produces< std::vector<rb::Cluster> > ();
    if (fWriteClusters) produces< art::Assns<cvn::PixelMap, rb::Cluster> >();
 }

  //......................................................................
  CVNCosmicMapper::~CVNCosmicMapper()
  {
  }

  //......................................................................
  void CVNCosmicMapper::beginJob()
  {
  }

  //......................................................................
  void CVNCosmicMapper::endJob()
  {
  }

  //......................................................................
  void CVNCosmicMapper::produce(art::Event& evt)
  {

    std::unique_ptr< std::vector<rb::Cluster>> clustercol(new std::vector<rb::Cluster>);
    std::unique_ptr< art::Assns<PixelMap, rb::Cluster> >
                                assoc(new art::Assns<PixelMap, rb::Cluster>);

    //Declaring containers for things to be stored in event
    auto pmCol = std::make_unique<std::vector<PixelMap>>();
    pmCol->reserve(fNumClusters+1);

    // Get the cell hits
    art::Handle< std::vector<rb::CellHit> > hitcol;
    evt.getByToken(fCellHitToken, hitcol);

    std::vector<art::Ptr<rb::CellHit > > hits;
    if (fWriteClusters){
      for(unsigned int i = 0; i < hitcol->size(); ++i){
        art::Ptr<rb::CellHit> hit(hitcol, i);
        hits.push_back(hit);  
      }
      std::sort(hits.begin(), hits.end(),
                [](art::Ptr<rb::CellHit> a, art::Ptr<rb::CellHit> b)
                {return a->TNS() < b->TNS();});
    }

    // Extract all the hits as concrete objects
    std::vector<rb::CellHit> hitlist = *hitcol;

    // Sort the hits by time to improve the speed.
    // WARNING:  The rest of the code assumes that the hits are
    //           time sorted!
    std::sort(hitlist.begin(), hitlist.end(),
              [](const rb::CellHit& a, const rb::CellHit& b)
              {return a.TNS() < b.TNS();});
 
    //  Sort hits into time chunks now and make clusters from them.
    //  Also need to associate the hits with an label.

    //boundary is always the full detector size so just fix that
    cvn::Boundary bound(fPlaneLength, fCellWidth, 0, fCellWidth/2,fCellWidth/2,1);


    rb::Cluster cluster;

    // Step through the event and group clusters of hits over 15uSec centered on 217-232 (spill window)
    // We add a 1uSec overlap on the beginning as well
    for(unsigned int i = 0; i < fNumClusters; ++i) {
      pmCol->emplace_back(fPlaneLength, fCellWidth, bound, true); // PEOnly
      PixelMap& pm = pmCol->back();
      unsigned int iCount=0;
      if (fWriteClusters) cluster.Clear();
      pm.SetMinTime(i*(fTimeWinSize-fTimeWinOverlap)+fTimeWinOffset);
      pm.SetMaxTime(i*(fTimeWinSize-fTimeWinOverlap)+fTimeWinSize+fTimeWinOffset);
      for(unsigned int j = 0; j < hitlist.size(); ++j) {
        const rb::CellHit& hj = hitlist[j];

        if ((i*(fTimeWinSize-fTimeWinOverlap)+fTimeWinOffset) > (hj.TNS())) continue;
        if ((hj.TNS()) >= (i*(fTimeWinSize-fTimeWinOverlap)+fTimeWinSize+fTimeWinOffset)) {
          if (fWriteClusters){
            clustercol->push_back(cluster);
            util::CreateAssn(*this, evt, *(assoc.get()), *(pmCol.get()), *(clustercol), i, i);
          }
          break;
        }
        unsigned int view = (unsigned int)hj.View();
        pm.Add(hj.Plane(),
               hj.Cell(),
               1.0,
               view,
               iCount, 
               hj.TNS(),
               kEmptyHit,
               0.0,
               0,
               0 );
        iCount++;
        if (fWriteClusters) cluster.Add(hits[j]);
      }
    }



    // Drop the cluster collections, pixelmap collections and associations into the event
    evt.put(std::move(pmCol));
    if (fWriteClusters){
      evt.put(std::move(clustercol));
      evt.put(std::move(assoc));
    }
  }

  //----------------------------------------------------------------------



  DEFINE_ART_MODULE(CVNCosmicMapper)
} // end namespace cvn
////////////////////////////////////////////////////////////////////////