anab::MVAWriter< N > Class Template Reference

#include "MVAWriter.h"

Inheritance diagram for anab::MVAWriter< N >:

Public Member Functions
	MVAWriter (art::EDProducer *module, const char *name="")
void	setOutput (FVector_ID id, size_t key, std::array< float, N > const &values)
void	setOutput (FVector_ID id, size_t key, std::array< double, N > const &values)
void	setOutput (FVector_ID id, size_t key, std::vector< float > const &values)
void	setOutput (FVector_ID id, size_t key, std::vector< double > const &values)
void	addOutput (FVector_ID id, std::array< float, N > const &values)
void	addOutput (FVector_ID id, std::array< double, N > const &values)
void	addOutput (FVector_ID id, std::vector< float > const &values)
void	addOutput (FVector_ID id, std::vector< double > const &values)
template<class T >
std::array< float, N >	getOutput (std::vector< art::Ptr< T > > const &items) const
template<class T >
std::array< float, N >	getOutput (std::vector< art::Ptr< T > > const &items, std::vector< float > const &weights) const
template<class T >
std::array< float, N >	getOutput (std::vector< art::Ptr< T > > const &items, std::function< float(T const &)> fweight) const
template<class T >
std::array< float, N >	getOutput (std::vector< art::Ptr< T > > const &items, std::function< float(art::Ptr< T > const &)> fweight) const
template<class T >
std::array< float, N >	getOutput (size_t key) const
	Get copy of the MVA output vector for the type T, at index "key". More...
template<class T >
std::array< float, N >	getOutput (art::Ptr< T > const &item) const
	Get copy of the MVA output vector for the type T, idicated with art::Ptr::key(). More...
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,""))
template<class T >
FVector_ID	initOutputs (art::InputTag const &dataTag, std::vector< std::string > const &names=std::vector< std::string >(N,""))
template<class T >
FVector_ID	initOutputs (std::vector< std::string > const &names=std::vector< std::string >(N,""))
template<class T >
anab::FVector_ID	initOutputs (std::string const &dataTag, size_t dataSize, std::vector< std::string > const &names)
void	setVector (FVector_ID id, size_t key, std::array< float, N > const &values)
void	setVector (FVector_ID id, size_t key, std::array< double, N > const &values)
void	setVector (FVector_ID id, size_t key, std::vector< float > const &values)
void	setVector (FVector_ID id, size_t key, std::vector< double > const &values)
void	addVector (FVector_ID id, std::array< float, N > const &values)
void	addVector (FVector_ID id, std::array< double, N > const &values)
void	addVector (FVector_ID id, std::vector< float > const &values)
void	addVector (FVector_ID id, std::vector< double > const &values)
void	setDataTag (FVector_ID id, art::InputTag const &dataTag)
	Set tag of associated data products in case it was not ready at the initialization time. More...
void	saveOutputs (art::Event &evt)
	Check consistency and save all the results in the event. More...
size_t	size (FVector_ID id) const
	Get the number of contained feature vectors. More...
size_t	length () const
	Get the length of a single feature vector. More...
template<class T >
std::array< float, N >	getVector (size_t key) const
	Get copy of the feature vector for the type T, at index "key". More...
template<class T >
std::array< float, N >	getVector (art::Ptr< T > const &item) const
	Get copy of the feature vector for the type T, idicated with art::Ptr::key(). More...
template<class T >
anab::FVector_ID	getProductID () const

Protected Member Functions
template<class T >
FVector_ID	getProductID () const
std::string	getProductName (std::type_info const &ti) const
size_t	getProductHash (std::type_info const &ti) const
template<class T , size_t N>
std::array< float, N >	pAccumulate (std::vector< art::Ptr< T > > const &items, std::vector< FeatureVector< N > > const &outs) const
template<class T , size_t N>
std::array< float, N >	pAccumulate (std::vector< art::Ptr< T > > const &items, std::vector< float > const &weights, std::vector< FeatureVector< N > > const &outs) const
template<class T , size_t N>
std::array< float, N >	pAccumulate (std::vector< art::Ptr< T > > const &items, std::function< float(T const &)> fweight, std::vector< FeatureVector< N > > const &outs) const
template<class T , size_t N>
std::array< float, N >	pAccumulate (std::vector< art::Ptr< T > > const &items, std::function< float(art::Ptr< T > const &)> fweight, std::vector< FeatureVector< N > > const &outs) const
template<class T , size_t N>
std::array< float, N >	pAccumulate (std::vector< art::Ptr< T > > const &items, std::vector< FeatureVector< N > > const &outs, std::array< char, N > const &mask) const

Protected Attributes
std::vector< std::unique_ptr< std::vector< anab::FeatureVector< N > > > >	fVectors

Detailed Description

template<size_t N>
class anab::MVAWriter< N >

Helper for registering in the art::EDProducer all data products needed for N-output MVA results: keep MVADescriptions<N> for all types T in one collection while separate instance names are used for the MVA output value collections for each type T. Use one instance of this class per one MVA model, applied to one or more types.

Definition at line 163 of file MVAWriter.h.

Constructor & Destructor Documentation

template<size_t N>

anab::MVAWriter< N >::MVAWriter ( art::EDProducer *  module, const char *  name = ""  )

inline

Name provided to the constructor is used as an instance name for MVADescription<N> and FeatureVector<N> (for which it is combined with the processed data product names). Good idea is to use the name as an indication of what MVA model was used on the data (like eg. "emtrack" for outputs from a model distinguishing EM from track-like hits and clusters). The name is used as an instance name for the MVADescription data product which lets you to save multiple MVA results from a single art module.

Definition at line 172 of file MVAWriter.h.

                                                            :
        FVectorWriter<N>(module, name)
    { }

Member Function Documentation

template<size_t N>

void anab::MVAWriter< N >::addOutput ( FVector_ID  id, std::array< float, N > const &  values  )

inline

Definition at line 181 of file MVAWriter.h.

References anab::FVectorWriter< N >::addVector().

{ FVectorWriter<N>::addVector(id, values); }

template<size_t N>

void anab::MVAWriter< N >::addOutput ( FVector_ID  id, std::array< double, N > const &  values  )

inline

Definition at line 182 of file MVAWriter.h.

References anab::FVectorWriter< N >::addVector().

{ FVectorWriter<N>::addVector(id, values); }

template<size_t N>

void anab::MVAWriter< N >::addOutput ( FVector_ID  id, std::vector< float > const &  values  )

inline

Definition at line 183 of file MVAWriter.h.

References anab::FVectorWriter< N >::addVector().

{ FVectorWriter<N>::addVector(id, values); }

template<size_t N>

void anab::MVAWriter< N >::addOutput ( FVector_ID  id, std::vector< double > const &  values  )

inline

Definition at line 184 of file MVAWriter.h.

References anab::FVectorWriter< N >::addVector().

{ FVectorWriter<N>::addVector(id, values); }

template<size_t N>

void anab::FVectorWriter< N >::addVector ( FVector_ID  id, std::array< float, N > const &  values  )

inlineinherited

Definition at line 79 of file MVAWriter.h.

Referenced by anab::MVAWriter< N >::addOutput(), and hit::DPRawHitFinder::produce().

{ fVectors[id]->emplace_back(values); }

template<size_t N>

void anab::FVectorWriter< N >::addVector ( FVector_ID  id, std::array< double, N > const &  values  )

inlineinherited

Definition at line 80 of file MVAWriter.h.

{ fVectors[id]->emplace_back(values); }

template<size_t N>

void anab::FVectorWriter< N >::addVector ( FVector_ID  id, std::vector< float > const &  values  )

inlineinherited

Definition at line 81 of file MVAWriter.h.

{ fVectors[id]->emplace_back(values); }

template<size_t N>

void anab::FVectorWriter< N >::addVector ( FVector_ID  id, std::vector< double > const &  values  )

inlineinherited

Definition at line 82 of file MVAWriter.h.

{ fVectors[id]->emplace_back(values); }

template<size_t N>

template<class T >

std::array<float, N> anab::MVAWriter< N >::getOutput ( std::vector< art::Ptr< T > > const &  items ) const

inline

Get MVA results accumulated over the vector of items (eg. over hits associated to a cluster). NOTE: MVA outputs for these items has to be added to the MVAWriter first!

Definition at line 190 of file MVAWriter.h.

    { return pAccumulate<T, N>(items, *(FVectorWriter<N>::fVectors[FVectorWriter<N>::template getProductID<T>()])); }

template<size_t N>

template<class T >

std::array<float, N> anab::MVAWriter< N >::getOutput ( std::vector< art::Ptr< T > > const &  items, std::vector< float > const &  weights  ) const

inline

Get MVA results accumulated with provided weights over the vector of items (eg. over clusters associated to a track, weighted by the cluster size; or over hits associated to a cluster, weighted by the hit area). NOTE: MVA outputs for these items has to be added to the MVAWriter first!

Definition at line 198 of file MVAWriter.h.

    { return pAccumulate<T, N>(items, weights, *(FVectorWriter<N>::fVectors[FVectorWriter<N>::template getProductID<T>()])); }

template<size_t N>

template<class T >

std::array<float, N> anab::MVAWriter< N >::getOutput ( std::vector< art::Ptr< T > > const &  items, std::function< float(T const &)>  fweight  ) const

inline

Get MVA results accumulated with provided weighting function over the vector of items (eg. over clusters associated to a track, weighted by the cluster size; or over hits associated to a cluster, weighted by the hit area). NOTE: MVA outputs for these items has to be added to the MVAWriter first!

Definition at line 207 of file MVAWriter.h.

    { return pAccumulate<T, N>(items, fweight, *(FVectorWriter<N>::fVectors[FVectorWriter<N>::template getProductID<T>()])); }

template<size_t N>

template<class T >

std::array<float, N> anab::MVAWriter< N >::getOutput ( std::vector< art::Ptr< T > > const &  items, std::function< float(art::Ptr< T > const &)>  fweight  ) const

inline

Definition at line 212 of file MVAWriter.h.

    { return pAccumulate<T, N>(items, fweight, *(FVectorWriter<N>::fVectors[FVectorWriter<N>::template getProductID<T>()])); }

template<size_t N>

template<class T >

std::array<float, N> anab::MVAWriter< N >::getOutput ( size_t  key ) const

inline

Get copy of the MVA output vector for the type T, at index "key".

Definition at line 218 of file MVAWriter.h.

{ return FVectorWriter<N>::template getVector<T>(key); }

template<size_t N>

template<class T >

std::array<float, N> anab::MVAWriter< N >::getOutput ( art::Ptr< T > const &  item ) const

inline

Get copy of the MVA output vector for the type T, idicated with art::Ptr::key().

Definition at line 222 of file MVAWriter.h.

{ return FVectorWriter<N>::template getVector<T>(item); }

size_t anab::FVectorWrapperBase::getProductHash ( std::type_info const &  ti ) const

inlineprotectedinherited

Definition at line 31 of file MVAWrapperBase.h.

Referenced by anab::FVectorWriter< N >::getProductID(), and anab::FVectorWriter< N >::initOutputs().

{ return ti.hash_code(); }

template<size_t N>

template<class T >

FVector_ID anab::FVectorWriter< N >::getProductID ( ) const

protectedinherited

template<size_t N>

template<class T >

anab::FVector_ID anab::FVectorWriter< N >::getProductID ( ) const

inherited

Definition at line 233 of file MVAWriter.h.

References anab::FVectorWriter< N >::fTypeHashToID, anab::FVectorWrapperBase::getProductHash(), and anab::FVectorWrapperBase::getProductName().

{
    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;
    }
}

std::string anab::FVectorWrapperBase::getProductName ( std::type_info const &  ti ) const

protectedinherited

Definition at line 17 of file MVAWrapperBase.cxx.

Referenced by anab::FVectorReader< T, N >::FVectorReader(), anab::FVectorWriter< N >::getProductID(), anab::FVectorWriter< N >::initOutputs(), and anab::FVectorWriter< N >::produces_using().

{
    char* realname;
    int status;

    realname = abi::__cxa_demangle(ti.name(), 0, 0, &status);
    std::string pname(realname);
    free(realname);

    pname.erase( std::remove(pname.begin(), pname.end(), ' '), pname.end() );
    pname.erase( std::remove(pname.begin(), pname.end(), ':'), pname.end() );

    return pname;
}

template<size_t N>

template<class T >

std::array<float, N> anab::FVectorWriter< N >::getVector ( size_t  key ) const

inlineinherited

Get copy of the feature vector for the type T, at index "key".

Definition at line 98 of file MVAWriter.h.

    {
        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<size_t N>

template<class T >

std::array<float, N> anab::FVectorWriter< N >::getVector ( art::Ptr< T > const &  item ) const

inlineinherited

Get copy of the feature vector for the type T, idicated with art::Ptr::key().

Definition at line 108 of file MVAWriter.h.

    {
        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;
    }

template<size_t N>

template<class T >

FVector_ID anab::FVectorWriter< N >::initOutputs ( std::string const &  dataTag, size_t  dataSize, std::vector< std::string > const &  names = std::vector< std::string >(N,"")  )

inherited

Initialize container for FeatureVectors and, if not yet done, the container for metadata, then creates metadata for data products of type T. FeatureVector container is initialized to hold dataSize vectors (if dataSize > 0): use setOutput() to store values. Returns index of collection which should be used when saving actual output values.

Referenced by anab::FVectorWriter< 4 >::FVectorWriter(), and hit::DPRawHitFinder::produce().

template<size_t N>

template<class T >

FVector_ID anab::FVectorWriter< N >::initOutputs ( art::InputTag const &  dataTag, size_t  dataSize, std::vector< std::string > const &  names = std::vector< std::string >(N, "")  )

inlineinherited

Definition at line 55 of file MVAWriter.h.

    { return initOutputs<T>(dataTag.encode(), dataSize, names); }

template<size_t N>

template<class T >

FVector_ID anab::FVectorWriter< N >::initOutputs ( art::InputTag const &  dataTag, std::vector< std::string > const &  names = std::vector< std::string >(N, "")  )

inlineinherited

Initialize container for FeatureVectors and, if not yet done, the container for metadata, then creates metadata for data products of type T. FeatureVector container is initialized as EMPTY and vectors should be added with addOutput() function. Returns index of collection which should be used when adding actual output values.

Definition at line 70 of file MVAWriter.h.

    { return initOutputs<T>(dataTag.encode(), 0, names); }

template<size_t N>

template<class T >

FVector_ID anab::FVectorWriter< N >::initOutputs ( std::vector< std::string > const &  names = std::vector< std::string >(N, "") )

inlineinherited

Definition at line 75 of file MVAWriter.h.

    { return initOutputs<T>(std::string(""), 0, names); }

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  )

inherited

Definition at line 293 of file MVAWriter.h.

References anab::FVectorWriter< N >::dataTypeRegistered(), anab::FVectorWriter< N >::descriptionExists(), anab::FVectorWriter< N >::fDescriptions, anab::FVectorWriter< N >::fInstanceName, anab::FVectorWriter< N >::fTypeHashToID, anab::FVectorWriter< N >::fVectors, anab::FVectorWrapperBase::getProductHash(), anab::FVectorWrapperBase::getProductName(), and lar::dump::vector().

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

size_t anab::FVectorWriter< N >::length ( ) const

inlineinherited

Get the length of a single feature vector.

Definition at line 94 of file MVAWriter.h.

{ return N; }

template<class T , size_t N>

std::array< float, N > anab::MVAWrapperBase::pAccumulate ( std::vector< art::Ptr< T > > const &  items, std::vector< FeatureVector< N > > const &  outs  ) const

protectedinherited

Definition at line 80 of file MVAWrapperBase.h.

References trkf::fill().

{
    std::array<double, N> acc;
    acc.fill(0);

        float pmin = 1.0e-6, pmax = 1.0 - pmin;
        float log_pmin = std::log(pmin), log_pmax = std::log(pmax);

        for (auto const & ptr : items)
        {
                auto const & vout = outs[ptr.key()];
                for (size_t i = 0; i < vout.size(); ++i)
                {
                    float v;
                        if (vout[i] < pmin) v = log_pmin;
                        else if (vout[i] > pmax) v = log_pmax;
                        else v = std::log(vout[i]);

                        acc[i] += v;
                }
        }

        if (!items.empty())
        {
                double totp = 0.0;
                for (size_t i = 0; i < N; ++i)
                {
                        acc[i] = exp(acc[i] / items.size());
                        totp += acc[i];
                }
                for (size_t i = 0; i < N; ++i)
                {
                        acc[i] /= totp;
                }
        }
        else std::fill(acc.begin(), acc.end(), 1.0 / N);


    std::array<float, N> result;
    for (size_t i = 0; i < N; ++i) result[i] = acc[i];
    return result;
}

template<class T , size_t N>

std::array< float, N > anab::MVAWrapperBase::pAccumulate ( std::vector< art::Ptr< T > > const &  items, std::vector< float > const &  weights, std::vector< FeatureVector< N > > const &  outs  ) const

protectedinherited

Definition at line 127 of file MVAWrapperBase.h.

References trkf::fill(), and w.

{
    std::array<double, N> acc;
    acc.fill(0);

        float pmin = 1.0e-6, pmax = 1.0 - pmin;
        float log_pmin = std::log(pmin), log_pmax = std::log(pmax);
        double totw = 0.0;

        for (size_t k = 0; k < items.size(); ++k)
        {
            auto const & ptr = items[k];
                float w = weights[k];

                if (w == 0) continue;

                auto const & vout = outs[ptr.key()];
                for (size_t i = 0; i < vout.size(); ++i)
                {
                    float v;
                        if (vout[i] < pmin) v = log_pmin;
                        else if (vout[i] > pmax) v = log_pmax;
                        else v = std::log(vout[i]);

                        acc[i] += w * v;
                }
                totw += w;
        }

        if (!items.empty())
        {
                double totp = 0.0;
                for (size_t i = 0; i < N; ++i)
                {
                        acc[i] = exp(acc[i] / totw);
                        totp += acc[i];
                }
                for (size_t i = 0; i < N; ++i)
                {
                        acc[i] /= totp;
                }
        }
        else std::fill(acc.begin(), acc.end(), 1.0 / N);


    std::array<float, N> result;
    for (size_t i = 0; i < N; ++i) result[i] = acc[i];
    return result;
}

template<class T , size_t N>

std::array< float, N > anab::MVAWrapperBase::pAccumulate ( std::vector< art::Ptr< T > > const &  items, std::function< float(T const &)>  fweight, std::vector< FeatureVector< N > > const &  outs  ) const

protectedinherited

Definition at line 181 of file MVAWrapperBase.h.

References trkf::fill(), and w.

{
    std::array<double, N> acc;
    acc.fill(0);

        float pmin = 1.0e-6, pmax = 1.0 - pmin;
        float log_pmin = std::log(pmin), log_pmax = std::log(pmax);
        double totw = 0.0;

        for (size_t k = 0; k < items.size(); ++k)
        {
            auto const & ptr = items[k];
                float w = fweight(*ptr);

                if (w == 0) continue;

                auto const & vout = outs[ptr.key()];
                for (size_t i = 0; i < vout.size(); ++i)
                {
                    float v;
                        if (vout[i] < pmin) v = log_pmin;
                        else if (vout[i] > pmax) v = log_pmax;
                        else v = std::log(vout[i]);

                        acc[i] += w * v;
                }
                totw += w;
        }

        if (!items.empty())
        {
                double totp = 0.0;
                for (size_t i = 0; i < N; ++i)
                {
                        acc[i] = exp(acc[i] / totw);
                        totp += acc[i];
                }
                for (size_t i = 0; i < N; ++i)
                {
                        acc[i] /= totp;
                }
        }
        else std::fill(acc.begin(), acc.end(), 1.0 / N);


    std::array<float, N> result;
    for (size_t i = 0; i < N; ++i) result[i] = acc[i];
    return result;
}

template<class T , size_t N>

std::array< float, N > anab::MVAWrapperBase::pAccumulate ( std::vector< art::Ptr< T > > const &  items, std::function< float(art::Ptr< T > const &)>  fweight, std::vector< FeatureVector< N > > const &  outs  ) const

protectedinherited

Definition at line 235 of file MVAWrapperBase.h.

References trkf::fill(), and w.

{
    std::array<double, N> acc;
    acc.fill(0);

        float pmin = 1.0e-6, pmax = 1.0 - pmin;
        float log_pmin = std::log(pmin), log_pmax = std::log(pmax);
        double totw = 0.0;

        for (size_t k = 0; k < items.size(); ++k)
        {
            auto const & ptr = items[k];
                float w = fweight(ptr);

                if (w == 0) continue;

                auto const & vout = outs[ptr.key()];
                for (size_t i = 0; i < vout.size(); ++i)
                {
                    float v;
                        if (vout[i] < pmin) v = log_pmin;
                        else if (vout[i] > pmax) v = log_pmax;
                        else v = std::log(vout[i]);

                        acc[i] += w * v;
                }
                totw += w;
        }

        if (!items.empty())
        {
                double totp = 0.0;
                for (size_t i = 0; i < N; ++i)
                {
                        acc[i] = exp(acc[i] / totw);
                        totp += acc[i];
                }
                for (size_t i = 0; i < N; ++i)
                {
                        acc[i] /= totp;
                }
        }
        else std::fill(acc.begin(), acc.end(), 1.0 / N);


    std::array<float, N> result;
    for (size_t i = 0; i < N; ++i) result[i] = acc[i];
    return result;
}

template<class T , size_t N>

std::array< float, N > anab::MVAWrapperBase::pAccumulate ( std::vector< art::Ptr< T > > const &  items, std::vector< FeatureVector< N > > const &  outs, std::array< char, N > const &  mask  ) const

protectedinherited

Definition at line 293 of file MVAWrapperBase.h.

{
    size_t n_groups = 0;
    std::unordered_map<char, size_t> label2group;
    std::vector<size_t> nb_entries;
    std::array<int, N> groupidx;
    for (size_t i = 0; i < N; ++i)
    {
        int idx = -1;
        if (mask[i] >= 0)
        {
            auto search = label2group.find(mask[i]);
            if (search == label2group.end())
            {
                idx = n_groups;
                label2group[mask[i]] = idx;
                nb_entries.push_back(0);
                ++n_groups;
            }
            else
            {
                idx = search->second;
                nb_entries[idx]++;
            }
        }
        groupidx[i] = idx;
    }

    std::array<double, N> acc;
    acc.fill(0);

        float pmin = 1.0e-6, pmax = 1.0 - pmin;
        float log_pmin = std::log(pmin), log_pmax = std::log(pmax);

        for (auto const & ptr : items)
        {
                auto const & vout = outs[ptr.key()];
                for (size_t i = 0; i < vout.size(); ++i)
                {
                    if (groupidx[i] < 0) continue;

                    float v;
                        if (vout[i] < pmin) v = log_pmin;
                        else if (vout[i] > pmax) v = log_pmax;
                        else v = std::log(vout[i]);

                        acc[i] += v;
                }
        }

        if (!items.empty())
        {
                std::vector<double> totp(n_groups, 0.0);
                for (size_t i = 0; i < N; ++i)
                {
                    if (groupidx[i] >= 0)
            {
                        acc[i] = exp(acc[i] / items.size());
                        totp[groupidx[i]] += acc[i];
                }
                }
                for (size_t i = 0; i < N; ++i)
                {
                        if (groupidx[i] >= 0) { acc[i] /= totp[groupidx[i]]; }
                }
        }
        else
        {
            for (size_t i = 0; i < N; ++i)
            {
                 if (groupidx[i] >= 0) { acc[i] = 1 / nb_entries[groupidx[i]]; }
            }
    }

    std::array<float, N> result;
    for (size_t i = 0; i < N; ++i) result[i] = acc[i];
    return result;
}

template<size_t N>

template<class T >

void anab::FVectorWriter< N >::produces_using ( )

inherited

Register the collection of metadata type FVecDescription<N> (once for all data types for which vectors are saved) and the collection of FeatureVectors<N> (using data type name added to fInstanceName as instance name of the collection made for the type T).

Definition at line 258 of file MVAWriter.h.

References anab::FVectorWriter< N >::dataTypeRegistered(), anab::FVectorWriter< N >::fInstanceName, anab::FVectorWriter< N >::fIsDescriptionRegistered, anab::FVectorWriter< N >::fProducer, anab::FVectorWriter< N >::fRegisteredDataTypes, and anab::FVectorWrapperBase::getProductName().

Referenced by hit::DPRawHitFinder::DPRawHitFinder(), and anab::FVectorWriter< 4 >::FVectorWriter().

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

void anab::FVectorWriter< N >::saveOutputs ( art::Event &  evt )

inherited

Check consistency and save all the results in the event.

Definition at line 326 of file MVAWriter.h.

References anab::FVectorWriter< N >::clearEventData(), anab::FVectorWriter< N >::descriptionExists(), anab::FVectorWriter< N >::fDescriptions, anab::FVectorWriter< N >::fInstanceName, anab::FVectorWriter< N >::fRegisteredDataTypes, anab::FVectorWriter< N >::fVectors, n, and art::Event::put().

Referenced by hit::DPRawHitFinder::produce(), and anab::FVectorWriter< 4 >::setDataTag().

{
    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();
}

template<size_t N>

void anab::FVectorWriter< N >::setDataTag ( FVector_ID  id, art::InputTag const &  dataTag  )

inlineinherited

Set tag of associated data products in case it was not ready at the initialization time.

Definition at line 85 of file MVAWriter.h.

{ (*fDescriptions)[id].setDataTag(dataTag.encode()); }

template<size_t N>

void anab::MVAWriter< N >::setOutput ( FVector_ID  id, size_t  key, std::array< float, N > const &  values  )

inline

Definition at line 176 of file MVAWriter.h.

References anab::FVectorWriter< N >::setVector().

{ FVectorWriter<N>::setVector(id, key, values); }

template<size_t N>

void anab::MVAWriter< N >::setOutput ( FVector_ID  id, size_t  key, std::array< double, N > const &  values  )

inline

Definition at line 177 of file MVAWriter.h.

References anab::FVectorWriter< N >::setVector().

{ FVectorWriter<N>::setVector(id, key, values); }

template<size_t N>

void anab::MVAWriter< N >::setOutput ( FVector_ID  id, size_t  key, std::vector< float > const &  values  )

inline

Definition at line 178 of file MVAWriter.h.

References anab::FVectorWriter< N >::setVector().

{ FVectorWriter<N>::setVector(id, key, values); }

template<size_t N>

void anab::MVAWriter< N >::setOutput ( FVector_ID  id, size_t  key, std::vector< double > const &  values  )

inline

Definition at line 179 of file MVAWriter.h.

References anab::FVectorWriter< N >::setVector().

{ FVectorWriter<N>::setVector(id, key, values); }

template<size_t N>

void anab::FVectorWriter< N >::setVector ( FVector_ID  id, size_t  key, std::array< float, N > const &  values  )

inlineinherited

Definition at line 59 of file MVAWriter.h.

Referenced by anab::MVAWriter< N >::setOutput().

{ (*(fVectors[id]))[key] = values; }

template<size_t N>

void anab::FVectorWriter< N >::setVector ( FVector_ID  id, size_t  key, std::array< double, N > const &  values  )

inlineinherited

Definition at line 60 of file MVAWriter.h.

{ (*(fVectors[id]))[key] = values; }

template<size_t N>

void anab::FVectorWriter< N >::setVector ( FVector_ID  id, size_t  key, std::vector< float > const &  values  )

inlineinherited

Definition at line 61 of file MVAWriter.h.

{ (*(fVectors[id]))[key] = values; }

template<size_t N>

void anab::FVectorWriter< N >::setVector ( FVector_ID  id, size_t  key, std::vector< double > const &  values  )

inlineinherited

Definition at line 62 of file MVAWriter.h.

{ (*(fVectors[id]))[key] = values; }

template<size_t N>

size_t anab::FVectorWriter< N >::size ( FVector_ID  id ) const

inlineinherited

Get the number of contained feature vectors.

Definition at line 91 of file MVAWriter.h.

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

Member Data Documentation

template<size_t N>

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

protectedinherited

Definition at line 132 of file MVAWriter.h.

Referenced by anab::FVectorWriter< 4 >::addVector(), anab::FVectorWriter< 4 >::getVector(), anab::FVectorWriter< N >::initOutputs(), anab::FVectorWriter< N >::saveOutputs(), anab::FVectorWriter< 4 >::setVector(), and anab::FVectorWriter< 4 >::size().

---

The documentation for this class was generated from the following file:

• lardata/v06_47_03/source/lardata/ArtDataHelper/MVAWriter.h