#include <MultiChainEvent.h>

Inheritance diagram for fwlite::MultiChainEvent:

Public Types
typedef std::pair< edm::EventID, edm::EventID >	event_id_range

typedef std::map< edm::EventID, Long64_t >	sec_file_index_map

typedef std::map< event_id_range, Long64_t >	sec_file_range_index_map

Public Member Functions
bool	atEnd () const

virtual edm::EventAuxiliary const &	eventAuxiliary () const

Long64_t	eventIndex () const

Long64_t	eventIndexSec () const

virtual Long64_t	fileIndex () const

std::vector< edm::BranchDescription > const &	getBranchDescriptions () const

virtual std::string const	getBranchNameFor (std::type_info const &, char const , char const , char const *) const

virtual bool	getByLabel (std::type_info const &, char const , char const , char const , void ) const

virtual edm::WrapperBase const *	getByProductID (edm::ProductID const &) const

fwlite::LuminosityBlock const &	getLuminosityBlock ()

std::vector< std::string > const &	getProcessHistory () const

fwlite::Run const &	getRun ()

TFile *	getTFile () const

TFile *	getTFileSec () const

edm::WrapperBase const *	getThinnedProduct (edm::ProductID const &pid, unsigned int &key) const

void	getThinnedProducts (edm::ProductID const &pid, std::vector< edm::WrapperBase const * > &foundContainers, std::vector< unsigned int > &keys) const

bool	isValid () const

	MultiChainEvent (std::vector< std::string > const &iFileNames1, std::vector< std::string > const &iFileNames2, bool useSecFileMapSorted=false)

	operator bool () const

const MultiChainEvent &	operator++ ()

ChainEvent const *	primary () const

edm::ProcessHistory const &	processHistory () const

ChainEvent const *	secondary () const

virtual Long64_t	secondaryFileIndex () const

Long64_t	size () const

bool	to (Long64_t iIndex)
	Go to the event at index iIndex. More...

bool	to (edm::EventID id)
	Go to event with event id "id". More...

bool	to (edm::RunNumber_t run, edm::EventNumber_t event)
	Go to event with given run and event number. More...

bool	to (edm::RunNumber_t run, edm::LuminosityBlockNumber_t lumi, edm::EventNumber_t event)
	Go to event with given run , lumi (if non-zero), and event number. More...

const MultiChainEvent &	toBegin ()

virtual edm::TriggerNames const &	triggerNames (edm::TriggerResults const &triggerResults) const

virtual edm::TriggerResultsByName	triggerResultsByName (edm::TriggerResults const &triggerResults) const

virtual	~MultiChainEvent ()

Public Member Functions inherited from fwlite::EventBase
	EventBase ()

virtual	~EventBase ()

Public Member Functions inherited from edm::EventBase
int	bunchCrossing () const

	EventBase ()

edm::EventAuxiliary::ExperimentType	experimentType () const

template<typename T >
bool	get (ProductID const &, Handle< T > &) const

template<typename T >
bool	getByLabel (InputTag const &, Handle< T > &) const

template<>
bool	getByLabel (edm::InputTag const &tag, Handle< FWGenericObject > &result) const
	Specialize the getByLabel method to work with a Handle<FWGenericObject> More...

edm::EventID	id () const

bool	isRealData () const

edm::LuminosityBlockNumber_t	luminosityBlock () const

int	orbitNumber () const

edm::Timestamp	time () const

Static Public Member Functions
static void	throwProductNotFoundException (std::type_info const &, char const , char const , char const *)

Private Member Functions
	MultiChainEvent (Event const &)

const MultiChainEvent &	operator= (Event const &)

bool	toSec (Long64_t iIndex)
	Go to the event from secondary files at index iIndex. More...

bool	toSec (const edm::EventID &id)

bool	toSec (edm::RunNumber_t run, edm::LuminosityBlockNumber_t lumi, edm::EventNumber_t event)
	Go to event with given run, lumi, and event number. More...

bool	toSec (edm::RunNumber_t run, edm::EventNumber_t event)
	Go to event with given run and event number. More...

Private Attributes
std::shared_ptr< ChainEvent >	event1_

std::shared_ptr< ChainEvent >	event2_

std::shared_ptr< internal::MultiProductGetter const >	getter_

sec_file_range_index_map	secFileMapSorted_

bool	useSecFileMapSorted_

Additional Inherited Members
Static Protected Member Functions inherited from edm::EventBase
static TriggerNames const *	triggerNames_ (edm::TriggerResults const &triggerResults)

Detailed Description

Definition at line 50 of file MultiChainEvent.h.

Member Typedef Documentation

typedef std::pair<edm::EventID, edm::EventID> fwlite::MultiChainEvent::event_id_range

Definition at line 56 of file MultiChainEvent.h.

typedef std::map<edm::EventID, Long64_t> fwlite::MultiChainEvent::sec_file_index_map

Definition at line 55 of file MultiChainEvent.h.

typedef std::map<event_id_range, Long64_t> fwlite::MultiChainEvent::sec_file_range_index_map

Definition at line 57 of file MultiChainEvent.h.

Constructor & Destructor Documentation

MultiChainEvent::MultiChainEvent	(	std::vector< std::string > const &	iFileNames1,
		std::vector< std::string > const &	iFileNames2,
		bool	useSecFileMapSorted = `false`
	)

Definition at line 71 of file MultiChainEvent.cc.

References gather_cfg::cout, and makeLayoutFileForGui::toAdd.

 {
   event1_ = std::make_shared<ChainEvent>(iFileNames1);
   event2_ = std::make_shared<ChainEvent>(iFileNames2);
 
   getter_ = std::make_shared<internal::MultiProductGetter>(this);
 
   if (event1_->size() == 0) {
     std::cout << "------------------------------------------------------------------------" << std::endl;
     std::cout << "WARNING! MultiChainEvent: all primary files have zero events."        << std::endl;
     std::cout << "Trying to access the events may lead to a crash.  "  << std::endl;
     std::cout << "------------------------------------------------------------------------" << std::endl;
   } else {
     event1_->setGetter(getter_);
     event2_->setGetter(getter_);
   }
 
   useSecFileMapSorted_ = useSecFileMapSorted;
 
   if (!useSecFileMapSorted_) {
     std::cout << "------------------------------------------------------------------------" << std::endl;
     std::cout << "WARNING! What you are about to do may be very slow." << std::endl;
     std::cout << "The 2-file solution in FWLite works with very simple assumptions." << std::endl;
     std::cout << "It will linearly search through the files in the secondary file list for Products." << std::endl;
     std::cout << "There are speed improvements available to make this run faster." << std::endl;
     std::cout << "***If your secondary files are sorted with a run-range within a file, (almost always the case) " << std::endl;
     std::cout << "***please use the option useSecFileMapSorted=true in this constructor. " << std::endl;
     std::cout << "    > usage: MultiChainEvent(primaryFiles, secondaryFiles, true);" << std::endl;
     std::cout << "------------------------------------------------------------------------" << std::endl;
 
   }
 
   if (useSecFileMapSorted_) {
 
     std::cout << "------------------------------------------------------------------------" << std::endl;
     std::cout << "This MultiChainEvent is now creating a (run_range)_2 ---> file_index_2 map" << std::endl;
     std::cout << "for the 2-file solution. " << std::endl;
     std::cout << "This is assuming the files you are giving me are sorted by run,event pairs within each secondary file." << std::endl;
     std::cout << "If this is not true (rarely the case), set this option to false." << std::endl;
     std::cout << "    > usage: MultiChainEvent(primaryFiles, secondaryFiles, false);" << std::endl;
     std::cout << "------------------------------------------------------------------------" << std::endl;
     // speed up secondary file access with a (run,event)_1 ---> index_2 map
 
 
     // Loop over events, when a new file is encountered, store the first run number from this file,
     // and the last run number from the last file.
     TFile * lastFile = nullptr;
     std::pair<event_id_range,Long64_t> eventRange;
     bool firstFile = true;
 
     bool foundAny = false;
 
     for(event2_->toBegin();
          ! event2_->atEnd();
          ++(*event2_)) {
       // if we have a new file, cache the "first"
       if (lastFile != event2_->getTFile()) {
 
         // if this is not the first file, we have an entry.
         // Add it to the list.
         if (!firstFile) {
           foundAny = true;
           event_id_range toAdd = eventRange.first;
           secFileMapSorted_[ toAdd ] = eventRange.second;
         }
         // always add the "first" event id to the cached event range
         eventRange.first.first = event2_->event()->id();
         lastFile = event2_->getTFile();
       }
       // otherwise, cache the "second" event id in the cached event range.
       // Upon the discovery of a new file, this will be used as the
       // "last" event id in the cached event range.
       else {
         eventRange.first.second = event2_->event()->id();
         eventRange.second = event2_->eventIndex();
       }
       firstFile = false;
     }
     // due to the invailability of a "look ahead" operation, we have one additional "put" to make
     // after the loop (which puts the "last" event, not "this" event.
     if (foundAny) {
       event_id_range toAdd = eventRange.first;
       secFileMapSorted_[ toAdd ] = eventRange.second;
     }
 //     std::cout << "Dumping run range to event id list:" << std::endl;
 //     for (sec_file_range_index_map::const_iterator mBegin = secFileMapSorted_.begin(),
 //          mEnd = secFileMapSorted_.end(),
 //          mit = mBegin;
 //        mit != mEnd; ++mit) {
 //       char buff[1000];
 //       event2_->to(mit->second);
 //       sprintf(buff, "[%10d,%10d - %10d,%10d] ---> %10d",
 //            mit->first.first.run(),
 //            mit->first.first.event(),
 //            mit->first.second.run(),
 //            mit->first.second.event(),
 //            mit->second);
 //       std::cout << buff << std::endl;
 //     }
   }
 
 }

MultiChainEvent::~MultiChainEvent ( )

virtual

Definition at line 181 of file MultiChainEvent.cc.

182 {

183 }

fwlite::MultiChainEvent::MultiChainEvent ( Event const & )

private

Member Function Documentation

bool MultiChainEvent::atEnd ( ) const

virtual

Implements fwlite::EventBase.

Definition at line 428 of file MultiChainEvent.cc.

 {
   return event1_->atEnd();
 }

edm::EventAuxiliary const & MultiChainEvent::eventAuxiliary ( ) const

virtual

Implements edm::EventBase.

Definition at line 360 of file MultiChainEvent.cc.

 {
    return event1_->eventAuxiliary();
 }

Long64_t fwlite::MultiChainEvent::eventIndex ( ) const

inline

Definition at line 108 of file MultiChainEvent.h.

108 { return event1_->eventIndex(); }

fwlite::MultiChainEvent::event1_

std::shared_ptr< ChainEvent > event1_

Definition: MultiChainEvent.h:162

Long64_t fwlite::MultiChainEvent::eventIndexSec ( ) const

inline

Definition at line 109 of file MultiChainEvent.h.

109 { return event2_->eventIndex(); }

fwlite::MultiChainEvent::event2_

std::shared_ptr< ChainEvent > event2_

Definition: MultiChainEvent.h:163

virtual Long64_t fwlite::MultiChainEvent::fileIndex ( ) const

inlinevirtual

Reimplemented from fwlite::EventBase.

Definition at line 120 of file MultiChainEvent.h.

Referenced by python.Events::fileIndicies().

121 { return event1_->eventIndex(); }

fwlite::MultiChainEvent::event1_

std::shared_ptr< ChainEvent > event1_

Definition: MultiChainEvent.h:162

std::vector< edm::BranchDescription > const & MultiChainEvent::getBranchDescriptions ( ) const

Definition at line 342 of file MultiChainEvent.cc.

 {
   return event1_->getBranchDescriptions();
 }

std::string const MultiChainEvent::getBranchNameFor	(	std::type_info const &	iType,
		char const *	iModule,
		char const *	iInstance,
		char const *	iProcess
	)		const

virtual

Implements fwlite::EventBase.

Definition at line 333 of file MultiChainEvent.cc.

 {
   return event1_->getBranchNameFor(iType,iModule,iInstance,iProcess);
 }

bool MultiChainEvent::getByLabel	(	std::type_info const &	iType,
		char const *	iModule,
		char const *	iInstance,
		char const *	iProcess,
		void *	iValue
	)		const

virtual

This function should only be called by fwlite::Handle<>

Implements fwlite::EventBase.

Definition at line 366 of file MultiChainEvent.cc.

 {
   bool ret1 = event1_->getByLabel(iType, iModule, iInstance, iProcess, iValue);
   if (!ret1) {
     (const_cast<MultiChainEvent*>(this))->toSec(event1_->id());
     bool ret2 = event2_->getByLabel(iType,iModule,iInstance,iProcess,iValue);
     if (!ret2) return false;
   }
   return true;
 }

edm::WrapperBase const * MultiChainEvent::getByProductID ( edm::ProductID const & iID ) const

virtual

Implements fwlite::EventBase.

Definition at line 382 of file MultiChainEvent.cc.

Referenced by fwlite::internal::MultiProductGetter::getIt().

 {
   // First try the first file
   edm::WrapperBase const* edp = event1_->getByProductID(iID);
   // Did not find the product, try secondary file
   if (edp == nullptr) {
     (const_cast<MultiChainEvent*>(this))->toSec(event1_->id());
     edp = event2_->getByProductID(iID);
   }
   return edp;
 }

fwlite::LuminosityBlock const& fwlite::MultiChainEvent::getLuminosityBlock ( )

inline

Definition at line 111 of file MultiChainEvent.h.

                                                         {
         return event1_->getLuminosityBlock();
       }

std::vector< std::string > const & MultiChainEvent::getProcessHistory ( ) const

Definition at line 348 of file MultiChainEvent.cc.

 {
   return event1_->getProcessHistory();
 }

fwlite::Run const& fwlite::MultiChainEvent::getRun ( )

inline

Definition at line 115 of file MultiChainEvent.h.

                                 {
         return event1_->getRun();
       }

TFile* fwlite::MultiChainEvent::getTFile ( ) const

inline

Definition at line 101 of file MultiChainEvent.h.

                               {
         return event1_->getTFile();
       }

TFile* fwlite::MultiChainEvent::getTFileSec ( ) const

inline

Definition at line 104 of file MultiChainEvent.h.

                                  {
         return event2_->getTFile();
       }

edm::WrapperBase const * MultiChainEvent::getThinnedProduct	(	edm::ProductID const &	pid,
		unsigned int &	key
	)		const

Definition at line 394 of file MultiChainEvent.cc.

Referenced by fwlite::internal::MultiProductGetter::getThinnedProduct().

                                                                                                          {
   // First try the first file
   edm::WrapperBase const* edp = event1_->getThinnedProduct(pid, key);
   // Did not find the product, try secondary file
   if (edp == nullptr) {
     (const_cast<MultiChainEvent*>(this))->toSec(event1_->id());
     edp = event2_->getThinnedProduct(pid, key);
   }
   return edp;
 }

void MultiChainEvent::getThinnedProducts	(	edm::ProductID const &	pid,
		std::vector< edm::WrapperBase const * > &	foundContainers,
		std::vector< unsigned int > &	keys
	)		const

Definition at line 405 of file MultiChainEvent.cc.

References spr::find().

Referenced by fwlite::internal::MultiProductGetter::getThinnedProducts().

                                                                               {
   // First try the first file
   event1_->getThinnedProducts(pid, wrappers, keys);
   // Did not find all the products, try secondary file
   if(std::find(wrappers.begin(), wrappers.end(), nullptr) != wrappers.end()) {
     (const_cast<MultiChainEvent*>(this))->toSec(event1_->id());
     event2_->getThinnedProducts(pid, wrappers, keys);
   }
 }

bool MultiChainEvent::isValid ( void ) const

Definition at line 418 of file MultiChainEvent.cc.

Referenced by ntuple._Object::_checkIsValid(), and core.AutoHandle.AutoHandle::ReallyLoad().

 {
   return event1_->isValid();
 }

MultiChainEvent::operator bool ( ) const

Definition at line 422 of file MultiChainEvent.cc.

 {
   return *event1_;
 }

const MultiChainEvent & MultiChainEvent::operator++ ( )

virtual

Implements fwlite::EventBase.

Definition at line 202 of file MultiChainEvent.cc.

 {
    event1_->operator++();
    return *this;
 }

const MultiChainEvent& fwlite::MultiChainEvent::operator= ( Event const & )

private

ChainEvent const* fwlite::MultiChainEvent::primary ( ) const

inline

Definition at line 132 of file MultiChainEvent.h.

132 { return &*event1_;}

fwlite::MultiChainEvent::event1_

std::shared_ptr< ChainEvent > event1_

Definition: MultiChainEvent.h:162

edm::ProcessHistory const & MultiChainEvent::processHistory ( ) const

virtual

Implements edm::EventBase.

Definition at line 354 of file MultiChainEvent.cc.

 {
   return event1_->processHistory();
 }

ChainEvent const* fwlite::MultiChainEvent::secondary ( ) const

inline

Definition at line 133 of file MultiChainEvent.h.

References edm::getThinnedProduct(), crabWrapper::key, relativeConstraints::keys, sysUtil::pid, and findQualityFiles::run.

133 { return &*event2_;}

fwlite::MultiChainEvent::event2_

std::shared_ptr< ChainEvent > event2_

Definition: MultiChainEvent.h:163

virtual Long64_t fwlite::MultiChainEvent::secondaryFileIndex ( ) const

inlinevirtual

Reimplemented from fwlite::EventBase.

Definition at line 122 of file MultiChainEvent.h.

References edm::throwProductNotFoundException(), and edm::triggerResults().

Referenced by python.Events::fileIndicies().

123 { return event2_->eventIndex(); }

fwlite::MultiChainEvent::event2_

std::shared_ptr< ChainEvent > event2_

Definition: MultiChainEvent.h:163

Long64_t MultiChainEvent::size ( void ) const

Definition at line 434 of file MultiChainEvent.cc.

Referenced by ntuple._Collection::__iter__(), and ntuple._Collection::__len__().

 {
   return event1_->size();
 }

void MultiChainEvent::throwProductNotFoundException	(	std::type_info const &	iType,
		char const *	iModule,
		char const *	iInstance,
		char const *	iProcess
	)

static

Definition at line 484 of file MultiChainEvent.cc.

References fwlite::ChainEvent::throwProductNotFoundException().

                                                                 {
   ChainEvent::throwProductNotFoundException(iType,iModule,iInstance,iProcess);
 }

bool MultiChainEvent::to ( Long64_t iIndex )

Go to the event at index iIndex.

Definition at line 210 of file MultiChainEvent.cc.

 {
   return event1_->to(iIndex);
 }

bool MultiChainEvent::to ( edm::EventID id )

Go to event with event id "id".

Definition at line 218 of file MultiChainEvent.cc.

References event(), and findQualityFiles::run.

 {
   return to(id.run(), id.luminosityBlock(), id.event());
 }

bool MultiChainEvent::to	(	edm::RunNumber_t	run,
		edm::EventNumber_t	event
	)

Go to event with given run and event number.

Definition at line 232 of file MultiChainEvent.cc.

References mitigatedMETSequence_cff::U.

 {
    return to(run, 0U, event);
 }

bool MultiChainEvent::to	(	edm::RunNumber_t	run,
		edm::LuminosityBlockNumber_t	lumi,
		edm::EventNumber_t	event
	)

Go to event with given run , lumi (if non-zero), and event number.

Definition at line 225 of file MultiChainEvent.cc.

 {
    return event1_->to(run, lumi, event);
 }

const MultiChainEvent & MultiChainEvent::toBegin ( )

virtual

Implements fwlite::EventBase.

Definition at line 323 of file MultiChainEvent.cc.

References AlCaHLTBitMon_QueryRunRegistry::string, and toBegin().

Referenced by toBegin().

 {
    event1_->toBegin();
    return *this;
 }

bool MultiChainEvent::toSec ( Long64_t iIndex )

private

Go to the event from secondary files at index iIndex.

Go to the event at index iIndex.

Definition at line 240 of file MultiChainEvent.cc.

 {
    return event2_->to(iIndex);
 }

bool MultiChainEvent::toSec ( const edm::EventID & id )

private

Definition at line 247 of file MultiChainEvent.cc.

References Exception, and plotBeamSpotDB::first.

 {
    // First try this file.
    if (event2_->event_->to(id))
    {
       // Found it, return.
       return true;
    }
    // Second, assume that the secondary files are each in run/event
    // order.  So, let's loop over all files and see if we can figure
    // out where the event ought to be.
    for (sec_file_range_index_map::const_iterator mBegin =
             secFileMapSorted_.begin(),
             mEnd = secFileMapSorted_.end(),
             mit = mBegin;
          mit != mEnd;
          ++mit)
    {
       if (id < mit->first.first || id > mit->first.second)
       {
          // We don't expect this event to be in this file, so don't
          // bother checking it right now.
          continue;
       }
       // If we're here, then we have a reasonable belief that this
       // event is in this secondary file.  This part is
       // expensive. switchToFile does memory allocations and opens the
       // files which becomes very time consuming. This should be done
       // as infrequently as possible.
       event2_->switchToFile(mit->second);
       // Is it here?
       if (event2_->to(id))
       {
          // Yes!
          return true;
       }
       // if we assumed that the secondary files were not each in
       // order, but were non-overlapping, we could break here.  But at
       // this point, we might as well keep going.
    } // for loop over files
 
    // if we are still here, then we did not find the id in question,
    // do it the old fashioned way.  This will open up each secondary
    // file and explicitly check to see if the event is there.
    if (event2_->to(id))
    {
       return true;
    }
    // if we're still here, then there really is no matching event in
    // the secondary files.  Throw.
    throw cms::Exception("ProductNotFound") << "Cannot find id "
                                            << id.run() << ", "
                                            << id.event()
                                            << " in secondary list. Exiting."
                                            << std::endl;
    // to make the compiler happy
    return false;
 }

bool MultiChainEvent::toSec	(	edm::RunNumber_t	run,
		edm::LuminosityBlockNumber_t	lumi,
		edm::EventNumber_t	event
	)

private

Go to event with given run, lumi, and event number.

Definition at line 308 of file MultiChainEvent.cc.

 {
   return toSec(edm::EventID(run, lumi, event));
 }

bool MultiChainEvent::toSec	(	edm::RunNumber_t	run,
		edm::EventNumber_t	event
	)

private

Go to event with given run and event number.

Definition at line 316 of file MultiChainEvent.cc.

References mitigatedMETSequence_cff::U.

 {
   return toSec(edm::EventID(run, 0U, event));
 }

edm::TriggerNames const & MultiChainEvent::triggerNames ( edm::TriggerResults const & triggerResults ) const

virtual

Implements edm::EventBase.

Definition at line 440 of file MultiChainEvent.cc.

References Exception, and cscdqm::h::names.

 {
   edm::TriggerNames const* names = triggerNames_(triggerResults);
   if (names != nullptr) return *names;
 
   event1_->fillParameterSetRegistry();
   names = triggerNames_(triggerResults);
   if (names != nullptr) return *names;
 
   // If we cannot find it in the primary file, this probably will
   // not help but try anyway
   event2_->to(event1_->id());
   event2_->fillParameterSetRegistry();
   names = triggerNames_(triggerResults);
   if (names != nullptr) return *names;
 
   throw cms::Exception("TriggerNamesNotFound")
     << "TriggerNames not found in ParameterSet registry";
   return *names;
 }

edm::TriggerResultsByName MultiChainEvent::triggerResultsByName ( edm::TriggerResults const & triggerResults ) const

virtual

Implements edm::EventBase.

Definition at line 462 of file MultiChainEvent.cc.

References cscdqm::h::names.

                                                                                    {
 
   edm::TriggerNames const* names = triggerNames_(triggerResults);
 
   if (names == nullptr) {
     event1_->fillParameterSetRegistry();
     names = triggerNames_(triggerResults);
   }
 
   if (names == nullptr) {
     event2_->to(event1_->id());
     event2_->fillParameterSetRegistry();
     names = triggerNames_(triggerResults);
   }
 
   return edm::TriggerResultsByName(&triggerResults, names);
 }

Member Data Documentation

std::shared_ptr<ChainEvent> fwlite::MultiChainEvent::event1_

private

Definition at line 162 of file MultiChainEvent.h.

std::shared_ptr<ChainEvent> fwlite::MultiChainEvent::event2_

private

Definition at line 163 of file MultiChainEvent.h.

std::shared_ptr<internal::MultiProductGetter const> fwlite::MultiChainEvent::getter_

private

Definition at line 164 of file MultiChainEvent.h.

sec_file_range_index_map fwlite::MultiChainEvent::secFileMapSorted_

private

Definition at line 171 of file MultiChainEvent.h.

bool fwlite::MultiChainEvent::useSecFileMapSorted_

private

Definition at line 170 of file MultiChainEvent.h.

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation