#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

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

Referenced by anab::MVAWriter< 4 >::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
	)

inline

Definition at line 100 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 104 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 108 of file MVAWriter.h.

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

template<size_t N>

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

inlineprivate

Definition at line 183 of file MVAWriter.h.

Referenced by anab::FVectorWriter< N >::saveOutputs().

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

References anab::FVectorWriter< N >::fRegisteredDataTypes.

Referenced by anab::FVectorWriter< 4 >::clearEventData(), anab::FVectorWriter< N >::initOutputs(), and anab::FVectorWriter< N >::produces_using().

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

References d, anab::FVectorWriter< N >::fDescriptions, anab::FVectorWriter< N >::fInstanceName, and n.

Referenced by anab::FVectorWriter< 4 >::clearEventData(), anab::FVectorWriter< N >::initOutputs(), and anab::FVectorWriter< N >::saveOutputs().

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

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

inlineprotectedinherited

Definition at line 29 of file MVAWrapperBase.h.

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

29 { return ti.hash_code(); }

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

inline

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

Definition at line 130 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 141 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.

Referenced by anab::FVectorWriter< 4 >::FVectorWriter(), hit::DPRawHitFinder::produce(), nnet::EmTrackClusterId2out::produce(), nnet::EmTrackClusterId::produce(), and nnet::EmTrackMichelId::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, "")`
	)

inline

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

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 84 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 91 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 374 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

inline

Get the length of a single feature vector.

Definition at line 126 of file MVAWriter.h.

126 { 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 341 of file MVAWriter.h.

References anab::FVectorWriter< N >::dataTypeRegistered(), anab::FVectorWriter< N >::fCollector, anab::FVectorWriter< N >::fInstanceName, anab::FVectorWriter< N >::fIsDescriptionRegistered, anab::FVectorWriter< N >::fRegisteredDataTypes, anab::FVectorWrapperBase::getProductName(), and art::ProducesCollector::produces().

Referenced by hit::DPRawHitFinder::DPRawHitFinder(), nnet::EmTrackClusterId::EmTrackClusterId(), nnet::EmTrackClusterId2out::EmTrackClusterId2out(), nnet::EmTrackMichelId::EmTrackMichelId(), 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) {
     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 404 of file MVAWriter.h.

References anab::FVectorWriter< N >::clearEventData(), anab::FVectorWriter< N >::descriptionExists(), util::empty(), 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(), nnet::EmTrack< N >::produce(), nnet::EmTrackClusterId2out::produce(), nnet::EmTrackClusterId::produce(), nnet::EmTrackMichelId::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
	)

inline

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

Definition at line 114 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 62 of file MVAWriter.h.

Referenced by anab::MVAWriter< 4 >::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
	)

inline

Definition at line 66 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 70 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 74 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 123 of file MVAWriter.h.

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

anab::FVectorWriter::fVectors

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

Definition: MVAWriter.h:170

Friends And Related Function Documentation

template<size_t N>

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

friend

Definition at line 150 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;
     }