HitCreator.h

Go to the documentation of this file.

#ifndef LARDATA_ARTDATAHELPERS_HITCREATOR_H
#define LARDATA_ARTDATAHELPERS_HITCREATOR_H

// LArSoft libraries
#include "lardataobj/RawData/RawDigit.h"
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/Wire.h"

// framework libraries
#include "art/Framework/Core/ProducesCollector.h"
#include "art/Persistency/Common/PtrMaker.h"
#include "canvas/Persistency/Common/Assns.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Utilities/Exception.h"
#include "canvas/Utilities/InputTag.h"

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

namespace geo {
  struct WireID;
}
namespace raw {
  class RawDigit;
}
namespace art {
  class ProducesCollector;
  class Event;
}

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 ROIsummedADC,
               float HitsummedADC,
               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 ROIsummedADC,
               float HitsummedADC,
               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 ROIsummedADC,
               float HitsummedADC,
               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 ROIsummedADC,
               float HitsummedADC,
               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; }

    static void declare_products(art::ProducesCollector& collector,
                                 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; 

    HitAndAssociationsWriterBase(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:

    HitCollectionCreator(art::Event& event,
                         std::string instance_name = "",
                         bool doWireAssns = true,
                         bool doRawDigitAssns = true);

    HitCollectionCreator(art::Event& event, bool doWireAssns, bool doRawDigitAssns)
      : HitCollectionCreator(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:

    HitCollectionAssociator(art::Event& event,
                            std::string instance_name,
                            art::InputTag const& WireModuleLabel,
                            art::InputTag const& RawDigitModuleLabel);

    HitCollectionAssociator(art::Event& event,
                            art::InputTag const& WireModuleLabel,
                            art::InputTag const& RawDigitModuleLabel)
      : HitCollectionAssociator(event, "", WireModuleLabel, RawDigitModuleLabel)
    {}

    HitCollectionAssociator(art::Event& event,
                            std::string instance_name,
                            art::InputTag const& WireModuleLabel,
                            bool doRawDigitAssns);

    HitCollectionAssociator(art::Event& event,
                            art::InputTag const& WireModuleLabel,
                            bool doRawDigitAssns)
      : HitCollectionAssociator(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:

    HitRefinerAssociator(art::Event& event,
                         art::InputTag const& HitModuleLabel,
                         std::string instance_name = "",
                         bool doWireAssns = true,
                         bool doRawDigitAssns = true);

    HitRefinerAssociator(art::Event& event,
                         art::InputTag const& HitModuleLabel,
                         bool doWireAssns,
                         bool doRawDigitAssns = true)
      : HitRefinerAssociator(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>
  class HitAndAssociationsWriterManager {

  public:
    using Writer_t = Writer; 

    HitAndAssociationsWriterManager() = default;

    HitAndAssociationsWriterManager(art::ProducesCollector& collector,
                                    std::string instanceName = "",
                                    bool doWireAssns = true,
                                    bool doRawDigitAssns = true);

    void declareProducts(art::ProducesCollector& collector,
                         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 noexcept { return collector_p != nullptr; }

  protected:
    art::ProducesCollector* collector_p = nullptr; 

    std::string prodInstance; 

    bool hasRawDigitAssns = true;

    bool hasWireAssns = true;

  }; // class HitAndAssociationsWriterManager

  using HitCollectionCreatorManager = HitAndAssociationsWriterManager<HitCollectionCreator>;

} // namespace recob

//------------------------------------------------------------------------------
//---  template implementation
//------------------------------------------------------------------------------
//---  recob::HitAndAssociationsWriterBase
//---
//------------------------------------------------------------------------------
//--- recob::HitAndAssociationsWriterManager
//---
template <typename Writer>
recob::HitAndAssociationsWriterManager<Writer>::HitAndAssociationsWriterManager(
  art::ProducesCollector& collector,
  std::string instanceName /* = "" */,
  bool doWireAssns /* = true */,
  bool doRawDigitAssns /* = true */
)
{
  declareProducts(collector, instanceName, doWireAssns, doRawDigitAssns);
} // recob::HitAndAssociationsWriterManager::HitAndAssociationsWriterManager()

//------------------------------------------------------------------------------
template <typename Writer>
void recob::HitAndAssociationsWriterManager<Writer>::declareProducts(
  art::ProducesCollector& collector,
  std::string instanceName /* = "" */,
  bool doWireAssns /* = true */,
  bool doRawDigitAssns /* = true */
)
{
  if (collector_p) {
    // 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.";
  }
  collector_p = &collector;
  prodInstance = instanceName;
  hasWireAssns = doWireAssns;
  hasRawDigitAssns = doRawDigitAssns;
  HitAndAssociationsWriterBase::declare_products(
    collector, prodInstance, hasWireAssns, hasRawDigitAssns);
} // recob::HitAndAssociationsWriterManager::declareProducts()

//------------------------------------------------------------------------------
template <typename Writer>
typename recob::HitAndAssociationsWriterManager<Writer>::Writer_t
recob::HitAndAssociationsWriterManager<Writer>::collectionWriter(art::Event& event) const
{
  if (!collector_p) {
    // 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 {event, prodInstance, hasWireAssns, hasRawDigitAssns};
} // recob::HitAndAssociationsWriterManager::collectionWriter()

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

#endif // LARDATA_ARTDATAHELPERS_HITCREATOR_H