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/EDProducer.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.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::EDProducer* module, const char* name = "") :
        fProducer(module), 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::EDProducer* fProducer;
    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::EDProducer* module, const char* name = "") :
        FVectorWriter<N>(module, 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)
    {
        fProducer->produces< std::vector< anab::FVecDescription<N> > >(fInstanceName);
        fIsDescriptionRegistered = true;
    }

    fProducer->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