anab::FVectorWriter< N > Class Template Reference

#include <MVAWriter.h>

Inheritance diagram for anab::FVectorWriter< N >:

Public Member Functions
	FVectorWriter (art::ProducesCollector &collector, const char *name="")
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,""))
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)
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,""))
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
template<class T >
anab::FVector_ID	initOutputs (std::string const &dataTag, size_t dataSize, std::vector< std::string > const &names)

Protected Member Functions
template<class T >
FVector_ID	getProductID () const
Protected Member Functions inherited from anab::FVectorWrapperBase
std::string	getProductName (std::type_info const &ti) const
size_t	getProductHash (std::type_info const &ti) const

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

Private Member Functions
void	clearEventData ()
bool	dataTypeRegistered (const std::string &dname) const
	Check if the the writer is configured to write results for data product type name. More...
bool	descriptionExists (const std::string &tname) const
	Check if the containers for results prepared for "tname" data type are ready. More...

Private Attributes
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

Friends
std::ostream &	operator<< (std::ostream &o, FVectorWriter const &a)

Detailed Description

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

Definition at line 25 of file MVAWriter.h.

Constructor & Destructor Documentation

template<size_t N>

anab::FVectorWriter< N >::FVectorWriter ( art::ProducesCollector &  collector, const char *  name = ""  )

inline

Name provided to the constructor is used as an instance name for FVecDescription<N> and FeatureVector<N> (for which it is combined with the processed data product names). The name is used as an instance name for the FVecDescription data product which lets you to save multiple vector collections from a single art module.

Definition at line 32 of file MVAWriter.h.

                                                                          :
        fCollector(collector), fInstanceName(name),
        fIsDescriptionRegistered(false),
        fDescriptions(nullptr)
    { }

Member Function Documentation

template<size_t N>

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

inline

Definition at line 78 of file MVAWriter.h.

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

template<size_t N>

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

inline

Definition at line 79 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  )

inline

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< double > const &  values  )

inline

Definition at line 81 of file MVAWriter.h.

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

template<size_t N>

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

inlineprivate

Definition at line 144 of file MVAWriter.h.

    {
        fTypeHashToID.clear(); fVectors.clear();
        fDescriptions.reset(nullptr);
    }

template<size_t N>

bool anab::FVectorWriter< N >::dataTypeRegistered ( const std::string &  dname ) const

private

Check if the the writer is configured to write results for data product type name.

Definition at line 245 of file MVAWriter.h.

{
    for (auto const & s : fRegisteredDataTypes)
    {
        if (s == dname) { return true; }
    }
    return false;
}

template<size_t N>

bool anab::FVectorWriter< N >::descriptionExists ( const std::string &  tname ) const

private

Check if the containers for results prepared for "tname" data type are ready.

Definition at line 277 of file MVAWriter.h.

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

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

protected

template<size_t N>

template<class T >

anab::FVector_ID anab::FVectorWriter< N >::getProductID

(

)

const

Definition at line 232 of file MVAWriter.h.

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

template<class T >

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

inline

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

Definition at line 97 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

inline

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

Definition at line 107 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,"")
	)

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.

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, "")  )

inline

Definition at line 54 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, "")  )

inline

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 69 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, "") )

inline

Definition at line 74 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
	)

Definition at line 292 of file MVAWriter.h.

{
    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

inline

Get the length of a single feature vector.

Definition at line 93 of file MVAWriter.h.

{ return N; }

template<size_t N>

template<class T >

void anab::FVectorWriter< N >::produces_using

(

)

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 257 of file MVAWriter.h.

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

void anab::FVectorWriter< N >::saveOutputs

(

art::Event &

evt

)

Check consistency and save all the results in the event.

Definition at line 325 of file MVAWriter.h.

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

inline

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

Definition at line 84 of file MVAWriter.h.

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

template<size_t N>

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

inline

Definition at line 58 of file MVAWriter.h.

{ (*(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  )

inline

Definition at line 59 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  )

inline

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< double > const &  values  )

inline

Definition at line 61 of file MVAWriter.h.

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

template<size_t N>

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

inline

Get the number of contained feature vectors.

Definition at line 90 of file MVAWriter.h.

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

Friends And Related Function Documentation

template<size_t N>

std::ostream& operator<< ( std::ostream &  o, FVectorWriter< N > const &  a  )

friend

Definition at line 115 of file MVAWriter.h.

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

Member Data Documentation

template<size_t N>

art::ProducesCollector& anab::FVectorWriter< N >::fCollector

private

Definition at line 135 of file MVAWriter.h.

template<size_t N>

std::unique_ptr< std::vector< anab::FVecDescription<N> > > anab::FVectorWriter< N >::fDescriptions

private

Definition at line 143 of file MVAWriter.h.

template<size_t N>

std::string anab::FVectorWriter< N >::fInstanceName

private

Definition at line 136 of file MVAWriter.h.

template<size_t N>

bool anab::FVectorWriter< N >::fIsDescriptionRegistered

private

Definition at line 139 of file MVAWriter.h.

template<size_t N>

std::vector< std::string > anab::FVectorWriter< N >::fRegisteredDataTypes

private

Definition at line 138 of file MVAWriter.h.

template<size_t N>

std::unordered_map< size_t, FVector_ID > anab::FVectorWriter< N >::fTypeHashToID

private

Definition at line 141 of file MVAWriter.h.

template<size_t N>

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

protected

Definition at line 131 of file MVAWriter.h.

---

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

• lardata/lardata/ArtDataHelper/MVAWriter.h