Inheritance diagram for art::ProvenanceCheckerOutput:

Classes
struct	Config

Public Types
using	Parameters = fhicl::WrappedTable< Config, OutputModule::Config::KeysToIgnore >

Public Types inherited from art::OutputModule
using	ModuleType = OutputModule

using	WorkerType = OutputWorker

using	PluginCollection_t = std::vector< std::unique_ptr< FileCatalogMetadataPlugin >>

Public Member Functions
	ProvenanceCheckerOutput (Parameters const &)

Public Member Functions inherited from art::OutputModule
virtual	~OutputModule () noexcept

	OutputModule (fhicl::ParameterSet const &pset)

	OutputModule (fhicl::TableFragment< Config > const &pset, fhicl::ParameterSet const &containing_pset)

	OutputModule (OutputModule const &)=delete

	OutputModule (OutputModule &&)=delete

OutputModule &	operator= (OutputModule const &)=delete

OutputModule &	operator= (OutputModule &&)=delete

int	maxEvents () const

int	remainingEvents () const

bool	fileIsOpen () const

OutputFileStatus	fileStatus () const

virtual std::string const &	lastClosedFileName () const

SelectionsArray const &	keptProducts () const

bool	selected (BranchDescription const &) const

std::array< bool, NumBranchTypes > const &	hasNewlyDroppedBranch () const

void	selectProducts (ProductTables const &)

void	doSelectProducts (ProductTables const &)

void	registerProducts (ProductDescriptions &, ModuleDescription const &)

BranchChildren const &	branchChildren () const

Public Member Functions inherited from art::Observer
	~Observer () noexcept

	Observer (Observer const &)=delete

	Observer (Observer &&)=delete

Observer &	operator= (Observer const &)=delete

Observer &	operator= (Observer &&)=delete

void	registerProducts (ProductDescriptions &, ModuleDescription const &)

void	fillDescriptions (ModuleDescription const &)

fhicl::ParameterSetID	selectorConfig () const

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Public Member Functions inherited from art::detail::SharedModule
	SharedModule ()

	SharedModule (std::string const &moduleLabel)

hep::concurrency::SerialTaskQueueChain *	serialTaskQueueChain () const

std::set< std::string > const &	sharedResources () const

void	createQueues (SharedResources const &resources)

template<BranchType , typename... T>
void	serialize (T const &...resources)

template<BranchType , typename... T>
void	serializeExternal (T const &...resources)

Private Member Functions
void	write (EventPrincipal &e) override

void	writeSubRun (SubRunPrincipal &) override

void	writeRun (RunPrincipal &) override

Additional Inherited Members
Protected Member Functions inherited from art::OutputModule
virtual void	doRegisterProducts (ProductDescriptions &, ModuleDescription const &)

Protected Member Functions inherited from art::Observer
std::string const &	processName () const

bool	wantAllEvents () const noexcept

bool	wantEvent (ScheduleID id, Event const &e) const

Handle< TriggerResults >	getTriggerResults (Event const &e) const

	Observer (fhicl::ParameterSet const &config)

	Observer (std::vector< std::string > const &select_paths, std::vector< std::string > const &reject_paths, fhicl::ParameterSet const &config)

Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Protected Member Functions inherited from art::detail::SharedModule
template<BranchType BT = InEvent, typename... T>
void	serialize (T const &...)

template<BranchType BT = InEvent, typename... T>
void	serializeExternal (T const &...)

template<BranchType BT = InEvent>
void	async ()

Detailed Description

Definition at line 20 of file ProvenanceCheckerOutput_module.cc.

Member Typedef Documentation

using art::ProvenanceCheckerOutput::Parameters = fhicl::WrappedTable<Config, OutputModule::Config::KeysToIgnore>

Definition at line 27 of file ProvenanceCheckerOutput_module.cc.

Constructor & Destructor Documentation

art::ProvenanceCheckerOutput::ProvenanceCheckerOutput ( ProvenanceCheckerOutput::Parameters const & ps )

explicit

Definition at line 43 of file ProvenanceCheckerOutput_module.cc.

45 : OutputModule{ps().omConfig, ps.get_PSet()}

46 {}

genie::units::ps

static constexpr double ps

Definition: Units.h:99

art::OutputModule::OutputModule

OutputModule(fhicl::ParameterSet const &pset)

Definition: OutputModule.cc:73

Member Function Documentation

void art::ProvenanceCheckerOutput::write ( EventPrincipal & e )

overrideprivatevirtual

Implements art::OutputModule.

Definition at line 75 of file ProvenanceCheckerOutput_module.cc.

   {
     // Check ProductProvenance's parents to see if they are in the
     // ProductProvenance list
 
     std::map<ProductID, bool> seenParentInPrincipal;
     std::set<ProductID> missingFromMapper;
     std::set<ProductID> missingProductProvenance;
 
     for (auto const& group : e) {
       auto const pid = group.first;
       auto const& pd = group.second;
       if (pd && pd->productAvailable()) {
         e.getForOutput(pid, false);
         if (not pd->productProvenance().get()) {
           missingProductProvenance.insert(pid);
           continue;
         }
         auto pInfo = e.branchToProductProvenance(pid);
         if (!pInfo) {
           missingFromMapper.insert(pid);
         }
         markAncestors(*(pd->productProvenance()),
                       e,
                       seenParentInPrincipal,
                       missingFromMapper);
       }
       seenParentInPrincipal[pid] = true;
     }
 
     // Determine what ProductIDs are missing from the principal,
     // vs. which ProductIDs are not even accessible to the principal
     // via the product tables.
     std::set<ProductID> missingFromPrincipal;
     std::set<ProductID> missingFromTables;
     for (auto const& seenParent : seenParentInPrincipal) {
       if (!seenParent.second) {
         missingFromPrincipal.insert(seenParent.first);
       }
       ProductID const pid{seenParent.first};
       auto found = e.getProductDescription(pid);
       if (found == nullptr) {
         missingFromTables.insert(pid);
       }
     }
 
     auto logProductID = [](auto const& missing) {
       mf::LogProblem("ProvenanceChecker") << missing;
     };
 
     if (missingFromMapper.size()) {
       mf::LogError("ProvenanceChecker")
         << "Missing the following ProductIDs from BranchMapper\n";
       cet::for_all(missingFromMapper, logProductID);
     }
 
     if (missingFromPrincipal.size()) {
       mf::LogError("ProvenanceChecker")
         << "Missing the following ProductIDs from EventPrincipal\n";
       cet::for_all(missingFromPrincipal, logProductID);
     }
 
     if (missingProductProvenance.size()) {
       mf::LogError("ProvenanceChecker") << "The Groups for the following "
                                            "ProductIDs have no "
                                            "ProductProvenance\n";
       cet::for_all(missingProductProvenance, logProductID);
     }
 
     if (missingFromTables.size()) {
       mf::LogError("ProvenanceChecker") << "Missing the following ProductIDs "
                                            "from the principal's product "
                                            "tables\n";
       cet::for_all(missingFromTables, logProductID);
     }
 
     if (missingFromMapper.size() or missingFromPrincipal.size() or
         missingProductProvenance.size() or missingFromTables.size()) {
       throw cet::exception("ProvenanceError")
         << (missingFromMapper.size() or missingFromPrincipal.size() ?
               "Having missing ancestors" :
               "")
         << (missingFromMapper.size() ? " from BranchMapper" : "")
         << (missingFromMapper.size() and missingFromPrincipal.size() ? " and" :
                                                                        "")
         << (missingFromPrincipal.size() ? " from EventPrincipal" : "")
         << (missingFromMapper.size() or missingFromPrincipal.size() ? ".\n" :
                                                                       "")
         << (missingProductProvenance.size() ? " Have missing "
                                               "ProductProvenance's from Group "
                                               "in EventPrincipal.\n" :
                                               "")
         << (missingFromTables.size() ?
               " Have missing info from the principal's product tables.\n" :
               "");
     }
   }