MVAWriter.h

Go to the documentation of this file.

// \version
//
// \brief Wrapper for saving MVA results into art::Event
//
// \author robert.sulej@cern.ch
//
#ifndef ANAB_MVAWRITER_H
#define ANAB_MVAWRITER_H

#include "art/Framework/Core/ProducesCollector.h"
#include "art/Framework/Principal/Event.h"
#include "canvas/Utilities/InputTag.h"

#include "lardata/ArtDataHelper/MVAWrapperBase.h"

namespace anab {

  typedef size_t FVector_ID;
  typedef size_t MVAOutput_ID;

  template <size_t N>
  class FVectorWriter : public FVectorWrapperBase {
  public:
    FVectorWriter(art::ProducesCollector& collector, const char* name = "")
      : fCollector(collector)
      , fInstanceName(name)
      , fIsDescriptionRegistered(false)
      , fDescriptions(nullptr)
    {}

    template <class T>
    void produces_using();

    template <class T>
    FVector_ID initOutputs(std::string const& dataTag,
                           size_t dataSize,
                           std::vector<std::string> const& names = std::vector<std::string>(N, ""));

    template <class T>
    FVector_ID initOutputs(art::InputTag const& dataTag,
                           size_t dataSize,
                           std::vector<std::string> const& names = std::vector<std::string>(N, ""))
    {
      return initOutputs<T>(dataTag.encode(), dataSize, names);
    }

    void setVector(FVector_ID id, size_t key, std::array<float, N> const& values)
    {
      (*(fVectors[id]))[key] = values;
    }
    void setVector(FVector_ID id, size_t key, std::array<double, N> const& values)
    {
      (*(fVectors[id]))[key] = values;
    }
    void setVector(FVector_ID id, size_t key, std::vector<float> const& values)
    {
      (*(fVectors[id]))[key] = values;
    }
    void setVector(FVector_ID id, size_t key, std::vector<double> const& values)
    {
      (*(fVectors[id]))[key] = values;
    }

    template <class T>
    FVector_ID initOutputs(art::InputTag const& dataTag,
                           std::vector<std::string> const& names = std::vector<std::string>(N, ""))
    {
      return initOutputs<T>(dataTag.encode(), 0, names);
    }

    template <class T>
    FVector_ID initOutputs(std::vector<std::string> const& names = std::vector<std::string>(N, ""))
    {
      return initOutputs<T>(std::string(""), 0, names);
    }

    void addVector(FVector_ID id, std::array<float, N> const& values)
    {
      fVectors[id]->emplace_back(values);
    }
    void addVector(FVector_ID id, std::array<double, N> const& values)
    {
      fVectors[id]->emplace_back(values);
    }
    void addVector(FVector_ID id, std::vector<float> const& values)
    {
      fVectors[id]->emplace_back(values);
    }
    void addVector(FVector_ID id, std::vector<double> const& values)
    {
      fVectors[id]->emplace_back(values);
    }

    void setDataTag(FVector_ID id, art::InputTag const& dataTag)
    {
      (*fDescriptions)[id].setDataTag(dataTag.encode());
    }

    void saveOutputs(art::Event& evt);

    size_t size(FVector_ID id) const { return fVectors[id]->size(); }

    size_t length() const { return N; }

    template <class T>
    std::array<float, N> getVector(size_t key) const
    {
      std::array<float, N> vout;
      auto const& src = (*(fVectors[getProductID<T>()]))[key];
      for (size_t i = 0; i < N; ++i)
        vout[i] = src[i];
      return vout;
    }

    template <class T>
    std::array<float, N> getVector(art::Ptr<T> const& item) const
    {
      std::array<float, N> vout;
      auto const& src = (*(fVectors[getProductID<T>()]))[item.key()];
      for (size_t i = 0; i < N; ++i)
        vout[i] = src[i];
      return vout;
    }

    friend std::ostream& operator<<(std::ostream& o, FVectorWriter const& a)
    {
      o << "FVectorWriter for " << a.fInstanceName << ", " << N << " outputs";
      if (!a.fRegisteredDataTypes.empty()) {
        o << ", ready to write results made for:" << std::endl;
        for (auto const& n : a.fRegisteredDataTypes) {
          o << "\t" << n << std::endl;
        }
      }
      else {
        o << ", nothing registered for writing to the events" << std::endl;
      }
      return o;
    }

  protected:
    // Data collected for each event:
    template <class T>
    FVector_ID getProductID() const;

    std::vector<std::unique_ptr<std::vector<anab::FeatureVector<N>>>> fVectors;

  private:
    // Data initialized for the module life:
    art::ProducesCollector& fCollector;
    std::string fInstanceName;

    std::vector<std::string> fRegisteredDataTypes;
    bool fIsDescriptionRegistered;

    std::unordered_map<size_t, FVector_ID> fTypeHashToID;

    std::unique_ptr<std::vector<anab::FVecDescription<N>>> fDescriptions;
    void clearEventData()
    {
      fTypeHashToID.clear();
      fVectors.clear();
      fDescriptions.reset(nullptr);
    }

    bool dataTypeRegistered(const std::string& dname) const;
    bool descriptionExists(const std::string& tname) const;
  };

  template <size_t N>
  class MVAWriter : public FVectorWriter<N>, public MVAWrapperBase {
  public:
    MVAWriter(art::ProducesCollector& collector, const char* name = "")
      : FVectorWriter<N>(collector, name)
    {}

    void setOutput(FVector_ID id, size_t key, std::array<float, N> const& values)
    {
      FVectorWriter<N>::setVector(id, key, values);
    }
    void setOutput(FVector_ID id, size_t key, std::array<double, N> const& values)
    {
      FVectorWriter<N>::setVector(id, key, values);
    }
    void setOutput(FVector_ID id, size_t key, std::vector<float> const& values)
    {
      FVectorWriter<N>::setVector(id, key, values);
    }
    void setOutput(FVector_ID id, size_t key, std::vector<double> const& values)
    {
      FVectorWriter<N>::setVector(id, key, values);
    }

    void addOutput(FVector_ID id, std::array<float, N> const& values)
    {
      FVectorWriter<N>::addVector(id, values);
    }
    void addOutput(FVector_ID id, std::array<double, N> const& values)
    {
      FVectorWriter<N>::addVector(id, values);
    }
    void addOutput(FVector_ID id, std::vector<float> const& values)
    {
      FVectorWriter<N>::addVector(id, values);
    }
    void addOutput(FVector_ID id, std::vector<double> const& values)
    {
      FVectorWriter<N>::addVector(id, values);
    }

    template <class T>
    std::array<float, N> getOutput(std::vector<art::Ptr<T>> const& items) const
    {
      return pAccumulate<T, N>(
        items, *(FVectorWriter<N>::fVectors[FVectorWriter<N>::template getProductID<T>()]));
    }

    template <class T>
    std::array<float, N> getOutput(std::vector<art::Ptr<T>> const& items,
                                   std::vector<float> const& weights) const
    {
      return pAccumulate<T, N>(
        items,
        weights,
        *(FVectorWriter<N>::fVectors[FVectorWriter<N>::template getProductID<T>()]));
    }

    template <class T>
    std::array<float, N> getOutput(std::vector<art::Ptr<T>> const& items,
                                   std::function<float(T const&)> fweight) const
    {
      return pAccumulate<T, N>(
        items,
        fweight,
        *(FVectorWriter<N>::fVectors[FVectorWriter<N>::template getProductID<T>()]));
    }

    template <class T>
    std::array<float, N> getOutput(std::vector<art::Ptr<T>> const& items,
                                   std::function<float(art::Ptr<T> const&)> fweight) const
    {
      return pAccumulate<T, N>(
        items,
        fweight,
        *(FVectorWriter<N>::fVectors[FVectorWriter<N>::template getProductID<T>()]));
    }

    template <class T>
    std::array<float, N> getOutput(size_t key) const
    {
      return FVectorWriter<N>::template getVector<T>(key);
    }

    template <class T>
    std::array<float, N> getOutput(art::Ptr<T> const& item) const
    {
      return FVectorWriter<N>::template getVector<T>(item);
    }
  };

} // namespace anab

//----------------------------------------------------------------------------
// FVectorWriter functions.
//
template <size_t N>
template <class T>
anab::FVector_ID anab::FVectorWriter<N>::getProductID() const
{
  auto const& ti = typeid(T);
  auto search = fTypeHashToID.find(getProductHash(ti));
  if (search != fTypeHashToID.end()) { return search->second; }
  else {
    throw cet::exception("FVectorWriter")
      << "Feature vectors not initialized for product " << getProductName(ti) << std::endl;
  }
}
//----------------------------------------------------------------------------

template <size_t N>
bool anab::FVectorWriter<N>::dataTypeRegistered(const std::string& dname) const
{
  for (auto const& s : fRegisteredDataTypes) {
    if (s == dname) { return true; }
  }
  return false;
}
//----------------------------------------------------------------------------

template <size_t N>
template <class T>
void anab::FVectorWriter<N>::produces_using()
{
  std::string dataName = getProductName(typeid(T));
  if (dataTypeRegistered(dataName)) {
    throw cet::exception("FVectorWriter")
      << "Type " << dataName << "was already registered." << std::endl;
  }

  if (!fIsDescriptionRegistered) {
    fCollector.produces<std::vector<anab::FVecDescription<N>>>(fInstanceName);
    fIsDescriptionRegistered = true;
  }

  fCollector.produces<std::vector<anab::FeatureVector<N>>>(fInstanceName + dataName);
  fRegisteredDataTypes.push_back(dataName);
}
//----------------------------------------------------------------------------

template <size_t N>
bool anab::FVectorWriter<N>::descriptionExists(const std::string& tname) const
{
  if (!fDescriptions) return false;

  std::string n = fInstanceName + tname;
  for (auto const& d : *fDescriptions) {
    if (d.outputInstance() == n) { return true; }
  }
  return false;
}
//----------------------------------------------------------------------------

template <size_t N>
template <class T>
anab::FVector_ID anab::FVectorWriter<N>::initOutputs(std::string const& dataTag,
                                                     size_t dataSize,
                                                     std::vector<std::string> const& names)
{
  size_t dataHash = getProductHash(typeid(T));
  std::string dataName = getProductName(typeid(T));

  if (!dataTypeRegistered(dataName)) {
    throw cet::exception("FVectorWriter")
      << "Type " << dataName << "not registered with produces_using() function." << std::endl;
  }

  if (!fDescriptions) { fDescriptions = std::make_unique<std::vector<anab::FVecDescription<N>>>(); }
  else if (descriptionExists(dataName)) {
    throw cet::exception("FVectorWriter")
      << "FVecDescription<N> already initialized for " << dataName << std::endl;
  }
  fDescriptions->emplace_back(dataTag, fInstanceName + dataName, names);

  fVectors.push_back(std::make_unique<std::vector<anab::FeatureVector<N>>>());
  anab::FVector_ID id = fVectors.size() - 1;
  fTypeHashToID[dataHash] = id;

  if (dataSize) { fVectors[id]->resize(dataSize, anab::FeatureVector<N>(0.0F)); }

  return id;
}
//----------------------------------------------------------------------------

template <size_t N>
void anab::FVectorWriter<N>::saveOutputs(art::Event& evt)
{
  for (auto const& n : fRegisteredDataTypes) {
    if (!descriptionExists(n)) {
      throw cet::exception("FVectorWriter")
        << "No FVecDescription<N> prepared for type " << n << std::endl;
    }
  }

  if (fVectors.size() != fDescriptions->size()) {
    throw cet::exception("FVectorWriter")
      << "FVecDescription<N> vector length not equal to the number of FeatureVector<N> vectors"
      << std::endl;
  }

  for (size_t i = 0; i < fVectors.size(); ++i) {
    auto const& outInstName = (*fDescriptions)[i].outputInstance();
    if ((*fDescriptions)[i].dataTag().empty()) {
      throw cet::exception("FVectorWriter")
        << "FVecDescription<N> reco data tag not set for " << outInstName << std::endl;
    }
    evt.put(std::move(fVectors[i]), outInstName);
  }
  evt.put(std::move(fDescriptions), fInstanceName);
  clearEventData();
}
//----------------------------------------------------------------------------

#endif //ANAB_MVAREADER