HitCreator.h

Go to the documentation of this file.

#ifndef LARDATA_ARTDATAHELPERS_HITCREATOR_H
#define LARDATA_ARTDATAHELPERS_HITCREATOR_H

// LArSoft libraries
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/Wire.h"
#include "lardataobj/RawData/RawDigit.h"
#include "art/Persistency/Common/PtrMaker.h"

// framework libraries
#include "canvas/Persistency/Common/Assns.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Utilities/InputTag.h"
#include "canvas/Utilities/Exception.h"

// C/C++ standard library
#include <utility> // std::move()
#include <vector>
#include <string>


// declaration of some heavy art stuff
namespace art {
        class Event;
        class EDProducer;
        class EDProductGetter;
} // namespace art


namespace recob {

  class HitCreator {
    public:
      using RegionOfInterest_t = recob::Wire::RegionsOfInterest_t::datarange_t;
      
      // destructor, copy and move constructor and assignment as default
      
      HitCreator(
        raw::RawDigit const& digits,
        geo::WireID const&   wireID,
        raw::TDCtick_t       start_tick,
        raw::TDCtick_t       end_tick,
        float                rms,
        float                peak_time,
        float                sigma_peak_time,
        float                peak_amplitude,
        float                sigma_peak_amplitude,
        float                hit_integral,
        float                hit_sigma_integral,
        float                summedADC,
        short int            multiplicity,
        short int            local_index,
        float                goodness_of_fit,
        int                  dof
        );
      
      
      HitCreator(
        recob::Wire const&   wire,
        geo::WireID const&   wireID,
        raw::TDCtick_t       start_tick,
        raw::TDCtick_t       end_tick,
        float                rms,
        float                peak_time,
        float                sigma_peak_time,
        float                peak_amplitude,
        float                sigma_peak_amplitude,
        float                hit_integral,
        float                hit_sigma_integral,
        float                summedADC,
        short int            multiplicity,
        short int            local_index,
        float                goodness_of_fit,
        int                  dof
        );
      
      
      HitCreator(
        recob::Wire const&   wire,
        geo::WireID const&   wireID,
        raw::TDCtick_t       start_tick,
        raw::TDCtick_t       end_tick,
        float                rms,
        float                peak_time,
        float                sigma_peak_time,
        float                peak_amplitude,
        float                sigma_peak_amplitude,
        float                hit_integral,
        float                hit_sigma_integral,
        short int            multiplicity,
        short int            local_index,
        float                goodness_of_fit,
        int                  dof
        );
      
      
      HitCreator(
        recob::Wire const&        wire,
        geo::WireID const&        wireID,
        float                     rms,
        float                     peak_time,
        float                     sigma_peak_time,
        float                     peak_amplitude,
        float                     sigma_peak_amplitude,
        float                     hit_integral,
        float                     hit_sigma_integral,
        float                     summedADC,
        short int                 multiplicity,
        short int                 local_index,
        float                     goodness_of_fit,
        int                       dof,
        RegionOfInterest_t const& signal
        );
      
      
      HitCreator(
        recob::Wire const& wire,
        geo::WireID const& wireID,
        float              rms,
        float              peak_time,
        float              sigma_peak_time,
        float              peak_amplitude,
        float              sigma_peak_amplitude,
        float              hit_integral,
        float              hit_sigma_integral,
        float              summedADC,
        short int          multiplicity,
        short int          local_index,
        float              goodness_of_fit,
        int                dof,
        size_t             iSignalRoI
        );
      
      
      HitCreator(recob::Hit const& from);
      
      
      HitCreator(recob::Hit const& from, geo::WireID const& wireID);
      
      
      recob::Hit&& move() { return std::move(hit); }
      
      
      recob::Hit const& copy() const { return hit; }
      
    protected:
      
      recob::Hit hit; 
      
  }; // class HitCreator
  
  
  
  class HitAndAssociationsWriterBase {
      public:
    
    // no public constructor: use one of the derived classes!
    // destructor, copy and move constructors and assignment are default
    
    size_t size() const { return hits? hits->size(): 0; }
    
    
    void put_into(art::Event&) { put_into(); }
    
    void put_into();
    
    
    std::vector<recob::Hit> const& peek() const { return *hits; }
    
    
    template <typename ModuleType>
    static void declare_products(
      ModuleType& producer, std::string instance_name = "",
      bool doWireAssns = true, bool doRawDigitAssns = true
      );
    
      protected:
    using HitPtr_t = art::Ptr<recob::Hit>; 
    
    std::string prod_instance; 
    
    std::unique_ptr<std::vector<recob::Hit>> hits;
    std::unique_ptr<art::Assns<recob::Wire, recob::Hit>> WireAssns;
    std::unique_ptr<art::Assns<raw::RawDigit, recob::Hit>> RawDigitAssns;
    
    art::Event* event = nullptr; 
    
    art::PtrMaker<recob::Hit> hitPtrMaker; 
    
    
    template <typename ModuleType>
    HitAndAssociationsWriterBase(
      ModuleType& producer, art::Event& event,
      std::string instance_name,
      bool doWireAssns, bool doRawDigitAssns
      );
    
    
    HitPtr_t CreatePtr(size_t index) const { return hitPtrMaker(index); }
    
  }; // class HitAndAssociationsWriterBase
  
  
  
  
  class HitCollectionCreator: public HitAndAssociationsWriterBase {
      public:
    

    template <typename ModuleType>
    HitCollectionCreator(
      ModuleType& producer, art::Event& event,
      std::string instance_name = "",
      bool doWireAssns = true, bool doRawDigitAssns = true
      );
    
    
    template <typename ModuleType>
    HitCollectionCreator(
      ModuleType& producer, art::Event& event,
      bool doWireAssns, bool doRawDigitAssns
      ):
      HitCollectionCreator(producer, event, "", doWireAssns, doRawDigitAssns)
      {}
    
    
    // destructor, copy and move constructors and assignment are default
    
    

    void emplace_back(
      recob::Hit&& hit,
      art::Ptr<recob::Wire> const& wire = art::Ptr<recob::Wire>(),
      art::Ptr<raw::RawDigit> const& digits = art::Ptr<raw::RawDigit>()
      );
    
    
    void emplace_back(
      recob::Hit const& hit,
      art::Ptr<recob::Wire> const& wire = art::Ptr<recob::Wire>(),
      art::Ptr<raw::RawDigit> const& digits = art::Ptr<raw::RawDigit>()
      );
    
    
    void emplace_back(
      HitCreator&& hit,
      art::Ptr<recob::Wire> const& wire = art::Ptr<recob::Wire>(),
      art::Ptr<raw::RawDigit> const& digits = art::Ptr<raw::RawDigit>()
      )
      { emplace_back(hit.move(), wire, digits); }
    
    
    void emplace_back(recob::Hit&& hit, art::Ptr<raw::RawDigit> const& digits)
      { emplace_back(std::move(hit), art::Ptr<recob::Wire>(), digits); }
    
    
    void emplace_back(HitCreator&& hit, art::Ptr<raw::RawDigit> const& digits)
      { emplace_back(std::move(hit), art::Ptr<recob::Wire>(), digits); }
    
    
    void emplace_back
      (HitCreator const& hit, art::Ptr<raw::RawDigit> const& digits)
      { emplace_back(std::move(hit.copy()), art::Ptr<recob::Wire>(), digits); }
    
    
    size_t size() const { return hits->size(); }
    
    
    void reserve(size_t new_size) { if (hits) hits->reserve(new_size); }
    
    
    void put_into(art::Event&) { put_into(); }
    
    void put_into();
    
    
    std::vector<recob::Hit> const& peek() const { return *hits; }
    
    
      protected:
    using HitPtr_t = HitAndAssociationsWriterBase::HitPtr_t;
    
    HitPtr_t CreatePtrToLastHit() const
      { return hits->empty()? HitPtr_t(): CreatePtr(hits->size() - 1); }
    
    void CreateAssociationsToLastHit(
      art::Ptr<recob::Wire> const& wire, art::Ptr<raw::RawDigit> const& digits
      );
    
  }; // class HitCollectionCreator
  
  
  
  
  class HitCollectionAssociator: public HitAndAssociationsWriterBase {
      public:

    template <typename ModuleType>
    HitCollectionAssociator(
      ModuleType& producer, art::Event& event,
      std::string instance_name,
      art::InputTag const& WireModuleLabel,
      art::InputTag const& RawDigitModuleLabel
      );
    
    template <typename ModuleType>
    HitCollectionAssociator(
      ModuleType& producer, art::Event& event,
      art::InputTag const& WireModuleLabel,
      art::InputTag const& RawDigitModuleLabel
      ):
      HitCollectionAssociator
        (producer, event, "", WireModuleLabel, RawDigitModuleLabel)
      {}
    
    template <typename ModuleType>
    HitCollectionAssociator(
      ModuleType& producer, art::Event& event,
      std::string instance_name,
      art::InputTag const& WireModuleLabel,
      bool doRawDigitAssns
      );
    
    template <typename ModuleType>
    HitCollectionAssociator(
      ModuleType& producer, art::Event& event,
      art::InputTag const& WireModuleLabel,
      bool doRawDigitAssns
      ):
      HitCollectionAssociator
        (producer, event, "", WireModuleLabel, doRawDigitAssns)
      {}

    
    // destructor, copy and move constructors and assignment are default
    
    void use_hits(std::unique_ptr<std::vector<recob::Hit>>&& srchits);
    
    
    void put_into(art::Event&) { put_into(); }
    
    void put_into();
    
    
      protected:
    art::InputTag wires_label;
    art::InputTag digits_label;
    
    void prepare_associations(std::vector<recob::Hit> const& srchits);
    
    void prepare_associations() { prepare_associations(*hits); }
    
  }; // class HitCollectionAssociator
  
  
  class HitRefinerAssociator: public HitAndAssociationsWriterBase {
      public:
    

    template <typename ModuleType>
    HitRefinerAssociator(
      ModuleType& producer, art::Event& event,
      art::InputTag const& HitModuleLabel,
      std::string instance_name = "",
      bool doWireAssns = true, bool doRawDigitAssns = true
      );
    
    template <typename ModuleType>
    HitRefinerAssociator(
      ModuleType& producer, art::Event& event,
      art::InputTag const& HitModuleLabel,
      bool doWireAssns, bool doRawDigitAssns = true
      ):
      HitRefinerAssociator
        (producer, event, HitModuleLabel, "", doWireAssns, doRawDigitAssns)
      {}
      
    
    // destructor, copy and move constructors and assignment are default
    
    void use_hits(std::unique_ptr<std::vector<recob::Hit>>&& srchits);
    
    
    void put_into(art::Event&) { put_into(); }
    
    void put_into();
    
    
      protected:
    art::InputTag hits_label; 
    
    void prepare_associations(std::vector<recob::Hit> const& srchits);
    
    void prepare_associations() { prepare_associations(*hits); }
    
  }; // class HitRefinerAssociator
  
  
  // ---------------------------------------------------------------------------
  template <typename Writer, typename ModuleType = art::EDProducer>
  class HitAndAssociationsWriterManager {
    
      public:
    using Writer_t = Writer; 
    using Module_t = ModuleType; 
    
    HitAndAssociationsWriterManager() = default;
    
    HitAndAssociationsWriterManager(
      Module_t& callingProducer, std::string instanceName = "",
      bool doWireAssns = true, bool doRawDigitAssns = true
      );
    
    void declareProducts(
      Module_t& callingProducer, std::string instanceName = "",
      bool doWireAssns = true, bool doRawDigitAssns = true
      );
    
    Writer_t collectionWriter(art::Event& event) const;
    
    
    std::string instanceName() const { return prodInstance; }
    
    bool ready() const { return producer; }
    
      protected:
    Module_t* producer = nullptr; 
    
    std::string prodInstance; 
    
    bool hasRawDigitAssns = true;
    
    bool hasWireAssns = true;
    
    
  }; // class HitAndAssociationsWriterManager
  
  template <typename ModuleType = art::EDProducer>
  using HitCollectionCreatorManager
    = HitAndAssociationsWriterManager<HitCollectionCreator, ModuleType>;
  
} // namespace recob


//------------------------------------------------------------------------------
//---  template implementation
//------------------------------------------------------------------------------
//---  recob::HitAndAssociationsWriterBase
//---
template <typename ModuleType>
recob::HitAndAssociationsWriterBase::HitAndAssociationsWriterBase(
  ModuleType& producer, art::Event& event,
  std::string instance_name, bool doWireAssns, bool doRawDigitAssns
  )
  : prod_instance(instance_name)
  , hits()
  , WireAssns
    (doWireAssns? new art::Assns<recob::Wire, recob::Hit>: nullptr)
  , RawDigitAssns
    (doRawDigitAssns? new art::Assns<raw::RawDigit, recob::Hit>: nullptr)
  , event(&event)
  , hitPtrMaker(*(this->event), producer, prod_instance)
{
  // this must be run in the producer constructor...
//  declare_products(producer, doWireAssns, doRawDigitAssns);
} // recob::HitAndAssociationsWriterBase::HitAndAssociationsWriterBase()


//------------------------------------------------------------------------------
template <typename ModuleType>
void recob::HitAndAssociationsWriterBase::declare_products(
  ModuleType& producer,
  std::string instance_name /* = "" */,
  bool doWireAssns /* = true */, bool doRawDigitAssns /* = true */
) {
  producer.template produces<std::vector<recob::Hit>>(instance_name);
  
  // declare the other products we are creating (if any)
  if (doWireAssns) {
    producer.template produces<art::Assns<recob::Wire, recob::Hit>>
      (instance_name);
  }
  if (doRawDigitAssns) {
    producer.template produces<art::Assns<raw::RawDigit, recob::Hit>>
      (instance_name);
  }
  
} // recob::HitAndAssociationsWriterBase::declare_products()


//------------------------------------------------------------------------------
//---  recob::HitRefinerAssociator
//---
template <typename ModuleType>
recob::HitRefinerAssociator::HitRefinerAssociator(
  ModuleType& producer, art::Event& event,
  art::InputTag const& HitModuleLabel,
  std::string instance_name /* = "" */,
  bool doWireAssns /* = true */, bool doRawDigitAssns /* = true */
)
  : HitAndAssociationsWriterBase
      (producer, event, instance_name, doWireAssns, doRawDigitAssns)
  , hits_label(HitModuleLabel)
{
  hits.reset(new std::vector<recob::Hit>);
} // recob::HitRefinerAssociator::HitRefinerAssociator()
  
  
//------------------------------------------------------------------------------
//---  recob::HitCollectionCreator
//---
template <typename ModuleType>
recob::HitCollectionCreator::HitCollectionCreator(
  ModuleType& producer, art::Event& event,
  std::string instance_name /* = "" */,
  bool doWireAssns /* = true */, bool doRawDigitAssns /* = true */
  )
  : HitAndAssociationsWriterBase
    (producer, event, instance_name, doWireAssns, doRawDigitAssns)
{
  hits.reset(new std::vector<recob::Hit>);
} // recob::HitCollectionCreator::HitCollectionCreator()


//------------------------------------------------------------------------------
//---  recob::HitCollectionAssociator
//---
template <typename ModuleType>
recob::HitCollectionAssociator::HitCollectionAssociator(
  ModuleType& producer, art::Event& event,
  std::string instance_name,
  art::InputTag const& WireModuleLabel,
  art::InputTag const& RawDigitModuleLabel
)
  : HitAndAssociationsWriterBase(
      producer, event, instance_name,
      WireModuleLabel != "", RawDigitModuleLabel != ""
      )
  , wires_label(WireModuleLabel)
  , digits_label(RawDigitModuleLabel)
{
  hits.reset(new std::vector<recob::Hit>);
} // recob::HitCollectionAssociator::HitCollectionAssociator()


//------------------------------------------------------------------------------
template <typename ModuleType>
recob::HitCollectionAssociator::HitCollectionAssociator(
  ModuleType& producer, art::Event& event,
  std::string instance_name,
  art::InputTag const& WireModuleLabel,
  bool doRawDigitAssns /* = false */
)
  : HitAndAssociationsWriterBase(
      producer, event, instance_name,
      WireModuleLabel != "", doRawDigitAssns
      )
  , wires_label(WireModuleLabel)
  , digits_label()
{
  if (RawDigitAssns && !WireAssns) {
    throw art::Exception(art::errors::LogicError)
      << "HitCollectionAssociator can't create hit <--> raw digit"
      " associations through wires, without wires!\n";
  }
  hits.reset(new std::vector<recob::Hit>);
} // recob::HitCollectionAssociator::HitCollectionAssociator()
  
  
//------------------------------------------------------------------------------
//--- recob::HitAndAssociationsWriterManager
//---
template <typename Writer, typename ModuleType /* = art::EDProducer */>
recob::HitAndAssociationsWriterManager<Writer, ModuleType>
  ::HitAndAssociationsWriterManager
  (
    Module_t& callingProducer, std::string instanceName /* = "" */,
    bool doWireAssns /* = true */, bool doRawDigitAssns /* = true */
  )
{
  declareProducts
    (callingProducer, instanceName, doWireAssns, doRawDigitAssns);
} // recob::HitAndAssociationsWriterManager::HitAndAssociationsWriterManager()


//------------------------------------------------------------------------------
template <typename Writer, typename ModuleType /* = art::EDProducer */>
void recob::HitAndAssociationsWriterManager<Writer, ModuleType>::declareProducts
  (
    Module_t& callingProducer, std::string instanceName /* = "" */,
    bool doWireAssns /* = true */, bool doRawDigitAssns /* = true */
  )
{
  if (producer) {
    // this means you already called to declaredProducts()
    // or used the wrong constructor (which did that for you):
    throw art::Exception(art::errors::LogicError)
      << "HitAndAssociationsWriter<> has already declared its products.";
  }
  producer = &callingProducer;
  prodInstance = instanceName;
  hasWireAssns = doWireAssns;
  hasRawDigitAssns = doRawDigitAssns;
  HitAndAssociationsWriterBase::declare_products
    (callingProducer, prodInstance, hasWireAssns, hasRawDigitAssns);
} // recob::HitAndAssociationsWriterManager::declareProducts()


//------------------------------------------------------------------------------
template <typename Writer, typename ModuleType /* = art::EDProducer */>
typename recob::HitAndAssociationsWriterManager<Writer, ModuleType>::Writer_t
recob::HitAndAssociationsWriterManager<Writer, ModuleType>::collectionWriter
  (art::Event& event) const
{
  if (!producer) {
    // this means you forgot to code a call to declaredProducts()
    // or used the wrong constructor:
    throw art::Exception(art::errors::LogicError)
      << "HitAndAssociationsWriter<>::collectionWriter() called"
      " before products are declared.";
  }
  return
    { *producer, event, prodInstance, hasWireAssns, hasRawDigitAssns };
} // recob::HitAndAssociationsWriterManager::collectionWriter()


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

#endif // LARDATA_ARTDATAHELPERS_HITCREATOR_H