PxHitConverter.h

Go to the documentation of this file.

// \file PxHitConverter.h
//
// \brief conversion utulities from recob::Hit to PxHit
//
// \author andrzej.szelc@yale.edu, based on LarLite code by Kazu
// 
//
#ifndef UTIL_PXHITCONVERTER_H
#define UTIL_PXHITCONVERTER_H

//#include <TMath.h>
//#include <TLorentzVector.h>

#include "PxUtils.h"
#include "larcore/Geometry/Geometry.h"
#include "lardata/Utilities/GeometryUtilities.h"
#include "lardata/Utilities/UtilException.h"
#include "lardata/Utilities/Dereference.h"
//#include "time.h"

#include "lardataobj/RecoBase/Hit.h"
//#include "Geometry/CryostatGeo.h"
//#include "Geometry/PlaneGeo.h"
//#include "Geometry/WireGeo.h"
//#include "Geometry/TPCGeo.h"
//#include "SimpleTypesAndConstants/geo_types.h"
#include "canvas/Persistency/Common/Ptr.h" 

//#include <climits>
#include <iostream>
#include <vector>


namespace util{

  
  //class GeometryUtilities : public larlight::larlight_base {
  class PxHitConverter {

      public:
    
    // Constructors and assignment operators generated by default
    
    virtual ~PxHitConverter() = default;

//     /// Generate: from 1 set of hits => 1 CPAN using indexes (association)
//     void GenerateCPAN(const std::vector<unsigned int>& hit_index,
//                    const larlite::event_hit* hits,
//                    ClusterParamsAlg &cpan) const;
//     
//     /// Generate: CPAN vector from event storage by specifying cluster type
//     void GenerateCPAN(::larlite::storage_manager* storage,
//                    const std::string &cluster_producer_name,
//                    std::vector<cluster::ClusterParamsAlg> &cpan_v) const;
    
    void GeneratePxHit(const std::vector<unsigned int>& hit_index,
                       const std::vector<art::Ptr<recob::Hit>> hits,
                       std::vector<util::PxHit> &pxhits) const;

    void GeneratePxHit(std::vector<art::Ptr<recob::Hit>> const& hits,
                       std::vector<util::PxHit> &pxhits) const;                
                       
    void GenerateSinglePxHit(art::Ptr<recob::Hit> const& hit,
                             util::PxHit &pxhits) const;        
    

    util::PxHit HitToPxHit(recob::Hit const& hit) const;
    /*
    util::PxHit ToPxHit(recob::Hit const& hit) const;
    
    util::PxHit ToPxHit(art::Ptr<recob::Hit> const& hit) const
      { return ToPxHit(*hit); }

    util::PxHit ToPxHit(recob::Hit const* hit) const
      { return ToPxHit(*hit); }
    */
    
    template <typename HitObj>
    util::PxHit ToPxHit(HitObj const& hit) const;
    
    
    template <typename Cont, typename Hit = typename Cont::value_type>
    std::vector<util::PxHit> ToPxHitVector(Cont const& hits) const;
    
    
                             
                       
//     /// Generate: vector of PxHit sets from event storage by specifying cluster type
//     void GeneratePxHit(larlite::storage_manager* storage,
//                     const std::string &cluster_producer_name,
//                     std::vector<std::vector<larutil::PxHit> > &pxhits_v) const;
    
    }; // class PxHitConverter

} //namespace util


//******************************************************************************
//***  Template implementation
//***
template <typename HitObj>
util::PxHit util::PxHitConverter::ToPxHit(HitObj const& hit) const
{
  // check that the argument is an object convertible to a recob::Hit,
  // or it is a pointer to such an object
  static_assert(
    std::is_convertible<
      typename lar::util::dereferenced_type<HitObj>::type,
      recob::Hit
    >::value,
    "The argument to PxHitConverter::ToPxHit() does not point to a recob::Hit"
    );
  return HitToPxHit(lar::util::dereference(hit));
} // PxHitConverter::ToPxHit()


template <typename Cont, typename Hit /* = typename Cont::value_type */>
std::vector<util::PxHit> util::PxHitConverter::ToPxHitVector
  (Cont const& hits) const
{
  std::vector<util::PxHit> pxhits;
  pxhits.reserve(hits.size());
  std::transform(hits.begin(), hits.end(), std::back_inserter(pxhits),
    [this](Hit const& hit) { return this->ToPxHit(hit); });
  return pxhits;
} // util::PxHitConverter::ToPxHitVector()



#endif // UTIL_PXHITCONVERTER_H