UpMuProb_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       UpMuProb
// Module Type: producer
// File:        UpMuProb_module.cc
//
// Generated at Mon Jun 13 14:37:49 2016 by Aristeidis Tsaris using artmod
// from cetpkgsupport v1_10_02.
////////////////////////////////////////////////////////////////////////

#include "art/Framework/Core/EDProducer.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"

// Framework includes
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "art_root_io/TFileService.h"
#include "canvas/Persistency/Common/Assns.h"
#include "Utilities/AssociationUtil.h"
#include "canvas/Persistency/Common/FindManyP.h"
#include "cetlib/search_path.h"

#include <memory>

// NOVA includes
#include "RecoBase/Track.h"
#include "RecoBase/RecoHit.h"
#include "Eval/LlrUpmu.h"

namespace upmuana {
  class UpMuProb;

  bool recoHitComp (rb::RecoHit lhs, rb::RecoHit rhs) {
    if (lhs.Y() == rhs.Y()) {
      if (lhs.Z() == rhs.Z()) {
        return lhs.T() < rhs.T();
      }
      else return lhs.Z() < rhs.Z();
    }
    else return lhs.Y() < rhs.Y();
  }

  bool pairHitComp (std::pair<rb::CellHit, rb::RecoHit> lhp,
                    std::pair<rb::CellHit, rb::RecoHit> rhp) {
    return recoHitComp(lhp.second, rhp.second);
  }

}

class upmuana::UpMuProb : public art::EDProducer {
public:
  explicit UpMuProb(fhicl::ParameterSet const & p);
  // The destructor generated by the compiler is fine for classes
  // without bare pointers or other resource use.

  // Plugins should not be copied or assigned.
  UpMuProb(UpMuProb const &) = delete;
  UpMuProb(UpMuProb &&) = delete;
  UpMuProb & operator = (UpMuProb const &) = delete;
  UpMuProb & operator = (UpMuProb &&) = delete;

  // Required functions.
  void produce(art::Event & e) override;

  // Selected optional functions.
  void beginJob() override;
  void endJob() override;

  void reconfigure(const fhicl::ParameterSet& p);

private:

  // Declare member data here.
  std::string fTrackLabel;
  std::string fSliceLabel;

};


upmuana::UpMuProb::UpMuProb(fhicl::ParameterSet const & p)
: EDProducer(p)
// Initialize member data here.
{
  // Call appropriate produces<>() functions here.
  reconfigure(p);
}

void upmuana::UpMuProb::reconfigure(const fhicl::ParameterSet& p)
{
  fTrackLabel = p.get<std::string>("trackInputTag");
  fSliceLabel = p.get<std::string>("sliceInputTag");

  produces<std::vector<upmuana::LlrUpmu> >();
  produces< art::Assns<upmuana::LlrUpmu,rb::Track> >();

}

void upmuana::UpMuProb::produce(art::Event & e)
{
  // Implementation of required member function here.
  
  std::unique_ptr<std::vector<upmuana::LlrUpmu> > upmucol(new std::vector<upmuana::LlrUpmu>);
  std::unique_ptr< art::Assns<upmuana::LlrUpmu,rb::Track> > assncol(new art::Assns<upmuana::LlrUpmu,rb::Track>);

  art::Handle<std::vector<rb::Cluster> > slicecol;
  e.getByLabel(fSliceLabel,slicecol);
  art::PtrVector<rb::Cluster> slicelist;
  for(unsigned int i = 0; i<slicecol->size();++i){
    art::Ptr<rb::Cluster>slice(slicecol,i);
    slicelist.push_back(slice);
  }

  art::FindManyP<rb::Track> fmt(slicecol, e, fTrackLabel);
  art::Handle<std::vector<rb::Track> > tracks;
  e.getByLabel(fTrackLabel, tracks);

  // loop over all of the slices
  for(unsigned int iSlice = 0; iSlice<slicelist.size(); ++iSlice){
    // get all of the tracks in this slice
    const std::vector< art::Ptr<rb::Track> > slicetrks = fmt.at(iSlice);
    for(unsigned int i_track = 0;i_track<slicetrks.size(); ++i_track){
      //for (size_t i_track=0; i_track < tracks->size(); ++i_track){

      art::Ptr<rb::Track> track = slicetrks[i_track];

      art::PtrVector<rb::CellHit> trackHits = track->AllCells();
      std::set< std::pair<rb::CellHit,rb::RecoHit>,
        bool(*)(std::pair<rb::CellHit,rb::RecoHit>,
                std::pair<rb::CellHit,rb::RecoHit>)>
        sortedTrackHits (pairHitComp);
      
      for (size_t i_hit=0; i_hit < trackHits.size(); ++i_hit) {
        art::Ptr<rb::CellHit> theHit = trackHits.at(i_hit);
        if (!theHit->GoodTiming()) continue;
        rb::RecoHit theRecoHit = track->RecoHit(theHit);
        if (!theRecoHit.IsCalibrated()) continue;
        sortedTrackHits.insert(std::make_pair(*theHit,theRecoHit));
      }
      
      upmuana::LlrUpmu tmp;
      tmp.setLLR(sortedTrackHits);
      upmucol->push_back(tmp);
      util::CreateAssn(e, *(upmucol.get()), track, *(assncol.get()));
    }
  }
  e.put(std::move(upmucol));
  e.put(std::move(assncol));
}
void upmuana::UpMuProb::beginJob()
{
  // Implementation of optional member function here.
}

void upmuana::UpMuProb::endJob()
{
  // Implementation of optional member function here.
}

DEFINE_ART_MODULE(upmuana::UpMuProb)