Service to store calibration data products (CDP) in the SQLite3 metadatabase of a file. More...

Namespaces
	actions

	detail

	errors

	evtSel

	ExceptionDetail

	fp_detail

	friendlyname

	gfactory

	hlt

	input

	productstatus

	PtrRemapperDetail

	root

	rootNames

	stats

	test

Classes
class	ActionTable

class	ActivityRegistry

class	AndHelper

class	Assns

class	Assns< L, R, void >

class	AssnsGroup

class	AssnsGroupWithData

struct	AssnsNode

class	BasicOptionsHandler

class	BasicOutputOptionsHandler

class	BasicPostProcessor

class	BasicSourceOptionsHandler

class	BeginEndPackage

class	BeginEndPackage< Level::Run >

class	BeginEndPackage< Level::SubRun >

class	BlockingPrescaler

class	BoolCache

class	BranchChildren

class	BranchDescription

class	BranchID

struct	BranchKey

class	BranchMapper

class	BranchMapperWithReader

struct	CannotFillView

class	CatalogInterface

class	ClosedRangeSetHandler

class	ClosingCriteria

class	Compare_Run_SubRun_EventEntry

class	ComparePtrs

class	ComposedSelectorWrapper

class	const_AssnsIter

class	ConstPtrCache

class	Consumer

class	CurrentModule

class	CurrentProcessingContext

class	DatabaseConnection

class	DataFlow

class	DataViewImpl

class	debugging_allocator

class	DebugOptionsHandler

struct	debugvalue

class	DecrepitRelicInputSourceImplementation

struct	Defaults

class	DeferredProductGetter

class	DelayedReader

struct	DoMakePartner

struct	DoNotMakePartner

struct	DoNotSetPtr

struct	DoSetPtr

class	DropMetaData

class	DuplicateChecker

class	EDAnalyzer

class	EDFilter

class	EDProducer

class	EDProduct

class	EDProductGetter

class	EDProductGetterFinder

class	EmptyEvent

class	EmptyEventTimestampPlugin

struct	enable_if_function_exists_t< void(T::)(std::vector< void const > &), &T::fillView >

class	EndPathExecutor

class	EngineCreator

class	Event

class	EventAuxiliary

class	EventID

class	EventIDFilter

class	EventIDMatcher

class	EventObserverBase

class	EventPrincipal

struct	EventProcessHistoryID

class	EventProcessor

class	EventRange

class	EventSelector

struct	EventSummary

class	ExecutionCounts

class	FastCloningInfoProvider

class	FileBlock

class	FileCatalog

class	FileCatalogItem

class	FileCatalogMetadata

class	FileCatalogMetadataPlugin

class	FileCatalogOptionsHandler

class	FileDumperOutput

struct	FileFormatVersion

class	FileIndex

class	FileProperties

class	FileStatsCollector

class	FileTransfer

class	FindMany

class	FindMany< ProdB, void >

class	FindManyP

class	FindManyP< ProdB, void >

class	FindOne

class	FindOne< ProdB, void >

class	FindOneP

class	FindOneP< ProdB, void >

class	FloatingPointControl

struct	FragmentSemantic

struct	FullSemantic

class	GlobalSignal

class	GlobalSignal< SRTYPE, ResultType(Args...)>

class	Granularity

class	Group

class	GroupQueryResult

class	GroupSelector

class	GroupSelectorRules

class	Handle

struct	has_fillView

struct	has_mapped_type

struct	has_mapped_type< T, cet::enable_if_type_exists_t< typename T::mapped_type > >

struct	has_setPtr

struct	has_setPtr< cet::map_vector< T > >

struct	has_setPtr< std::deque< T, A > >

struct	has_setPtr< std::list< T, A > >

struct	has_setPtr< std::set< T, A > >

struct	has_setPtr< std::vector< bool, A > >

struct	has_setPtr< std::vector< T, A > >

struct	has_value_type

struct	has_value_type< T, cet::enable_if_type_exists_t< typename T::value_type > >

class	Hash

class	History

class	HLTGlobalStatus

class	HLTPathStatus

struct	IDNumber

struct	IDNumber< Level::Event >

struct	IDNumber< Level::Run >

struct	IDNumber< Level::SubRun >

class	InputFileCatalog

class	InputSource

struct	InputSourceDescription

class	InputSourceFactory

class	InputTag

struct	key_traits

struct	key_traits< std::pair< U, V > >

struct	key_traits< std::string >

struct	LinuxProcData

class	LinuxProcMgr

class	LocalSignal

class	LocalSignal< STYPE, ResultType(Args...)>

class	MallocOptionSetter

struct	MallocOpts

class	MasterProductRegistry

class	MatchAllSelector

struct	MaybeFillView

struct	MaybeFillView< cet::map_vector< T > >

struct	MaybeFillView< std::deque< T, A > >

struct	MaybeFillView< std::list< T, A > >

struct	MaybeFillView< std::set< T, A > >

struct	MaybeFillView< std::vector< bool, A > >

struct	MaybeFillView< std::vector< T, A > >

struct	MaybeFillView< T, std::enable_if_t< has_fillView< T >::value > >

class	MaybeIncrementCounts

class	MaybeIncrementCounts< Level::Event, T >

class	MemoryAdjuster

class	MemoryTracker

class	MFStatusUpdater

struct	MinimalToolConfig

class	MixFilter

class	MixHelper

class	MixOp

class	MixOpBase

class	ModuleDescription

struct	ModuleInPathSummary

class	ModuleLabelSelector

struct	NewToOld

class	NoDelayedReader

class	NotHelper

struct	OldToNew

class	OpenRangeSetHandler

class	OptionsHandler

class	OrHelper

class	OutputFileInfo

class	OutputHandle

class	OutputModule

struct	OutputModuleDescription

class	OutputWorker

struct	ParameterSetBlob

class	Parentage

class	Path

class	PathManager

class	PathsInfo

struct	PathSummary

class	PostCloseFileRenamer

class	Prescaler

struct	prevent_recursion

struct	prevent_recursion< Sampled< T > >

class	Principal

struct	ProcessConfiguration

class	ProcessHistory

class	ProcessingOptionsHandler

class	ProcessNameSelector

class	ProcessPackage

class	ProdToProdMapBuilder

class	ProducerBase

class	ProducerTable

class	ProducingService

class	ProducingServiceSignals

class	ProductID

class	ProductInfo

class	ProductInstanceNameSelector

class	ProductMetaData

class	ProductProvenance

struct	ProductRegistry

class	ProductRegistryHelper

struct	productSize

struct	productSize< cet::map_vector< E >, false >

struct	productSize< PtrVector< E >, false >

struct	productSize< std::deque< E >, false >

struct	productSize< std::list< E >, false >

struct	productSize< std::set< E >, false >

struct	productSize< std::vector< E >, false >

struct	productSize< T, false >

struct	productSize< T, true >

struct	ProductTable

class	ProductTables

class	ProductToken

class	Provenance

class	ProvenanceCheckerOutput

class	ProvenanceDumper

class	ProvenanceDumper< DETAIL, cet::enable_if_type_exists_t< typename DETAIL::Config > >

struct	ProvenanceDumperConfig

struct	ProvenanceDumperConfig< DETAIL, cet::enable_if_type_exists_t< typename DETAIL::Config > >

class	Ptr

class	PtrMaker

class	PtrRemapper

class	PtrVector

class	PtrVectorBase

class	RandomNumberGenerator

class	RandomNumberSaver

struct	RangedFragmentSemantic

class	RangeSet

class	RangeSetHandler

class	RefCore

class	Results

class	ResultsAuxiliary

class	ResultsPrincipal

class	ResultsProducer

class	RNGsnapshot

class	RootBranchInfo

class	RootBranchInfoList

class	RootDelayedReader

class	RootFileBlock

class	RootHandlers

class	RootInput

class	RootInputFile

class	RootInputFileSequence

class	RootInputTree

class	RootOutput

class	RootOutputFile

class	RootOutputTree

class	RootSizeOnDisk

class	RPManager

struct	RPParams

class	RPWorker

class	RPWorkerT

class	Run

class	RunAuxiliary

class	RunID

class	RunPrincipal

class	Sampled

struct	SampledEventInfo

struct	SampledInfo

class	SamplingInput

class	Schedule

class	ScheduleContext

class	ScheduleID

class	Selector

class	SelectorBase

class	ServiceDirector

class	ServiceHandle

class	ServiceHandle< T, art::ServiceScope::PER_SCHEDULE >

class	ServiceRegistry

class	ServicesManager

class	ServiceTable

class	ServiceToken

class	SortInvalidFirst

class	Source

struct	Source_generator

struct	Source_wantFileServices

struct	Source_wantFileServices< daq2raw::NOvASocketInputDriver >

class	SourceHelper

class	SQLErrMsg

class	SQLite3Wrapper

class	SubRun

class	SubRunAuxiliary

class	SubRunID

class	SubRunPrincipal

class	Suffixes

class	SummedValue

struct	SupportsView

struct	SupportsView< T, std::enable_if_t< has_mapped_type< T >::value > >

class	TFileDirectory

class	TFileService

class	thread_safe_registry_via_id

class	Timestamp

class	TimeTracker

class	TKeyVFSOpenPolicy

class	ToolConfigTable

class	Tracer

class	Transient

class	TriggerNamesService

struct	TriggerReport

class	TriggerResultInserter

class	TriggerResults

class	TrivialFileDelivery

class	TrivialFileTransfer

class	TypeID

class	TypeLabel

class	ValidHandle

struct	value

class	View

class	ViewToken

class	Worker

class	WorkerInPath

struct	WorkerParams

struct	WorkerSummary

class	WorkerT

struct	WrappedTypeID

class	Wrapper

Typedefs
using	OptionsHandlers = std::vector< std::unique_ptr< art::OptionsHandler >>

using	PathPtrs = std::vector< std::unique_ptr< Path >>

using	WorkerMap = std::map< std::string, std::unique_ptr< Worker >>

template<typename PROD , typename OPROD = PROD>
using	MixFunc = std::function< bool(std::vector< PROD const * > const &, OPROD &, PtrRemapper const &)>

using	EventIDIndex = std::map< FileIndex::EntryNumber_t, EventID >

using	SubRunIDIndex = std::map< SubRunID, FileIndex::EntryNumber_t >

using	RunIDIndex = std::map< SubRunID, FileIndex::EntryNumber_t >

using	EventIDSequence = std::vector< EventID >

using	EntryNumberSequence = std::vector< FileIndex::EntryNumber_t >

using	EventAuxiliarySequence = std::vector< EventAuxiliary >

using	DataFlowDumper = ProvenanceDumper< DataFlow >

using	CountingStatistics = ExecutionCounts< stats::Visited, stats::Run, stats::Passed, stats::Failed, stats::ExceptionThrown >

template<Level L>
using	Do = ProcessPackage< L >

template<Level L>
using	Begin = typename BeginEndPackage< L >::Begin

template<Level L>
using	End = typename BeginEndPackage< L >::End

using	ConsumableProductVectorPerBranch = std::vector< ProductInfo >

using	ConsumableProductSetPerBranch = std::set< ProductInfo >

using	ConsumableProducts = std::array< ConsumableProductVectorPerBranch, NumBranchTypes >

using	ConsumableProductSets = std::array< ConsumableProductSetPerBranch, NumBranchTypes >

using	ProductListUpdatedCallback = std::function< void(ProductList const &)>

using	ProcessConfigurationRegistry = thread_safe_registry_via_id< ProcessConfigurationID, ProcessConfiguration >

using	ProcessConfigurationMap = ProcessConfigurationRegistry::collection_type

using	ProcessHistoryRegistry = thread_safe_registry_via_id< ProcessHistoryID, ProcessHistory >

using	Selections = std::vector< BranchDescription const * >

using	SelectionsArray = std::array< Selections, NumBranchTypes >

template<typename T >
using	tool_return_type = typename detail::tool_type< T >::return_type

using	new_t = std::string

using	old_t = std::string

using	CFUNC = void()(int, siginfo_t , void *)

using	ProductDescriptions = std::vector< BranchDescription >

typedef unsigned short	BranchListIndex

typedef std::vector< BranchListIndex >	BranchListIndexes

typedef fhicl::ParameterSetID	EventSelectionID

typedef std::vector< EventSelectionID >	EventSelectionIDVector

template<Level L>
using	IDNumber_t = typename IDNumber< L >::type

using	EventNumber_t = IDNumber_t< Level::Event >

using	SubRunNumber_t = IDNumber_t< Level::SubRun >

using	RunNumber_t = IDNumber_t< Level::Run >

typedef unsigned int	ModuleDescriptionID

typedef std::map< fhicl::ParameterSetID, ParameterSetBlob >	ParameterSetMap

typedef Hash< ParentageType >	ParentageID

typedef thread_safe_registry_via_id< ParentageID, Parentage >	ParentageRegistry

using	ProcessConfigurations = std::vector< ProcessConfiguration >

typedef Hash< ProcessConfigurationType >	ProcessConfigurationID

typedef std::map< ProcessHistoryID const, ProcessHistory >	ProcessHistoryMap

typedef Hash< ProcessHistoryType >	ProcessHistoryID

typedef std::map< BranchKey, BranchDescription >	ProductList

using	ProductProvenances = std::vector< ProductProvenance >

using	ProductStatus = unsigned char

typedef std::string	ReleaseVersion

using	SampledRunInfo = std::map< std::string, SampledInfo< RunID >>

using	SampledSubRunInfo = std::map< std::string, SampledInfo< SubRunID >>

using	TimeValue_t = std::uint64_t

using	ProcessLookup = std::map< std::string, std::vector< ProductID >>

using	ViewLookup_t = ProcessLookup

using	ProductLookup_t = std::map< std::string, ProcessLookup >

using	AvailableProducts_t = std::unordered_set< ProductID, ProductID::Hash >

using	Exception = cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate >

Enumerations
enum	ModuleType { ModuleType::NON_ART, ModuleType::ANALYZER, ModuleType::FILTER, ModuleType::PRODUCER, ModuleType::OUTPUT }

enum	OutputFileStatus { OutputFileStatus::Open, OutputFileStatus::Switching, OutputFileStatus::Closed }

enum	FileCatalogStatus { FileCatalogStatus::SUCCESS, FileCatalogStatus::NO_MORE_FILES, FileCatalogStatus::DELIVERY_ERROR, FileCatalogStatus::TRANSFER_ERROR }

enum	BranchActionType { BranchActionBegin = 0, BranchActionEnd, BranchActionProcess }

enum	FileDisposition { FileDisposition::PENDING = -1, FileDisposition::TRANSFERRED, FileDisposition::CONSUMED, FileDisposition::SKIPPED, FileDisposition::INCOMPLETE }

enum	ServiceScope { ServiceScope::LEGACY, ServiceScope::GLOBAL, ServiceScope::PER_SCHEDULE }

enum	suffix_type { suffix_type::module, suffix_type::plugin, suffix_type::service, suffix_type::source, suffix_type::tool, suffix_type::mfPlugin, suffix_type::mfStatsPlugin }

enum	Verbosity { Silent = 0, Concise = 2, Normal = 5, Detailed = 10 }

enum	Direction : int { Direction::Forward = 1, Direction::Reverse = -1 }

enum	BranchType { InEvent, InSubRun, InRun, InResults, NumBranchTypes }

enum	HashedTypes { ModuleDescriptionType, ParameterSetType, ProcessHistoryType, ProcessConfigurationType, EntryDescriptionType, ParentageType }

enum	Persistable { Persistable::Yes, Persistable::No }

enum	Level { Level::Job = 0, Level::InputFile, Level::Run, Level::SubRun, Level::Event, Level::NumNestingLevels, Level::ReadyToAdvance }

Functions
bool	find_config (std::string const &filename, std::string const &search_path_spec, std::string &full_path)

template<typename T , typename... Args>
void	add_opt (T &t, Args &&...args)

int	run_art (int argc, char **argv, bpo::options_description &all_desc, cet::filepath_maker &lookupPolicy, art::OptionsHandlers &&handlers)

int	run_art_string_config (std::string const &config_string)

int	run_art_common_ (fhicl::ParameterSet const &main_pset)

template<typename T >
std::ostream &	operator<< (std::ostream &os, EDAnalyzer::Table< T > const &t)

std::ostream &	operator<< (std::ostream &os, const GroupSelector &gs)

std::string	to_string (ModuleType mt)

bool	is_observer (ModuleType mt)

bool	is_modifier (ModuleType mt)

std::ostream &	operator<< (std::ostream &os, Granularity const &b)

std::ostream &	operator<< (std::ostream &os, OutputFileStatus const ofs)

template<typename T >
std::ostream &	operator<< (std::ostream &os, ProducerBase::Table< T > const &t)

template<typename UserConfig , typename ImplicitConfig >
std::ostream &	operator<< (std::ostream &os, ProducerTable< UserConfig, ImplicitConfig > const &t)

std::ostream &	operator<< (std::ostream &os, FileProperties const &fp)

std::ostream &	operator<< (std::ostream &os, MixHelper::Mode)

void	checkDictionaries (BranchDescription const &productDesc)

std::string const &	getFileFormatEra ()

int	getFileFormatVersion ()

void	unloadRootSigHandler ()

void	setRootErrorHandler (bool want_custom)

void	completeRootHandlers ()

bool	have_table (sqlite3 *db, std::string const &table, std::string const &filename)

std::string	couldNotFindTree (std::string const &treename)

bool	greaterBySize (RootSizeOnDisk::Record const &lhs, RootSizeOnDisk::Record const &rhs)

template<typename T , typename P >
std::enable_if_t< P::branch_type==InEvent\|\|P::branch_type==InResults >	put_product_in_principal (std::unique_ptr< T > &&product, P &principal, std::string const &module_label, std::string const &instance_name={})

template<typename T , typename P >
std::enable_if_t< P::branch_type==InSubRun\|\|P::branch_type==InRun >	put_product_in_principal (std::unique_ptr< T > &&product, P &principal, std::string const &module_label, std::string const &instance_name={}, RangeSet &&=RangeSet::invalid())

RangeSet	rangeSetFor (RunPrincipal const &rp)

RangeSet	rangeSetFor (SubRunPrincipal const &srp)

static void	markAncestors (ProductProvenance const &iInfo, BranchMapper const &iMapper, std::map< ProductID, bool > &oMap, std::set< ProductID > &oMapperMissing)

template<typename PROD >
std::ostream &	operator<< (std::ostream &os, Handle< PROD > const &h)

template<typename T >
BranchDescription const &	get_ProductDescription (BranchType branch_type, std::string const &module_label, std::string const &instance_name)

template<typename T >
BranchDescription const &	get_ProductDescription (Principal const &principal, std::string const &module_label, std::string const &instance_name)

BranchDescription const &	get_ProductDescription (TypeID type_id, BranchType branch_type, std::string const &module_label, std::string const &instance_name)

BranchDescription const &	get_ProductDescription (TypeID type_id, Principal const &principal, std::string const &module_label, std::string const &instance_name)

BranchDescription const &	get_ProductDescription (TypeID tid, std::string const &process_name, ProductList const &product_list, BranchType branch_type, std::string const &module_label, std::string const &instance_name)

std::ostream &	operator<< (std::ostream &os, Group const &g)

template<class T >
void	swap (Handle< T > &a, Handle< T > &b)

template<class T >
void	swap (ValidHandle< T > &a, ValidHandle< T > &b)

template<class T >
void	convert_handle (GroupQueryResult const &, Handle< T > &)

template<class T >
std::enable_if_t< detail::is_handle< T >::value, RangeSet const & >	range_of_validity (T const &h)

template<class T , class U >
std::enable_if_t< detail::are_handles< T, U >::value, bool >	same_ranges (T const &a, U const &b)

template<class T , class U >
std::enable_if_t< detail::are_handles< T, U >::value, bool >	disjoint_ranges (T const &a, U const &b)

template<class T , class U >
std::enable_if_t< detail::are_handles< T, U >::value, bool >	overlapping_ranges (T const &a, U const &b)

void	swap (OutputHandle &a, OutputHandle &b)

bool	operator< (ProductInfo const &a, ProductInfo const &b)

std::ostream &	operator<< (std::ostream &, Provenance const &)

bool	operator== (Provenance const &a, Provenance const &b)

void	swap (Provenance &x, Provenance &y)

template<class A , class B >
std::enable_if_t< std::is_base_of< art::SelectorBase, A >::value &&std::is_base_of< art::SelectorBase, B >::value, art::AndHelper< A, B > >	operator&& (A const &a, B const &b)

template<class A , class B >
std::enable_if_t< std::is_base_of< art::SelectorBase, A >::value &&std::is_base_of< art::SelectorBase, B >::value, art::OrHelper< A, B > >	operator\|\| (A const &a, B const &b)

template<class A >
std::enable_if_t< std::is_base_of< art::SelectorBase, A >::value, art::NotHelper< A > >	operator! (A const &a)

template<class T , class U >
bool	same_ranges (SummedValue< T > const &a, SummedValue< U > const &b)

template<class T , class U >
bool	disjoint_ranges (SummedValue< T > const &a, SummedValue< U > const &b)

template<class T , class U >
bool	overlapping_ranges (SummedValue< T > const &a, SummedValue< U > const &b)

std::string	translateFileDeliveryStatus (FileDeliveryStatus stat)

std::string	translateFileDisposition (FileDisposition fd)

std::string	translateFileTransferStatus (FileTransferStatus stat)

template<typename T >
std::ostream &	operator<< (std::ostream &os, ServiceTable< T > const &t)

template<typename CONTAINER >
std::enable_if_t< detail::has_two_arg_insert< CONTAINER >::value >	concatContainers (CONTAINER &out, CONTAINER const &in)

template<typename CONTAINER >
std::enable_if_t< detail::has_three_arg_insert< CONTAINER >::value >	concatContainers (CONTAINER &out, CONTAINER const &in)

template<typename COLLECTION >
void	flattenCollections (std::vector< COLLECTION const * > const &in, COLLECTION &out)

template<typename COLLECTION , typename OFFSETS >
void	flattenCollections (std::vector< COLLECTION const * > const &in, COLLECTION &out, OFFSETS &offsets)

template<typename T >
void	flattenCollections (std::vector< PtrVector< T > const * > const &in, PtrVector< T > &out)

template<typename T , typename OFFSETS >
void	flattenCollections (std::vector< PtrVector< T > const * > const &in, PtrVector< T > &out, OFFSETS &offsets)

template<class X , class Y >
bool	operator== (debugging_allocator< X > const &, debugging_allocator< Y > const &) throw ()

template<class X , class Y >
bool	operator!= (debugging_allocator< X > const &, debugging_allocator< Y > const &) throw ()

bool	operator< (EventProcessHistoryID const &lh, EventProcessHistoryID const &rh)

std::ostream &	operator<< (std::ostream &os, MasterProductRegistry const &mpr)

std::ostream &	operator<< (std::ostream &os, ProductMetaData const &pmd)

void	ensureTable (fhicl::intermediate_table &table, std::string const &fhicl_spec)

void	printArtException (cet::exception const &e, char const *prog=0)

void	printBadAllocException (char const *prog=0)

void	printStdException (std::exception const &e, char const *prog=0)

void	printUnknownException (char const *prog=0)

template<typename T >
std::enable_if_t< std::is_class< T >::value, tool_return_type< T > >	make_tool (fhicl::ParameterSet const &pset)

template<typename T >
std::enable_if_t< std::is_function< T >::value, tool_return_type< T > >	make_tool (fhicl::ParameterSet const &pset, std::string const &function_tool_type)

template<typename T , typename TableConfig >
std::enable_if_t< std::is_class< T >::value, tool_return_type< T > >	make_tool (TableConfig const &tc)

template<typename T , typename TableConfig >
std::enable_if_t< std::is_function< T >::value, tool_return_type< T > >	make_tool (TableConfig const &tc, std::string const &function_tool_type)

std::ostream &	operator<< (std::ostream &ost, const MallocOpts &)

MallocOptionSetter &	getGlobalOptionSetter ()

std::string	parent_path (std::string const &path)

std::ostream &	operator<< (std::ostream &os, suffix_type const st)

template<typename T1 , typename T2 >
std::enable_if_t< std::is_same< T1, T2 >::value\|\|std::is_base_of< T1, T2 >::value\|\|std::is_base_of< T2, T1 >::value, bool >	pointersEqual (T1 t1, T2 t2)

template<typename T1 , typename T2 >
std::enable_if_t<!std::is_same< T1, T2 >::value &&!std::is_base_of< T1, T2 >::value &&!std::is_base_of< T2, T1 >::value, bool >	pointersEqual (T1 , T2 )

constexpr auto	fullRun ()

constexpr auto	fullSubRun ()

constexpr auto	runFragment ()

constexpr auto	subRunFragment ()

auto	runFragment (RangeSet const &rs)

auto	subRunFragment (RangeSet const &rs)

bool	is_glob (std::string const &pattern)

std::string	glob2reg (std::string pattern)

std::vector< std::vector< std::string >::const_iterator >	regexMatch (std::vector< std::string > const &strings, std::regex const &regexp)

std::vector< std::vector< std::string >::const_iterator >	regexMatch (std::vector< std::string > const &strings, std::string const &pattern)

std::map< new_t, old_t >	newToOldName ()

std::map< new_t, old_t >	oldToNewName ()

bool	operator!= (ScheduleID left, ScheduleID right)

bool	operator<= (ScheduleID left, ScheduleID right)

bool	operator> (ScheduleID left, ScheduleID right)

bool	operator>= (ScheduleID left, ScheduleID right)

std::string	unique_filename (std::string stem, std::string extension=".root")

void	ep_sigusr2 (int, siginfo_t , void )

int	getSigNum ()

void	disableAllSigs (sigset_t *oldset)

void	disableRTSigs ()

void	enableSignal (sigset_t *newset, int signum)

void	disableSignal (sigset_t *newset, int signum)

void	reenableSigs (sigset_t *oldset)

void	installSig (int signum, CFUNC func)

void	installCustomHandler (int signum, CFUNC func)

void	sigInventory ()

void	setupSignals (bool want_sigint_enabled)

std::string const &	getReleaseVersion ()

template<typename A , typename B , typename D , typename F >
void	for_each_group (art::Assns< A, B, D > const &assns, F func)
	Helper functions to access associations in order. More...

template<typename A , typename B , typename D , typename F >
void	for_each_group_with_left (art::Assns< A, B, D > const &assns, F func)

template<typename A , typename B , typename D , typename F >
void	for_each_pair (art::Assns< A, B, D > const &assns, F func)

template<Direction Dir>
constexpr int	signed_one ()

template<Direction Dir>
constexpr auto	index_for_dereferencing (std::size_t const i)

template<class L , class R , class D , Direction Dir>
constexpr auto const &	left (const_AssnsIter< L, R, D, Dir > const &a, const_AssnsIter< L, R, D, Dir > const &b)

template<class L , class R , class D , Direction Dir>
constexpr auto const &	right (const_AssnsIter< L, R, D, Dir > const &a, const_AssnsIter< L, R, D, Dir > const &b)

template<class COLLECTION >
void	getElementAddresses (COLLECTION const &coll, const std::type_info &iToType, const std::vector< unsigned long > &iIndices, std::vector< void const * > &oPtr)

template<typename T >
void	getElementAddresses (cet::map_vector< T > const &obj, const std::type_info &iToType, const std::vector< unsigned long > &iIndices, std::vector< void const * > &oPtr)

void	swap (HLTGlobalStatus &lhs, HLTGlobalStatus &rhs)

std::ostream &	operator<< (std::ostream &ost, HLTGlobalStatus const &hlt)

template<typename T , typename U >
std::enable_if_t< std::is_same< T, U >::value\|\|std::is_base_of< T, U >::value\|\|std::is_base_of< U, T >::value, bool >	operator== (Ptr< T > const &lhs, Ptr< U > const &rhs)

template<typename T , typename U >
std::enable_if_t< std::is_same< T, U >::value\|\|std::is_base_of< T, U >::value\|\|std::is_base_of< U, T >::value, bool >	operator!= (Ptr< T > const &lhs, Ptr< U > const &rhs)

template<typename T , typename U >
std::enable_if_t< std::is_same< T, U >::value\|\|std::is_base_of< T, U >::value\|\|std::is_base_of< U, T >::value, bool >	operator< (Ptr< T > const &lhs, Ptr< U > const &rhs)

template<typename T , typename H >
void	fill_ptr_vector (std::vector< Ptr< T >> &ptrs, H const &h)

template<typename T , typename H >
void	fill_ptr_list (std::list< Ptr< T >> &ptrs, H const &h)

template<typename T >
std::ostream &	operator<< (std::ostream &, Ptr< T > const &)

template<typename T >
void	swap (PtrVector< T > &, PtrVector< T > &)

bool	operator== (RefCore const &, RefCore const &)

bool	operator!= (RefCore const &, RefCore const &)

bool	operator< (RefCore const &, RefCore const &)

void	swap (art::RefCore &, art::RefCore &)

auto	sampled_from (std::string process_name)

template<class COLLECTION >
void	setPtr (COLLECTION const &coll, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)

template<typename T >
void	setPtr (cet::map_vector< T > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)

void	swap (TriggerResults &lhs, TriggerResults &rhs)

std::ostream &	operator<< (std::ostream &os, BranchDescription const &p)

bool	operator< (BranchDescription const &a, BranchDescription const &b)

bool	operator== (BranchDescription const &a, BranchDescription const &b)

bool	combinable (BranchDescription const &a, BranchDescription const &b)

std::ostream &	operator<< (std::ostream &os, BranchID const &id)

bool	operator< (BranchKey const &a, BranchKey const &b)

bool	operator== (BranchKey const &a, BranchKey const &b)

bool	operator!= (BranchKey const &a, BranchKey const &b)

std::ostream &	operator<< (std::ostream &os, BranchKey const &bk)

std::ostream &	operator<< (std::ostream &, BranchMapper const &)

std::string const &	BranchTypeToString (BranchType)

std::string const &	BranchTypeToProductTreeName (BranchType)

std::string const &	BranchTypeToMetaDataTreeName (BranchType)

std::string const &	BranchTypeToAuxiliaryBranchName (BranchType)

std::string const &	productProvenanceBranchName (BranchType)

std::string const &	BranchTypeToMajorIndexName (BranchType)

std::string const &	BranchTypeToMinorIndexName (BranchType)

std::ostream &	operator<< (std::ostream &os, BranchType const branchType)

std::string	canonicalProductName (std::string const &friendlyClassName, std::string const &moduleLabel, std::string const &productInstanceName, std::string const &processName)

std::ostream &	operator<< (std::ostream &os, EventID const &iID)

std::ostream &	operator<< (std::ostream &os, EventRange const &r)

bool	operator== (FileFormatVersion const &a, FileFormatVersion const &b)

bool	operator!= (FileFormatVersion const &a, FileFormatVersion const &b)

std::ostream &	operator<< (std::ostream &os, FileFormatVersion const &ff)

bool	operator< (FileIndex::Element const &lh, FileIndex::Element const &rh)

bool	operator> (FileIndex::Element const &lh, FileIndex::Element const &rh)

bool	operator>= (FileIndex::Element const &lh, FileIndex::Element const &rh)

bool	operator<= (FileIndex::Element const &lh, FileIndex::Element const &rh)

bool	operator== (FileIndex::Element const &lh, FileIndex::Element const &rh)

bool	operator!= (FileIndex::Element const &lh, FileIndex::Element const &rh)

std::ostream &	operator<< (std::ostream &os, FileIndex::Element const &el)

std::ostream &	operator<< (std::ostream &os, FileIndex const &fileIndex)

template<int I>
void	swap (Hash< I > &a, Hash< I > &b)

template<int I>
std::ostream &	operator<< (std::ostream &os, Hash< I > const &h)

template<Level L = Level::Event>
constexpr bool	is_valid (IDNumber_t< L > const id)

std::ostream &	operator<< (std::ostream &os, ModuleDescription const &p)

std::ostream &	operator<< (std::ostream &os, ParameterSetBlob const &blob)

std::ostream &	operator<< (std::ostream &os, Parentage const &)

bool	operator== (Parentage const &a, Parentage const &b)

bool	operator!= (Parentage const &a, Parentage const &b)

bool	operator< (ProcessConfiguration const &a, ProcessConfiguration const &b)

bool	operator== (ProcessConfiguration const &a, ProcessConfiguration const &b)

bool	operator!= (ProcessConfiguration const &a, ProcessConfiguration const &b)

std::ostream &	operator<< (std::ostream &os, ProcessConfiguration const &pc)

void	swap (art::ProcessHistory &a, art::ProcessHistory &b)

bool	operator== (art::ProcessHistory const &a, art::ProcessHistory const &b)

bool	operator!= (art::ProcessHistory const &a, art::ProcessHistory const &b)

bool	isAncestor (art::ProcessHistory const &a, art::ProcessHistory const &b)

bool	isDescendant (art::ProcessHistory const &a, art::ProcessHistory const &b)

std::ostream &	operator<< (std::ostream &ost, art::ProcessHistory const &ph)

std::ostream &	operator<< (std::ostream &os, ProductID const id)

auto	make_product_descriptions (ProductList const &productList)

bool	operator< (ProductProvenance const &a, ProductProvenance const &b) noexcept

std::ostream &	operator<< (std::ostream &os, ProductProvenance const &p)

bool	operator== (ProductProvenance const &a, ProductProvenance const &b) noexcept

bool	operator!= (ProductProvenance const &a, ProductProvenance const &b) noexcept

bool	operator== (RangeSet const &l, RangeSet const &r)

bool	same_ranges (RangeSet const &l, RangeSet const &r)

bool	disjoint_ranges (RangeSet const &l, RangeSet const &r)

void	throw_if_not_disjoint (RunNumber_t const rn, EventRange const &left, EventRange const &right) noexcept(false)

bool	overlapping_ranges (RangeSet const &l, RangeSet const &r)

std::ostream &	operator<< (std::ostream &os, RangeSet const &rs)

std::ostream &	operator<< (std::ostream &os, art::RunID const &iID)

std::ostream &	operator<< (std::ostream &os, SampledEventInfo const &eventInfo)

std::ostream &	operator<< (std::ostream &os, SubRunID const &iID)

bool	operator< (TypeLabel const &a, TypeLabel const &b)

std::ostream &	operator<< (std::ostream &os, TypeLabel const &tl)

template<typename WANTED_POINTER , typename InputIterator >
WANTED_POINTER	ensurePointer (InputIterator it)

std::ostream &	operator<< (std::ostream &ost, InputTag const &tag)

bool	operator!= (InputTag const &left, InputTag const &right) noexcept

void	decode (boost::any const &a, InputTag &tag)

constexpr auto	underlying_value (Level const l) noexcept

constexpr auto	highest_level () noexcept

constexpr auto	level_up (Level const l) noexcept

constexpr auto	most_deeply_nested_level () noexcept

constexpr auto	level_down (Level const l) noexcept

constexpr bool	is_above_most_deeply_nested_level (Level const l) noexcept

constexpr bool	is_most_deeply_nested_level (Level const l) noexcept

constexpr bool	is_highest_level (Level const l) noexcept

constexpr bool	is_level_contained_by (Level const l1, Level const l2) noexcept

std::ostream &	operator<< (std::ostream &os, Level const l)

bool	operator> (TypeID const &, TypeID const &)

bool	operator!= (TypeID const &, TypeID const &)

std::ostream &	operator<< (std::ostream &, TypeID const &)

void	swap (TypeID &, TypeID &)

bool	is_assns (TypeID const &tid)

bool	is_assns (std::string const &type_name)

bool	is_instantiation_of (std::string const &type_name, std::string const &template_name)

bool	is_instantiation_of (TypeID const &tid, std::string const &template_name)

std::string	name_of_template_arg (std::string const &template_instance, size_t desired_arg)

std::string	name_of_assns_partner (std::string assns_type_name)

std::string	name_of_assns_base (std::string assns_type_name)

std::string	name_of_unwrapped_product (std::string const &wrapped_name)

std::string	uniform_type_name (std::type_info const &tid)

std::string	uniform_type_name (std::string name)

std::string	wrappedClassName (std::string const &iFullName)

std::string const &	getCanvasReleaseVersion ()

Variables
std::mutex	usr2_lock

std::atomic< int >	shutdown_flag

debugvalue	debugit

Detailed Description

Service to store calibration data products (CDP) in the SQLite3 metadatabase of a file.

HLT enums.

Class for generating ASIC traces including the effect // of the pre-amplifier and the energy dependent fall time // seen on the JINR test stand. //.

Class for dealing with correlated noise on the FEB // in the simulation. // See NOVA-doc-4401 for background //.

Class for generating ASIC traces using the analytic form. // This does not include pre-amplifier or fall time variation // modeling. //.

Interface class for pulse shapers //.

Class for simulating the spread in photo-electrons // according to the theory of APDs presented in // P. Balaban, P.E Fleischer, H Zucker, // IEEE Trans. Electron Devices 23, 1189-1190, (1979) // See NOVA-doc-4401 for background //.

A module for propagating particles through Geant4 and generating energy depositions.

Author: brebe.nosp@m.l@fn.nosp@m.al.go.nosp@m.v

Version

Id: G4Alg.h,v 1.3 2012-09-13 15:23:13 brebel Exp

Author: brebe.nosp@m.l@fn.nosp@m.al.go.nosp@m.v; messi.nosp@m.er@i.nosp@m.ndian.nosp@m.a.ed.nosp@m.u brebe.nosp@m.l@fn.nosp@m.al.go.nosp@m.v rhatc.nosp@m.her@.nosp@m.fnal..nosp@m.gov; auris.nosp@m.aam@.nosp@m.ucmai.nosp@m.l.uc.nosp@m..edu //

Date: //

Author: rbpat.nosp@m.ter@.nosp@m.calte.nosp@m.ch.e.nosp@m.du //

Date: //

Definition of common HLT enums

Typedef Documentation

using art::AvailableProducts_t = typedef std::unordered_set<ProductID, ProductID::Hash>

Definition at line 21 of file type_aliases.h.

template<Level L>

using art::Begin = typedef typename BeginEndPackage<L>::Begin

Definition at line 256 of file PrincipalPackages.h.

typedef unsigned short art::BranchListIndex

Definition at line 13 of file BranchListIndex.h.

typedef std::vector<BranchListIndex> art::BranchListIndexes

Definition at line 14 of file BranchListIndex.h.

using art::CFUNC = typedef void (*)(int, siginfo_t*, void*)

Definition at line 24 of file UnixSignalHandlers.h.

using art::ConsumableProducts = typedef std::array<ConsumableProductVectorPerBranch, NumBranchTypes>

Definition at line 55 of file ProductInfo.h.

using art::ConsumableProductSetPerBranch = typedef std::set<ProductInfo>

Definition at line 53 of file ProductInfo.h.

using art::ConsumableProductSets = typedef std::array<ConsumableProductSetPerBranch, NumBranchTypes>

Definition at line 57 of file ProductInfo.h.

using art::ConsumableProductVectorPerBranch = typedef std::vector<ProductInfo>

Definition at line 52 of file ProductInfo.h.

using art::CountingStatistics = typedef ExecutionCounts<stats::Visited, stats::Run, stats::Passed, stats::Failed, stats::ExceptionThrown>

Definition at line 56 of file ExecutionCounts.h.

using art::DataFlowDumper = typedef ProvenanceDumper<DataFlow>

Definition at line 28 of file DataFlowDumper_module.cc.

template<Level L>

using art::Do = typedef ProcessPackage<L>

Definition at line 73 of file PrincipalPackages.h.

template<Level L>

using art::End = typedef typename BeginEndPackage<L>::End

Definition at line 259 of file PrincipalPackages.h.

using art::EntryNumberSequence = typedef std::vector<FileIndex::EntryNumber_t>

Definition at line 23 of file MixTypes.h.

using art::EventAuxiliarySequence = typedef std::vector<EventAuxiliary>

Definition at line 24 of file MixTypes.h.

using art::EventIDIndex = typedef std::map<FileIndex::EntryNumber_t, EventID>

Definition at line 19 of file MixTypes.h.

using art::EventIDSequence = typedef std::vector<EventID>

Definition at line 22 of file MixTypes.h.

using art::EventNumber_t = typedef IDNumber_t<Level::Event>

Definition at line 117 of file IDNumber.h.

typedef fhicl::ParameterSetID art::EventSelectionID

Definition at line 17 of file EventSelectionID.h.

typedef std::vector<EventSelectionID> art::EventSelectionIDVector

Definition at line 18 of file EventSelectionID.h.

using art::Exception = typedef cet::coded_exception<errors::ErrorCodes, ExceptionDetail::translate>

Definition at line 66 of file Exception.h.

template<Level L>

using art::IDNumber_t = typedef typename IDNumber<L>::type

Definition at line 108 of file IDNumber.h.

template<typename PROD , typename OPROD = PROD>

using art::MixFunc = typedef std::function< bool(std::vector<PROD const*> const&, OPROD&, PtrRemapper const&)>

Definition at line 17 of file MixTypes.h.

typedef unsigned int art::ModuleDescriptionID

Definition at line 8 of file ModuleDescriptionID.h.

using art::new_t = typedef std::string

Definition at line 11 of file SAMMetadataTranslators.h.

using art::old_t = typedef std::string

Definition at line 12 of file SAMMetadataTranslators.h.

using art::OptionsHandlers = typedef std::vector<std::unique_ptr<art::OptionsHandler>>

Definition at line 10 of file OptionsHandlers.h.

typedef std::map<fhicl::ParameterSetID, ParameterSetBlob> art::ParameterSetMap

Definition at line 8 of file ParameterSetMap.h.

typedef Hash<ParentageType> art::ParentageID

Definition at line 8 of file ParentageID.h.

typedef thread_safe_registry_via_id<ParentageID, Parentage> art::ParentageRegistry

Definition at line 9 of file ParentageRegistry.h.

using art::PathPtrs = typedef std::vector<std::unique_ptr<Path>>

Definition at line 29 of file Path.h.

typedef Hash<ProcessConfigurationType> art::ProcessConfigurationID

Definition at line 8 of file ProcessConfigurationID.h.

using art::ProcessConfigurationMap = typedef ProcessConfigurationRegistry::collection_type

Definition at line 18 of file ProcessConfigurationRegistry.h.

using art::ProcessConfigurationRegistry = typedef thread_safe_registry_via_id<ProcessConfigurationID, ProcessConfiguration>

Definition at line 17 of file ProcessConfigurationRegistry.h.

using art::ProcessConfigurations = typedef std::vector<ProcessConfiguration>

Definition at line 65 of file ProcessConfiguration.h.

typedef Hash<ProcessHistoryType> art::ProcessHistoryID

Definition at line 8 of file ProcessHistoryID.h.

typedef std::map<ProcessHistoryID const, ProcessHistory> art::ProcessHistoryMap

Definition at line 14 of file ProcessHistory.h.

using art::ProcessHistoryRegistry = typedef thread_safe_registry_via_id<ProcessHistoryID, ProcessHistory>

Definition at line 23 of file ProcessHistoryRegistry.h.

using art::ProcessLookup = typedef std::map<std::string, std::vector<ProductID>>

Definition at line 15 of file type_aliases.h.

using art::ProductDescriptions = typedef std::vector<BranchDescription>

Definition at line 301 of file BranchDescription.h.

typedef std::map<BranchKey, BranchDescription> art::ProductList

Definition at line 15 of file ProductList.h.

using art::ProductListUpdatedCallback = typedef std::function<void(ProductList const&)>

Definition at line 42 of file MasterProductRegistry.h.

using art::ProductLookup_t = typedef std::map<std::string, ProcessLookup>

Definition at line 20 of file type_aliases.h.

using art::ProductProvenances = typedef std::vector<ProductProvenance>

Definition at line 23 of file ProductProvenance.h.

using art::ProductStatus = typedef unsigned char

Definition at line 6 of file ProductStatus.h.

typedef std::string art::ReleaseVersion

Definition at line 6 of file ReleaseVersion.h.

using art::RunIDIndex = typedef std::map<SubRunID, FileIndex::EntryNumber_t>

Definition at line 21 of file MixTypes.h.

using art::RunNumber_t = typedef IDNumber_t<Level::Run>

Definition at line 119 of file IDNumber.h.

using art::SampledRunInfo = typedef std::map<std::string, SampledInfo<RunID>>

Definition at line 39 of file SampledInfo.h.

using art::SampledSubRunInfo = typedef std::map<std::string, SampledInfo<SubRunID>>

Definition at line 40 of file SampledInfo.h.

using art::Selections = typedef std::vector<BranchDescription const*>

Definition at line 11 of file Selections.h.

using art::SelectionsArray = typedef std::array<Selections, NumBranchTypes>

Definition at line 12 of file Selections.h.

using art::SubRunIDIndex = typedef std::map<SubRunID, FileIndex::EntryNumber_t>

Definition at line 20 of file MixTypes.h.

using art::SubRunNumber_t = typedef IDNumber_t<Level::SubRun>

Definition at line 118 of file IDNumber.h.

using art::TimeValue_t = typedef std::uint64_t

Definition at line 7 of file Timestamp.h.

template<typename T >

using art::tool_return_type = typedef typename detail::tool_type<T>::return_type

Definition at line 15 of file make_tool.h.

using art::ViewLookup_t = typedef ProcessLookup

Definition at line 17 of file type_aliases.h.

using art::WorkerMap = typedef std::map<std::string, std::unique_ptr<Worker>>

Definition at line 10 of file WorkerMap.h.

Enumeration Type Documentation

enum art::BranchActionType

Enumerator
BranchActionBegin
BranchActionEnd
BranchActionProcess

Definition at line 11 of file BranchActionType.h.

                         {
     BranchActionBegin = 0,
     BranchActionEnd,
     BranchActionProcess
   };

enum art::BranchType

Enumerator
InEvent
InSubRun
InRun
InResults
NumBranchTypes

Definition at line 18 of file BranchType.h.

18 { InEvent, InSubRun, InRun, InResults, NumBranchTypes };

art::NumBranchTypes

Definition: BranchType.h:18

art::InResults

Definition: BranchType.h:18

art::InEvent

Definition: BranchType.h:18

art::InSubRun

Definition: BranchType.h:18

art::InRun

Definition: BranchType.h:18

enum art::Direction : int

strong

Enumerator
Forward
Reverse

Definition at line 24 of file AssnsIter.h.

24 : int { Forward = 1, Reverse = -1 };

art::Direction::Forward

art::Direction::Reverse

enum art::FileCatalogStatus

strong

Enumerator
SUCCESS
NO_MORE_FILES
DELIVERY_ERROR
TRANSFER_ERROR

Definition at line 26 of file InputFileCatalog.h.

                                {
     SUCCESS,
     NO_MORE_FILES,
     DELIVERY_ERROR,
     TRANSFER_ERROR
   };

enum art::FileDisposition

strong

Enumerator
PENDING
TRANSFERRED
CONSUMED
SKIPPED
INCOMPLETE

Definition at line 13 of file FileDisposition.h.

                               {
   PENDING = -1,
   TRANSFERRED,
   CONSUMED,
   SKIPPED,
   INCOMPLETE
 };

enum art::HashedTypes

Enumerator
ModuleDescriptionType
ParameterSetType
ProcessHistoryType
ProcessConfigurationType
EntryDescriptionType
ParentageType

Definition at line 11 of file HashedTypes.h.

                    {
     ModuleDescriptionType, // Obsolete
     ParameterSetType,
     ProcessHistoryType,
     ProcessConfigurationType,
     EntryDescriptionType, // Obsolete
     ParentageType
   };

enum art::Level

strong

Enumerator
Job
InputFile
Run
SubRun
Event
NumNestingLevels
ReadyToAdvance

Definition at line 12 of file Level.h.

                    {
     Job = 0,
     InputFile,
     Run,
     SubRun,
     Event,
     NumNestingLevels,
     ReadyToAdvance
   };

enum art::ModuleType

strong

Enumerator
NON_ART
ANALYZER
FILTER
PRODUCER
OUTPUT

Definition at line 22 of file ModuleType.h.

22 { NON_ART, ANALYZER, FILTER, PRODUCER, OUTPUT };

art::ModuleType::PRODUCER

art::ModuleType::FILTER

art::ModuleType::ANALYZER

art::ModuleType::NON_ART

art::ModuleType::OUTPUT

enum art::OutputFileStatus

strong

Enumerator
Open
Switching
Closed

Definition at line 8 of file OutputFileStatus.h.

8 { Open, Switching, Closed };

art::OutputFileStatus::Open

art::OutputFileStatus::Switching

art::OutputFileStatus::Closed

enum art::Persistable

strong

Enumerator
Yes
No

Definition at line 5 of file Persistable.h.

5 { Yes, No };

art::Persistable::Yes

art::Persistable::No

enum art::ServiceScope

strong

Enumerator
LEGACY
GLOBAL
PER_SCHEDULE

Definition at line 5 of file ServiceScope.h.

5 { LEGACY, GLOBAL, PER_SCHEDULE };

art::ServiceScope::PER_SCHEDULE

art::ServiceScope::GLOBAL

art::ServiceScope::LEGACY

enum art::suffix_type

strong

Enumerator
module
plugin
service
source
tool
mfPlugin
mfStatsPlugin

Definition at line 61 of file PluginSuffixes.h.

                          {
     module,
     plugin,
     service,
     source,
     tool,
     mfPlugin,
     mfStatsPlugin
   };

enum art::Verbosity

Enumerator
Silent
Concise
Normal
Detailed

Definition at line 5 of file Verbosity.h.

5 { Silent = 0, Concise = 2, Normal = 5, Detailed = 10 };

art::Detailed

Definition: Verbosity.h:5

art::Concise

Definition: Verbosity.h:5

art::Normal

Definition: Verbosity.h:5

art::Silent

Definition: Verbosity.h:5

Function Documentation

template<typename T , typename... Args>

void art::add_opt	(	T &	t,
		Args &&...	args
	)

Definition at line 34 of file OptionsHandler.h.

References runNovaSAM::args, and confusionMatrixTree::t.

   {
     t(std::forward<Args>(args)...);
   }

std::string const& art::BranchTypeToAuxiliaryBranchName ( BranchType )

Referenced by art::RootOutputTree::RootOutputTree().

std::string const& art::BranchTypeToMajorIndexName ( BranchType )

std::string const& art::BranchTypeToMetaDataTreeName ( BranchType )

Referenced by art::RootOutputTree::RootOutputTree().

std::string const& art::BranchTypeToMinorIndexName ( BranchType )

std::string const& art::BranchTypeToProductTreeName ( BranchType )

Referenced by art::RootOutputTree::RootOutputTree().

std::string const& art::BranchTypeToString ( BranchType )

Referenced by operator<<(), and art::FileDumperOutput::printPrincipal().

std::string art::canonicalProductName	(	std::string const &	friendlyClassName,
		std::string const &	moduleLabel,
		std::string const &	productInstanceName,
		std::string const &	processName
	)

Referenced by art::ProductID::invalid().

void art::checkDictionaries ( BranchDescription const & productDesc )

bool art::combinable	(	BranchDescription const &	a,
		BranchDescription const &	b
	)

Referenced by art::BranchDescription::wrappedName().

void art::completeRootHandlers ( )

template<typename CONTAINER >

std::enable_if_t<detail::has_two_arg_insert<CONTAINER>::value> art::concatContainers	(	CONTAINER &	out,
		CONTAINER const &	in
	)

Referenced by art::detail::TwoArgInsert< cet::map_vector< T > >::concatenate(), flattenCollections(), and art::detail::mix_offset< cet::map_vector< P > >::offset().

template<typename CONTAINER >

std::enable_if_t<detail::has_three_arg_insert<CONTAINER>::value> art::concatContainers	(	CONTAINER &	out,
		CONTAINER const &	in
	)

template<class T >

void art::convert_handle	(	GroupQueryResult const &	orig,
		Handle< T > &	result
	)

Definition at line 248 of file Handle.h.

References make_syst_table_plots::h, and art::Handle< T >::swap().

Referenced by art::DataViewImpl::get(), art::DataViewImpl::getByLabel(), and art::DataViewImpl::getMany().

 {
   Handle<T> h{orig};
   result.swap(h);
 }

std::string art::couldNotFindTree ( std::string const & treename )

inline

Definition at line 9 of file rootErrMsgs.h.

References datagram_client::message.

Referenced by art::detail::readFileIndex().

   {
     std::string message = "Could not find tree ";
     message.append(treename);
     message.append(" in the input file.\n");
     return message;
   }

void art::decode	(	boost::any const &	a,
		InputTag &	tag
	)

Referenced by fhicl::ParameterSet::get_one_(), and operator!=().

void art::disableAllSigs ( sigset_t * oldset )

void art::disableRTSigs ( )

void art::disableSignal	(	sigset_t *	newset,
		int	signum
	)

template<class T , class U >

std::enable_if_t<detail::are_handles<T, U>::value, bool> art::disjoint_ranges	(	T const &	a,
		U const &	b
	)

Referenced by disjoint_ranges(), art::ValidHandle< T >::swap(), art::detail::throw_if_invalid(), and art::SummedValue< T >::update_impl().

bool art::disjoint_ranges	(	RangeSet const &	l,
		RangeSet const &	r
	)

template<class T , class U >

bool art::disjoint_ranges	(	SummedValue< T > const &	a,
		SummedValue< U > const &	b
	)

Definition at line 182 of file SummedValue.h.

References disjoint_ranges(), and art::SummedValue< T >::rangeOfValidity().

   {
     return disjoint_ranges(a.rangeOfValidity(), b.rangeOfValidity());
   }

void art::enableSignal	(	sigset_t *	newset,
		int	signum
	)

template<typename WANTED_POINTER , typename InputIterator >

WANTED_POINTER art::ensurePointer ( InputIterator it )

inline

Definition at line 77 of file ensurePointer.h.

References art::errors::LogicError.

Referenced by art::detail::IPRHelper< ProdA, ProdB, Data, DATACOLL, EVENT >::operator()().

                                        {
   static_assert(std::is_pointer<WANTED_POINTER>::value,
                 "Supplied template argument is not a pointer.");
   return detail::EnsurePointer<
     WANTED_POINTER,
     typename std::iterator_traits<InputIterator>::value_type>{}(*it);
 }
 catch (std::bad_cast&) {
   throw Exception(errors::LogicError, "ensurePointer")
     << "Iterator value type "
     << cet::demangle_symbol(
          typeid(typename std::iterator_traits<InputIterator>::value_type)
            .name())
     << " and wanted pointer type "
     << cet::demangle_symbol(typeid(WANTED_POINTER).name())
     << " are incompatible.\n";
 }

void art::ensureTable	(	fhicl::intermediate_table &	table,
		std::string const &	fhicl_spec
	)

void art::ep_sigusr2	(	int	,
		siginfo_t *	,
		void *
	)

template<typename T , typename H >

void art::fill_ptr_list	(	std::list< Ptr< T >> &	ptrs,
		H const &	h
	)

Definition at line 473 of file Ptr.h.

References MECModelEnuComparisons::i.

 {
   for (std::size_t i = 0, sz = h->size(); i != sz; ++i) {
     ptrs.emplace_back(h, i);
   }
 }

template<typename T , typename H >

void art::fill_ptr_vector	(	std::vector< Ptr< T >> &	ptrs,
		H const &	h
	)

Definition at line 464 of file Ptr.h.

References MECModelEnuComparisons::i.

 {
   for (std::size_t i = 0, sz = h->size(); i != sz; ++i) {
     ptrs.emplace_back(h, i);
   }
 }

bool art::find_config	(	std::string const &	filename,
		std::string const &	search_path_spec,
		std::string &	full_path
	)

template<typename COLLECTION >

void art::flattenCollections	(	std::vector< COLLECTION const * > const &	in,
		COLLECTION &	out
	)

Definition at line 283 of file CollectionUtilities.h.

References concatContainers().

 {
   typename COLLECTION::size_type total_size = 0;
   for (auto collptr : in) {
     if (collptr != nullptr) {
       total_size += collptr->size();
     }
   }
   out.reserve(total_size);
   for (auto collptr : in) {
     if (collptr != nullptr) {
       concatContainers(out, *collptr);
     }
   }
 }

template<typename COLLECTION , typename OFFSETS >

void art::flattenCollections	(	std::vector< COLLECTION const * > const &	in,
		COLLECTION &	out,
		OFFSETS &	offsets
	)

Definition at line 303 of file CollectionUtilities.h.

References delta, in, art::detail::mix_offset< C >::offset(), and confusionMatrixTree::out.

 {
   offsets.clear();
   offsets.reserve(in.size());
   typename COLLECTION::size_type current_offset{};
   for (auto collptr : in) {
     if (collptr == nullptr)
       continue;
 
     auto const delta = detail::mix_offset<COLLECTION>::offset(*collptr);
     offsets.push_back(current_offset);
     current_offset += delta;
   }
   flattenCollections<COLLECTION>(in, out); // 1.
 }

template<typename T >

void art::flattenCollections	(	std::vector< PtrVector< T > const * > const &	in,
		PtrVector< T > &	out
	)

Definition at line 324 of file CollectionUtilities.h.

References in, art::errors::LogicError, confusionMatrixTree::out, and art::detail::verifyPtrCollection().

 {
   // Extra checks are required to verify that the PtrVectors are
   // compatible.
   if (!detail::verifyPtrCollection(in)) {
     throw Exception(errors::LogicError)
       << "Attempt to flatten incompatible PtrVectors "
       << "referring to different ProductIDs.\n";
   }
   flattenCollections<PtrVector<T>>(in, out); // 1
 }

template<typename T , typename OFFSETS >

void art::flattenCollections	(	std::vector< PtrVector< T > const * > const &	in,
		PtrVector< T > &	out,
		OFFSETS &	offsets
	)

Definition at line 340 of file CollectionUtilities.h.

References in, art::errors::LogicError, confusionMatrixTree::out, and art::detail::verifyPtrCollection().

 {
   // Extra checks are required to verify that the PtrVectors are
   // compatible.
   if (!detail::verifyPtrCollection(in)) {
     throw Exception(errors::LogicError)
       << "Attempt to flatten incompatible PtrVectors "
       << "referring to different ProductIDs.\n";
   }
   flattenCollections<PtrVector<T>>(in, out, offsets); // 2.
 }

template<typename A , typename B , typename D , typename F >

void art::for_each_group	(	art::Assns< A, B, D > const &	assns,
		F	func
	)

Helper functions to access associations in order.

Template Parameters

A	type of association being read
F	type of functor to be called on each associated group

Parameters

assns	the association being read
func	functor to be called on each associated group

This function takes two input arguments, a constant reference to the association data product itself (assns), and the function (func) to be operated on each of the group of associated objects. This function represents the association data product as a range of ranges representing the right hand side in the collection, hence the function provided as the second argument should assume that it will be operating on a range of art::Ptr to the associated data products grouped by the data product they are associated with.

Example: assuming that a module with input tag stored in fTrackTag has created associations of each track to its hits, the total charge for each track can be extracted by:

auto assns = art::getValidHandle<art::Assns<recob::Track, recob::Hit>>
  (fTrackTag);
std::vector<double> totalCharge;
art::for_each_group(*assns,
  [&totalCharge](auto hits)
    {
      double total = 0.;
      for (auto iHit = begin(hits); iHit != end(hits); ++iHit)
        total += (*iHit)->Integral();
      totalCharge.push_back(total);
    }
  );

A number of important points need to be realised about this example:

the requirements of this function translate, for this example, into:
- at the creation of the associations data product, for each track the complete sequence of hits must be associated, one hit after the other (via addSingle); if the order of the hits is relevant (it is not in this specific example), hits must be associated in that order
- each track must have at least one associated hit;
- the original association has to be stored with recob::Track as left key and recob::Hit as right key;
we use here a lambda function as func; any object behaving as a function and able to accept the range of hits as its only argument will work just as well;
func will be called once for every track (but if a track has no associated hit, that track will be skipped, and if a track appears in more than one association sequence, like in (T1,H1) (T1,H2) (T2,H4) (T1,H3), then that track will appear as many times);
func does not return any value: the results are accumulated in a new sequence;
func receives a range of art pointers (art::Ptr<recob::Hit>) which needs to be navigated with the begin()/end() free functions (don't specify their namespace: C++ will figure out!); double dereferencing is needed: the first (*iHit) will turn the range iterator into the pointed art::Ptr<recob::Hit>, and the second ((...)->Integral()) accesses the recob::Hit pointed by the art pointer;
func does not know which track the hits are associated to, and it assumes that the first sequence of hits is associated to the first track (so that its total charge will be available in totalCharge[0]), the second sequence to the second track (totalCharge[1]) and so on.

Therefore, for a assns sequence like

(T1,H1) (T1,H2) (T2,H4) (T2,H6) (T1,H5)

the function for_each_group() will execute two calls:

func({ H1, H2 })
func({ H4, H6, H5 })

dealing with the hits associated to T1 first, and T2 next.

Definition at line 111 of file AssnsAlgorithms.h.

References a1, a2, PandAna.Demos.pi0_spectra::transform, and train_latest_snapshot::values.

   {
     ranges::for_each(assns | ranges::view::all |
                        ranges::view::group_by([](auto a1, auto a2) {
                          return a1.first == a2.first;
                        }) |
                        ranges::view::transform([](auto pairs) {
                          return pairs | ranges::view::values;
                        }),
                      func);
   }

template<typename A , typename B , typename D , typename F >

void art::for_each_group_with_left	(	art::Assns< A, B, D > const &	assns,
		F	func
	)

Definition at line 141 of file AssnsAlgorithms.h.

References for_each_pair(), func(), caf_analysis::keys, left(), and train_latest_snapshot::values.

   {
     for_each_pair(assns, [&func](auto rng) {
       auto rights = rng | ranges::view::values;
       auto lefts = rng | ranges::view::keys;
       auto const& left = **ranges::begin(lefts);
       func(left, rights);
     });
   }

template<typename A , typename B , typename D , typename F >

void art::for_each_pair	(	art::Assns< A, B, D > const &	assns,
		F	func
	)

Definition at line 153 of file AssnsAlgorithms.h.

References a1, and a2.

Referenced by for_each_group_with_left().

   {
     ranges::for_each(assns | ranges::view::all |
                        ranges::view::group_by(
                          [](auto a1, auto a2) { return a1.first == a2.first; }),
                      func);
   }

constexpr auto art::fullRun ( )

Definition at line 22 of file ProductSemantics.h.

   {
     return FullSemantic<Level::Run>{};
   }

constexpr auto art::fullSubRun ( )

Definition at line 27 of file ProductSemantics.h.

   {
     return FullSemantic<Level::SubRun>{};
   }

template<typename T >

BranchDescription const& art::get_ProductDescription	(	BranchType	branch_type,
		std::string const &	module_label,
		std::string const &	instance_name
	)

template<typename T >

BranchDescription const& art::get_ProductDescription	(	Principal const &	principal,
		std::string const &	module_label,
		std::string const &	instance_name
	)

BranchDescription const& art::get_ProductDescription	(	TypeID	type_id,
		BranchType	branch_type,
		std::string const &	module_label,
		std::string const &	instance_name
	)

BranchDescription const& art::get_ProductDescription	(	TypeID	type_id,
		Principal const &	principal,
		std::string const &	module_label,
		std::string const &	instance_name
	)

BranchDescription const& art::get_ProductDescription	(	TypeID	tid,
		std::string const &	process_name,
		ProductList const &	product_list,
		BranchType	branch_type,
		std::string const &	module_label,
		std::string const &	instance_name
	)

std::string const& art::getCanvasReleaseVersion ( )

template<class COLLECTION >

void art::getElementAddresses	(	COLLECTION const &	coll,
		const std::type_info &	iToType,
		const std::vector< unsigned long > &	iIndices,
		std::vector< void const * > &	oPtr
	)

Definition at line 67 of file getElementAddresses.h.

References it, and art::detail::maybeCastObj().

 {
   typedef COLLECTION product_type;
   oPtr.reserve(iIndices.size());
   for (std::vector<unsigned long>::const_iterator itIndex = iIndices.begin(),
                                                   itEnd = iIndices.end();
        itIndex != itEnd;
        ++itIndex) {
     auto it = coll.begin();
     advance(it, *itIndex);
     oPtr.push_back(detail::maybeCastObj(
       detail::GetProduct<product_type>::address(it), iToType));
   }
 }

template<typename T >

void art::getElementAddresses	(	cet::map_vector< T > const &	obj,
		const std::type_info &	iToType,
		const std::vector< unsigned long > &	iIndices,
		std::vector< void const * > &	oPtr
	)

Definition at line 87 of file getElementAddresses.h.

References cet::map_vector< Value >::end(), cet::map_vector< Value >::find(), cet::map_vector< Value >::getOrNull(), it, art::detail::value_type_helper::look_past_pair(), art::detail::maybeCastObj(), elec2geo::pos, art::detail::value_type_helper::starts_with_pair(), T, and uniform_type_name().

 {
   typedef cet::map_vector<T> product_type;
   typedef typename product_type::const_iterator iter;
   detail::value_type_helper vh;
   std::string const wanted_type =
     uniform_type_name(cet::demangle_symbol(iToType.name()));
   static size_t pos = vh.look_past_pair<T>();
   oPtr.reserve(iIndices.size());
   if ((pos < wanted_type.size()) && vh.starts_with_pair(wanted_type, pos)) {
     // Want value_type.
     for (std::vector<unsigned long>::const_iterator itIndex = iIndices.begin(),
                                                     itEnd = iIndices.end();
          itIndex != itEnd;
          ++itIndex) {
       iter it = obj.find(cet::map_vector_key(*itIndex));
       oPtr.push_back(
         detail::maybeCastObj((it == obj.end()) ? 0 : &(*it), iToType));
     }
   } else {
     // Want mapped_type.
     for (std::vector<unsigned long>::const_iterator itIndex = iIndices.begin(),
                                                     itEnd = iIndices.end();
          itIndex != itEnd;
          ++itIndex) {
       oPtr.push_back(detail::maybeCastObj(
         obj.getOrNull(cet::map_vector_key(*itIndex)), iToType));
     }
   }
 }

std::string const& art::getFileFormatEra ( )

int art::getFileFormatVersion ( )

MallocOptionSetter& art::getGlobalOptionSetter ( )

Referenced by art::MemoryAdjuster::MemoryAdjuster().

std::string const& art::getReleaseVersion ( )

int art::getSigNum ( )

std::string art::glob2reg ( std::string pattern )

bool art::greaterBySize	(	RootSizeOnDisk::Record const &	lhs,
		RootSizeOnDisk::Record const &	rhs
	)

bool art::have_table	(	sqlite3 *	db,
		std::string const &	table,
		std::string const &	filename
	)

constexpr auto art::highest_level ( )

noexcept

Definition at line 39 of file Level.h.

Referenced by is_highest_level().

   {
     return static_cast<Level>(0);
   }

template<Direction Dir>

constexpr auto art::index_for_dereferencing ( std::size_t const i )

Definition at line 95 of file AssnsIter.h.

References Forward.

   {
     return (Dir == Direction::Forward) ? i : i - 1;
   }

void art::installCustomHandler	(	int	signum,
		CFUNC	func
	)

void art::installSig	(	int	signum,
		CFUNC	func
	)

constexpr bool art::is_above_most_deeply_nested_level ( Level const l )

noexcept

Definition at line 63 of file Level.h.

References submit_hadd::l, most_deeply_nested_level(), and underlying_value().

   {
     return underlying_value(l) < underlying_value(most_deeply_nested_level());
   }

bool art::is_assns ( TypeID const & tid )

inline

Definition at line 145 of file TypeID.h.

References art::TypeID::className().

 {
   return is_assns(tid.className());
 }

bool art::is_assns ( std::string const & type_name )

inline

Definition at line 151 of file TypeID.h.

References is_instantiation_of().

 {
   using namespace std::string_literals;
   return is_instantiation_of(type_name, "art::Assns"s);
 }

bool art::is_glob ( std::string const & pattern )

constexpr bool art::is_highest_level ( Level const l )

noexcept

Definition at line 75 of file Level.h.

References highest_level(), and submit_hadd::l.

   {
     return l == highest_level();
   }

bool art::is_instantiation_of	(	std::string const &	type_name,
		std::string const &	template_name
	)

inline

Definition at line 158 of file TypeID.h.

Referenced by is_assns(), and is_instantiation_of().

 {
   return type_name.find(template_name + '<') == 0ull;
 }

bool art::is_instantiation_of	(	TypeID const &	tid,
		std::string const &	template_name
	)

inline

Definition at line 165 of file TypeID.h.

References art::TypeID::className(), and is_instantiation_of().

 {
   return is_instantiation_of(tid.className(), template_name);
 }

constexpr bool art::is_level_contained_by	(	Level const	l1,
		Level const	l2
	)

noexcept

Definition at line 81 of file Level.h.

References central_limit::l1, and underlying_value().

   {
     return underlying_value(l1) > underlying_value(l2);
   }

bool art::is_modifier ( ModuleType mt )

inline

Definition at line 59 of file ModuleType.h.

References FILTER, and PRODUCER.

 {
   return mt == ModuleType::FILTER || mt == ModuleType::PRODUCER;
 }

constexpr bool art::is_most_deeply_nested_level ( Level const l )

noexcept

Definition at line 69 of file Level.h.

References submit_hadd::l, and most_deeply_nested_level().

   {
     return l == most_deeply_nested_level();
   }

bool art::is_observer ( ModuleType mt )

inline

Definition at line 53 of file ModuleType.h.

References ANALYZER, and OUTPUT.

 {
   return mt == ModuleType::ANALYZER || mt == ModuleType::OUTPUT;
 }

template<Level L = Level::Event>

constexpr bool art::is_valid ( IDNumber_t< L > const id )

Definition at line 112 of file IDNumber.h.

References PandAna.reco_validation.prod5_pid_validation::invalid.

Referenced by art::RangeSet::ranges(), and genie::Target::SetHitNucPdg().

   {
     return id != IDNumber<L>::invalid();
   }

bool art::isAncestor	(	art::ProcessHistory const &	a,
		art::ProcessHistory const &	b
	)

Referenced by isDescendant().

bool art::isDescendant	(	art::ProcessHistory const &	a,
		art::ProcessHistory const &	b
	)

inline

Definition at line 173 of file ProcessHistory.h.

References isAncestor().

 {
   return isAncestor(b, a);
 }

template<class L , class R , class D , Direction Dir>

constexpr auto const& art::left	(	const_AssnsIter< L, R, D, Dir > const &	a,
		const_AssnsIter< L, R, D, Dir > const &	b
	)

Definition at line 104 of file AssnsIter.h.

References b, and Forward.

Referenced by ValidCalibPDF::AbsoluteCalibration(), auto_legend(), ValidCalibPDF::CalibAllSamples(), colorhit(), ana::CovMxSurface::CovMxSurface(), CrossCheckDiag(), DrawArrow(), drawLabels(), novaddt::RateMonitor::endJob(), novaddt::UpMuTrigger::filter(), for_each_group_with_left(), lem::dec::Forest::FromFile(), genie_syst_universe(), art::TimeTracker::logToDestination_(), dt::Cand::NSegs(), Nue2018ThreeBinAxis_Reduced(), ana::Nue2018ThreeBinAxis_Reduced(), operator!=(), art::const_AssnsIter< L, R, D, Dir >::operator<(), art::const_AssnsIter< L, R, D, Dir >::operator<=(), art::const_AssnsIter< L, R, D, Dir >::operator>(), art::const_AssnsIter< L, R, D, Dir >::operator>=(), INukeNucleonCorr::OutputFiles(), PhotonSim(), plot_datamcpred(), genie::geometry::PathSegment::Print(), nova::database::Table::PrintColumns(), nutools::dbi::Table::PrintColumns(), nova::dbi::Table::PrintColumns(), stan::mcmc::chains< RNG >::quantile(), stan::mcmc::chains< RNG >::quantiles(), stan::io::stan_csv_reader::read_samples(), remakeresultsplots_nue(), boost::python::detail::proxy_group< Proxy >::replace(), RunOneTrace(), set_labels_1D(), set_labels_2D(), sha1_forRMS_update(), dt::Cand::ShortenOne(), art::MemoryTracker::summary_(), ana::SystConcat::SystConcat(), TestSpacing(), lem::dec::Forest::TrainSingleTransformed(), TransverseEff(), and stan::mcmc::base_leapfrog< dense_e_metric< Model, BaseRNG > >::verbose_evolve().

   {
     return (Dir == Direction::Forward) ? a : b;
   }

constexpr auto art::level_down ( Level const l )

noexcept

Definition at line 57 of file Level.h.

References submit_hadd::l, and underlying_value().

   {
     return static_cast<Level>(underlying_value(l) + 1);
   }

constexpr auto art::level_up ( Level const l )

noexcept

Definition at line 45 of file Level.h.

References submit_hadd::l, and underlying_value().

Referenced by most_deeply_nested_level().

   {
     return static_cast<Level>(underlying_value(l) - 1);
   }

auto art::make_product_descriptions ( ProductList const & productList )

inline

Definition at line 19 of file ProductList.h.

References gammaraytel::pr, fillBadChanDBTables::result, and cet::transform_all().

   {
     ProductDescriptions result;
     cet::transform_all(productList, back_inserter(result), [](auto const& pr) {
       return pr.second;
     });
     return result;
   }

template<typename T >

std::enable_if_t<std::is_class<T>::value, tool_return_type<T> > art::make_tool ( fhicl::ParameterSet const & pset )

Definition at line 19 of file make_tool.h.

References art::errors::Configuration, e, train_bdt::factory, fhicl::ParameterSet::get(), fillBadChanDBTables::result, and art::Suffixes::tool().

   {
     cet::BasicPluginFactory factory{Suffixes::tool(), "makeTool"};
     std::string const libspec{pset.get<std::string>("tool_type")};
     tool_return_type<T> result;
     try {
       result = detail::tool_type<T>::make_plugin(factory, libspec, pset);
     }
     catch (cet::exception const& e) {
       throw Exception(errors::Configuration, "make_tool: ", e)
         << "Exception caught while processing plugin spec: " << libspec << '\n';
     }
     return result;
   }

template<typename T >

std::enable_if_t<std::is_function<T>::value, tool_return_type<T> > art::make_tool	(	fhicl::ParameterSet const &	pset,
		std::string const &	function_tool_type
	)

Definition at line 36 of file make_tool.h.

References art::errors::Configuration, e, train_bdt::factory, fhicl::ParameterSet::get(), fillBadChanDBTables::result, and art::Suffixes::tool().

   {
     cet::BasicPluginFactory factory{
       Suffixes::tool(), "toolFunction", "toolType"};
     std::string const libspec{pset.get<std::string>("tool_type")};
     tool_return_type<T> result;
     try {
       result = detail::tool_type<T>::make_plugin(
         factory, libspec, pset, function_tool_type);
     }
     catch (cet::exception const& e) {
       throw Exception(errors::Configuration, "make_tool: ", e)
         << "Exception caught while processing plugin spec: " << libspec << '\n';
     }
     return result;
   }

template<typename T , typename TableConfig >

std::enable_if_t<std::is_class<T>::value, tool_return_type<T> > art::make_tool ( TableConfig const & tc )

inline

Definition at line 56 of file make_tool.h.

   {
     return make_tool<T>(tc.get_PSet());
   }

template<typename T , typename TableConfig >

std::enable_if_t<std::is_function<T>::value, tool_return_type<T> > art::make_tool	(	TableConfig const &	tc,
		std::string const &	function_tool_type
	)

inline

Definition at line 63 of file make_tool.h.

   {
     return make_tool<T>(tc.get_PSet(), function_tool_type);
   }

static void art::markAncestors	(	ProductProvenance const &	iInfo,
		BranchMapper const &	iMapper,
		std::map< ProductID, bool > &	oMap,
		std::set< ProductID > &	oMapperMissing
	)

static

Definition at line 54 of file ProvenanceCheckerOutput_module.cc.

References art::BranchMapper::branchToProductProvenance(), cet::exempt_ptr< Element >::get(), file_size_ana::parent, art::ProductProvenance::parentage(), and art::Parentage::parents().

Referenced by art::ProvenanceCheckerOutput::write().

   {
     for (art::ProductID const parent : iInfo.parentage().parents()) {
       // Don't look for parents if we've previously looked at the parents
       if (oMap.find(parent) == oMap.end()) {
         // use side effect of calling operator[] which is if the item isn't
         // there it will add it as 'false'
         oMap[parent];
         cet::exempt_ptr<ProductProvenance const> pInfo =
           iMapper.branchToProductProvenance(parent);
         if (pInfo.get()) {
           markAncestors(*pInfo, iMapper, oMap, oMapperMissing);
         } else {
           oMapperMissing.insert(parent);
         }
       }
     }
   }

constexpr auto art::most_deeply_nested_level ( )

noexcept

Definition at line 51 of file Level.h.

References level_up(), and NumNestingLevels.

Referenced by is_above_most_deeply_nested_level(), and is_most_deeply_nested_level().

   {
     return level_up(Level::NumNestingLevels);
   }

std::string art::name_of_assns_base ( std::string assns_type_name )

std::string art::name_of_assns_partner ( std::string assns_type_name )

std::string art::name_of_template_arg	(	std::string const &	template_instance,
		size_t	desired_arg
	)

std::string art::name_of_unwrapped_product ( std::string const & wrapped_name )

std::map<new_t, old_t> art::newToOldName ( )

inline

Definition at line 15 of file SAMMetadataTranslators.h.

Referenced by oldToNewName(), and art::NewToOld::operator()().

   {
     return {{"file_type", "fileType"},
             {"data_tier", "dataTier"},
             {"data_stream", "streamName"},
             {"run_type", "runType"}};
   }

std::map<new_t, old_t> art::oldToNewName ( )

inline

Definition at line 37 of file SAMMetadataTranslators.h.

References make_pair(), newToOldName(), gammaraytel::pr, and cet::transform_all().

Referenced by art::OldToNew::operator()().

   {
     auto const newToOld = newToOldName();
     std::map<old_t, new_t> oldToNew;
     cet::transform_all(
       newToOld, std::inserter(oldToNew, oldToNew.begin()), [](auto const& pr) {
         return std::make_pair(pr.second, pr.first);
       });
     return oldToNew;
   }

template<class A >

std::enable_if_t< std::is_base_of< art::SelectorBase, A >::value, art::NotHelper< A > > art::operator! ( A const & a )

Definition at line 284 of file Selector.h.

References a.

 {
   return art::NotHelper<A>(a);
 }

bool art::operator!=	(	ScheduleID	left,
		ScheduleID	right
	)

inline

Definition at line 124 of file ScheduleID.h.

References right().

 {
   return !(left == right);
 }

bool art::operator!=	(	InputTag const &	left,
		InputTag const &	right
	)

inlinenoexcept

Definition at line 114 of file InputTag.h.

References a, decode(), left(), right(), and getGoodRuns4SAM::tag.

 {
   return !(left == right);
 }

bool art::operator!=	(	TypeID const &	a,
		TypeID const &	b
	)

inline

Definition at line 133 of file TypeID.h.

References b.

 {
   return !(a == b);
 }

bool art::operator!=	(	RefCore const &	lhs,
		RefCore const &	rhs
	)

inline

Definition at line 143 of file RefCore.h.

 {
   return !(lhs == rhs);
 }

bool art::operator!=	(	art::ProcessHistory const &	a,
		art::ProcessHistory const &	b
	)

inline

Definition at line 167 of file ProcessHistory.h.

References b.

 {
   return !(a == b);
 }

bool art::operator!=	(	BranchKey const &	a,
		BranchKey const &	b
	)

inline

Definition at line 82 of file BranchKey.h.

References b.

 {
   return !(a == b);
 }

bool art::operator!=	(	ProductProvenance const &	a,
		ProductProvenance const &	b
	)

inlinenoexcept

Definition at line 118 of file ProductProvenance.h.

References a, and b.

 {
   return !(a == b);
 }

bool art::operator!=	(	FileFormatVersion const &	a,
		FileFormatVersion const &	b
	)

inline

Definition at line 34 of file FileFormatVersion.h.

References b, ff, and operator<<().

   {
     return !(a == b);
   }

bool art::operator!=	(	Parentage const &	a,
		Parentage const &	b
	)

inline

Definition at line 54 of file Parentage.h.

References b.

   {
     return !(a == b);
   }

bool art::operator!=	(	ProcessConfiguration const &	a,
		ProcessConfiguration const &	b
	)

inline

Definition at line 58 of file ProcessConfiguration.h.

References b, operator<<(), and python.hepunit::pc.

   {
     return !(a == b);
   }

template<typename T , typename U >

std::enable_if_t<std::is_same<T, U>::value \|\| std::is_base_of<T, U>::value \|\| std::is_base_of<U, T>::value, bool> art::operator!=	(	Ptr< T > const &	lhs,
		Ptr< U > const &	rhs
	)

template<class X , class Y >

bool art::operator!=	(	debugging_allocator< X > const &	,
		debugging_allocator< Y > const &
	)
throw	(
	)

Definition at line 108 of file debugging_allocator.h.

Referenced by art::const_AssnsIter< L, R, D, Dir >::const_AssnsIter(), and art::Ptr< T >::getData_().

   {
     return false;
   }

bool art::operator!=	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

inline

Definition at line 215 of file FileIndex.h.

   {
     return lh < rh || rh < lh;
   }

template<class A , class B >

std::enable_if_t< std::is_base_of< art::SelectorBase, A >::value &&std::is_base_of< art::SelectorBase, B >::value, art::AndHelper< A, B > > art::operator&&	(	A const &	a,
		B const &	b
	)

Definition at line 212 of file Selector.h.

References a, and b.

 {
   return art::AndHelper<A, B>(a, b);
 }

bool art::operator<	(	EventProcessHistoryID const &	lh,
		EventProcessHistoryID const &	rh
	)

inline

Definition at line 17 of file EventProcessHistoryID.h.

References art::EventProcessHistoryID::eventID_.

   {
     return lh.eventID_ < rh.eventID_;
   }

bool art::operator<	(	RefCore const &	lhs,
		RefCore const &	rhs
	)

inline

Definition at line 149 of file RefCore.h.

References art::RefCore::id().

 {
   return lhs.id() < rhs.id();
 }

bool art::operator<	(	BranchKey const &	a,
		BranchKey const &	b
	)

inline

Definition at line 62 of file BranchKey.h.

References art::BranchKey::branchType_, art::BranchKey::friendlyClassName_, art::BranchKey::moduleLabel_, art::BranchKey::processName_, and art::BranchKey::productInstanceName_.

 {
   return std::tie(a.friendlyClassName_,
                   a.moduleLabel_,
                   a.productInstanceName_,
                   a.processName_,
                   a.branchType_) < std::tie(b.friendlyClassName_,
                                             b.moduleLabel_,
                                             b.productInstanceName_,
                                             b.processName_,
                                             b.branchType_);
 }

bool art::operator<	(	ProductProvenance const &	a,
		ProductProvenance const &	b
	)

inlinenoexcept

Definition at line 105 of file ProductProvenance.h.

References a, and b.

 {
   return a.productID() < b.productID();
 }

bool art::operator<	(	BranchDescription const &	a,
		BranchDescription const &	b
	)

bool art::operator<	(	ProductInfo const &	a,
		ProductInfo const &	b
	)

inline

Definition at line 44 of file ProductInfo.h.

References art::ProductInfo::consumableType_, art::ProductInfo::instance_, art::ProductInfo::label_, art::ProductInfo::process_, and art::ProductInfo::typeID_.

Referenced by art::BranchDescription::wrappedName().

   {
     return std::tie(
              a.consumableType_, a.typeID_, a.label_, a.instance_, a.process_) <
            std::tie(
              b.consumableType_, b.typeID_, b.label_, b.instance_, b.process_);
   }

bool art::operator<	(	ProcessConfiguration const &	a,
		ProcessConfiguration const &	b
	)

template<typename T , typename U >

std::enable_if_t<std::is_same<T, U>::value \|\| std::is_base_of<T, U>::value \|\| std::is_base_of<U, T>::value, bool> art::operator<	(	Ptr< T > const &	lhs,
		Ptr< U > const &	rhs
	)

bool art::operator<	(	TypeLabel const &	a,
		TypeLabel const &	b
	)

bool art::operator<	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		OutputFileStatus const	ofs
	)

inline

Definition at line 11 of file OutputFileStatus.h.

References Closed, art::errors::LogicError, Open, and Switching.

   {
     switch (ofs) {
       case OutputFileStatus::Open:
         return os << "Open";
       case OutputFileStatus::Switching:
         return os << "Switching";
       case OutputFileStatus::Closed:
         return os << "Closed";
       default:
         throw art::Exception{art::errors::LogicError,
                              "Unknown output file status."};
     }
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		SubRunID const &	iID
	)

std::ostream& art::operator<<	(	std::ostream &	ost,
		InputTag const &	tag
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		EventID const &	iID
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		const GroupSelector &	gs
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		art::RunID const &	iID
	)

std::ostream& art::operator<<	(	std::ostream &	,
		TypeID const &
	)

std::ostream & art::operator<<	(	std::ostream &	os,
		BranchMapper const &	p
	)

inline

Definition at line 67 of file BranchMapper.h.

References art::BranchMapper::write().

 {
   p.write(os);
   return os;
 }

std::ostream& art::operator<<	(	std::ostream &	os,
		BranchKey const &	bk
	)

std::ostream & art::operator<<	(	std::ostream &	os,
		ProductProvenance const &	p
	)

inline

Definition at line 111 of file ProductProvenance.h.

References art::ProductProvenance::write().

 {
   p.write(os);
   return os;
 }

std::ostream& art::operator<<	(	std::ostream &	os,
		BranchType const	branchType
	)

inline

Definition at line 29 of file BranchType.h.

References BranchTypeToString().

   {
     return os << BranchTypeToString(branchType);
   }

std::ostream& art::operator<<	(	std::ostream &	ost,
		art::ProcessHistory const &	ph
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		ParameterSetBlob const &	blob
	)

std::ostream & art::operator<<	(	std::ostream &	os,
		Provenance const &	p
	)

inline

Definition at line 162 of file Provenance.h.

References art::Provenance::write().

 {
   return p.write(os);
 }

std::ostream& art::operator<<	(	std::ostream &	os,
		BranchDescription const &	p
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		FileFormatVersion const &	ff
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		SampledEventInfo const &	eventInfo
	)

inline

Definition at line 43 of file SampledInfo.h.

References art::SampledEventInfo::dataset, art::SampledEventInfo::id, art::SampledEventInfo::probability, and art::SampledEventInfo::weight.

   {
     os << "Sampled EventID: '" << eventInfo.id << "'  Dataset: '"
        << eventInfo.dataset << "'  Weight: " << eventInfo.weight
        << "  Probability: " << eventInfo.probability;
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		MasterProductRegistry const &	mpr
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		Parentage const &
	)

inline

Definition at line 45 of file Parentage.h.

References a, b, and operator==().

   {
     // Unimplemented
     return os;
   }

template<typename T >

std::ostream& art::operator<<	(	std::ostream &	os,
		ServiceTable< T > const &	t
	)

inline

Definition at line 61 of file ServiceTable.h.

References gen_flatrecord::config, and confusionMatrixTree::t.

   {
     std::ostringstream config;
     t.print_allowed_configuration(config, std::string(3, ' '));
     return os << config.str();
   }

std::ostream& art::operator<<	(	std::ostream &	ost,
		const MallocOpts &
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		Granularity const &	b
	)

inline

Definition at line 62 of file OutputFileGranularity.h.

References b, art::Granularity::Event, art::Granularity::InputFile, art::Granularity::Job, art::Granularity::Run, art::Granularity::SubRun, and art::Granularity::Unset.

   {
     std::string token{"Unset"};
     switch (b()) {
       case Granularity::Event:
         token = "Event";
         break;
       case Granularity::SubRun:
         token = "SubRun";
         break;
       case Granularity::Run:
         token = "Run";
         break;
       case Granularity::InputFile:
         token = "InputFile";
         break;
       case Granularity::Job:
         token = "Job";
         break;
       case Granularity::Unset:;
     }
     os << token;
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		ProcessConfiguration const &	pc
	)

template<typename T >

std::ostream& art::operator<<	(	std::ostream &	os,
		ProducerBase::Table< T > const &	t
	)

inline

Definition at line 66 of file ProducerBase.h.

References gen_flatrecord::config, and confusionMatrixTree::t.

   {
     std::ostringstream config;
     t.print_allowed_configuration(config, std::string(3, ' '));
     return os << config.str();
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		suffix_type const	st
	)

inline

Definition at line 72 of file PluginSuffixes.h.

   {
     return os << static_cast<std::underlying_type_t<suffix_type>>(st);
   }

template<typename UserConfig , typename ImplicitConfig >

std::ostream& art::operator<<	(	std::ostream &	os,
		ProducerTable< UserConfig, ImplicitConfig > const &	t
	)

inline

Definition at line 73 of file ProducerTable.h.

References gen_flatrecord::config, and art::ProducerTable< UserConfig, ImplicitConfig, UserKeysToIgnore >::print_allowed_configuration().

   {
     std::ostringstream config;
     t.print_allowed_configuration(config, std::string(3, ' '));
     return os << config.str();
   }

template<typename PROD >

std::ostream & art::operator<<	(	std::ostream &	os,
		Handle< PROD > const &	h
	)

inline

Definition at line 296 of file DataViewImpl.h.

References make_syst_table_plots::h.

 {
   os << h.product() << " " << h.provenance() << " " << h.id();
   return os;
 }

std::ostream& art::operator<<	(	std::ostream &	os,
		BranchID const &	id
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		ProductID const	id
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		TypeLabel const &	tl
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		Level const	l
	)

inline

Definition at line 87 of file Level.h.

References Event, InputFile, Job, NumNestingLevels, ReadyToAdvance, Run, SubRun, and underlying_value().

   {
     switch (l) {
       case Level::Job:
         os << "Job";
         break;
       case Level::InputFile:
         os << "InputFile";
         break;
       case Level::Run:
         os << "Run";
         break;
       case Level::SubRun:
         os << "SubRun";
         break;
       case Level::Event:
         os << "Event";
         break;
       case Level::NumNestingLevels:
         os << underlying_value(Level::NumNestingLevels);
         break;
       case Level::ReadyToAdvance:
         os << "ReadyToAdvance";
         break;
     }
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		EventRange const &	r
	)

template<typename T >

std::ostream & art::operator<<	(	std::ostream &	os,
		Ptr< T > const &	p
	)

Definition at line 498 of file Ptr.h.

 {
   os << "(" << p.id() << ", " << p.key() << ")";
   return os;
 }

std::ostream& art::operator<<	(	std::ostream &	os,
		ProductMetaData const &	pmd
	)

inline

Definition at line 114 of file ProductMetaData.h.

References art::ProductMetaData::printBranchDescriptions().

   {
     pmd.printBranchDescriptions(os);
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		ModuleDescription const &	p
	)

inline

Definition at line 139 of file ModuleDescription.h.

References art::ModuleDescription::write().

   {
     p.write(os);
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		FileProperties const &	fp
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		RangeSet const &	rs
	)

std::ostream& art::operator<<	(	std::ostream &	ost,
		HLTGlobalStatus const &	hlt
	)

inline

Definition at line 176 of file HLTGlobalStatus.h.

References MECModelEnuComparisons::i, getGoodRuns4SAM::n, art::HLTGlobalStatus::size(), art::HLTGlobalStatus::state(), and MakeMiniprodValidationCuts::text.

   {
     std::vector<std::string> text(4);
     text[0] = "n";
     text[1] = "1";
     text[2] = "0";
     text[3] = "e";
     for (std::size_t i{}, n{hlt.size()}; i != n; ++i)
       ost << text.at(hlt.state(i));
     return ost;
   }

template<typename T >

std::ostream& art::operator<<	(	std::ostream &	os,
		EDAnalyzer::Table< T > const &	t
	)

inline

Definition at line 184 of file EDAnalyzer.h.

References gen_flatrecord::config, and confusionMatrixTree::t.

Referenced by operator!=(), and art::MallocOpts::operator!=().

   {
     std::ostringstream config;
     t.print_allowed_configuration(config, std::string(3, ' '));
     return os << config.str();
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		Group const &	g
	)

inline

Definition at line 198 of file Group.h.

References art::Group::write().

   {
     g.write(os);
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		FileIndex::Element const &	el
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		FileIndex const &	fileIndex
	)

template<int I>

std::ostream& art::operator<<	(	std::ostream &	os,
		Hash< I > const &	h
	)

inline

Definition at line 250 of file Hash.h.

References make_syst_table_plots::h.

   {
     return h.print(os);
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		MixHelper::Mode
	)

bool art::operator<=	(	ScheduleID	left,
		ScheduleID	right
	)

inline

Definition at line 130 of file ScheduleID.h.

 {
   return (left < right || left == right);
 }

bool art::operator<=	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

inline

Definition at line 203 of file FileIndex.h.

   {
     return !(rh < lh);
   }

bool art::operator==	(	art::ProcessHistory const &	a,
		art::ProcessHistory const &	b
	)

inline

Definition at line 161 of file ProcessHistory.h.

References art::ProcessHistory::data().

 {
   return a.data() == b.data();
 }

bool art::operator==	(	RefCore const &	lhs,
		RefCore const &	rhs
	)

inline

Definition at line 137 of file RefCore.h.

References art::RefCore::id().

 {
   return lhs.id() == rhs.id();
 }

bool art::operator==	(	BranchKey const &	a,
		BranchKey const &	b
	)

inline

Definition at line 76 of file BranchKey.h.

References a.

 {
   return !(a < b || b < a);
 }

bool art::operator==	(	FileFormatVersion const &	a,
		FileFormatVersion const &	b
	)

inline

Definition at line 28 of file FileFormatVersion.h.

References art::FileFormatVersion::value_.

   {
     return a.value_ == b.value_;
   }

bool art::operator==	(	ProductProvenance const &	a,
		ProductProvenance const &	b
	)

noexcept

bool art::operator==	(	art::Provenance const &	a,
		art::Provenance const &	b
	)

inline

Definition at line 168 of file Provenance.h.

References art::Provenance::equals().

Referenced by art::const_AssnsIter< L, R, D, Dir >::const_AssnsIter(), art::Ptr< T >::getData_(), operator<<(), and art::BranchDescription::wrappedName().

 {
   return a.equals(b);
 }

bool art::operator==	(	BranchDescription const &	a,
		BranchDescription const &	b
	)

bool art::operator==	(	Parentage const &	a,
		Parentage const &	b
	)

bool art::operator==	(	ProcessConfiguration const &	a,
		ProcessConfiguration const &	b
	)

template<typename T , typename U >

std::enable_if_t<std::is_same<T, U>::value \|\| std::is_base_of<T, U>::value \|\| std::is_base_of<U, T>::value, bool> art::operator==	(	Ptr< T > const &	lhs,
		Ptr< U > const &	rhs
	)

template<class X , class Y >

bool art::operator==	(	debugging_allocator< X > const &	,
		debugging_allocator< Y > const &
	)
throw	(
	)

Definition at line 100 of file debugging_allocator.h.

   {
     return true;
   }

bool art::operator==	(	RangeSet const &	l,
		RangeSet const &	r
	)

bool art::operator==	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

inline

Definition at line 209 of file FileIndex.h.

   {
     return !(lh < rh || rh < lh);
   }

bool art::operator>	(	ScheduleID	left,
		ScheduleID	right
	)

inline

Definition at line 136 of file ScheduleID.h.

References right().

Referenced by art::const_AssnsIter< L, R, D, Dir >::const_AssnsIter().

 {
   return !(left <= right);
 }

bool art::operator>	(	TypeID const &	a,
		TypeID const &	b
	)

inline

Definition at line 127 of file TypeID.h.

References a.

 {
   return b < a;
 }

bool art::operator>	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

inline

Definition at line 191 of file FileIndex.h.

   {
     return rh < lh;
   }

bool art::operator>=	(	ScheduleID	left,
		ScheduleID	right
	)

inline

Definition at line 142 of file ScheduleID.h.

References right().

Referenced by art::const_AssnsIter< L, R, D, Dir >::const_AssnsIter().

 {
   return !(left < right);
 }

bool art::operator>=	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

inline

Definition at line 197 of file FileIndex.h.

References rh.

   {
     return !(lh < rh);
   }

template<class A , class B >

std::enable_if_t< std::is_base_of< art::SelectorBase, A >::value &&std::is_base_of< art::SelectorBase, B >::value, art::OrHelper< A, B > > art::operator\|\|	(	A const &	a,
		B const &	b
	)

Definition at line 249 of file Selector.h.

References a, and b.

 {
   return art::OrHelper<A, B>(a, b);
 }

template<class T , class U >

std::enable_if_t<detail::are_handles<T, U>::value, bool> art::overlapping_ranges	(	T const &	a,
		U const &	b
	)

Referenced by overlapping_ranges(), art::ValidHandle< T >::swap(), art::detail::throw_if_invalid(), and art::SummedValue< T >::update_impl().

bool art::overlapping_ranges	(	RangeSet const &	l,
		RangeSet const &	r
	)

template<class T , class U >

bool art::overlapping_ranges	(	SummedValue< T > const &	a,
		SummedValue< U > const &	b
	)

Definition at line 189 of file SummedValue.h.

References overlapping_ranges(), and art::SummedValue< T >::rangeOfValidity().

   {
     return overlapping_ranges(a.rangeOfValidity(), b.rangeOfValidity());
   }

std::string art::parent_path ( std::string const & path )

Referenced by art::TFileService::fileNameAtOpen_(), and art::RootOutput::RootOutput().

template<typename T1 , typename T2 >

std::enable_if_t<std::is_same<T1, T2>::value \|\| std::is_base_of<T1, T2>::value \|\| std::is_base_of<T2, T1>::value, bool> art::pointersEqual	(	T1 *	t1,
		T2 *	t2
	)

inline

Definition at line 15 of file pointersEqual.h.

References t2.

   {
     return t1 == t2;
   }

template<typename T1 , typename T2 >

std::enable_if_t<!std::is_same<T1, T2>::value && !std::is_base_of<T1, T2>::value && !std::is_base_of<T2, T1>::value, bool> art::pointersEqual	(	T1 *	,
		T2 *
	)

Definition at line 26 of file pointersEqual.h.

References art::errors::LogicError.

   {
     throw art::Exception(art::errors::LogicError)
       << "Tried to compare two incompatible pointers.\n";
   }

void art::printArtException	(	cet::exception const &	e,
		char const *	prog = `0`
	)

void art::printBadAllocException ( char const * prog = 0 )

void art::printStdException	(	std::exception const &	e,
		char const *	prog = `0`
	)

void art::printUnknownException ( char const * prog = 0 )

std::string const& art::productProvenanceBranchName ( BranchType )

Referenced by art::RootOutputTree::RootOutputTree().

template<typename T , typename P >

std::enable_if_t<P::branch_type == InEvent \|\| P::branch_type == InResults> art::put_product_in_principal	(	std::unique_ptr< T > &&	product,
		P &	principal,
		std::string const &	module_label,
		std::string const &	instance_name = `{}`
	)

Referenced by daq2raw::BeamlineRawInputDriver::makeEvent(), rangeSetFor(), novaddt::NovaDDTRawInputDriver::readNext(), daq2raw::NOvARawInputDriver::readNext(), lem::GenFromLib::readNext(), daq2raw::NOvASocketInputDriver::readNext(), and daq2raw::TestBeamRawInputDriver::readNext().

template<typename T , typename P >

std::enable_if_t<P::branch_type == InSubRun \|\| P::branch_type == InRun> art::put_product_in_principal	(	std::unique_ptr< T > &&	product,
		P &	principal,
		std::string const &	module_label,
		std::string const &	instance_name = `{}`,
		RangeSet &&	= `RangeSet::invalid()`
	)

template<class T >

std::enable_if_t<detail::is_handle<T>::value, RangeSet const&> art::range_of_validity ( T const & h )

Referenced by art::ValidHandle< T >::swap(), and art::detail::throw_if_invalid().

RangeSet art::rangeSetFor ( RunPrincipal const & rp )

inline

Definition at line 45 of file put_product_in_principal.h.

References art::RangeSet::forRun(), and art::RunPrincipal::id().

Referenced by rangeSetFor().

   {
     return RangeSet::forRun(rp.id());
   }

RangeSet art::rangeSetFor ( SubRunPrincipal const & srp )

inline

Definition at line 51 of file put_product_in_principal.h.

References art::RangeSet::forSubRun(), art::SubRunPrincipal::id(), InEvent, InResults, InRun, InSubRun, art::errors::NullPointerError, P, art::productstatus::present(), stan::io::product(), art::BranchDescription::productID(), put_product_in_principal(), rangeSetFor(), and T.

   {
     return RangeSet::forSubRun(srp.id());
   }

void art::reenableSigs ( sigset_t * oldset )

std::vector<std::vector<std::string>::const_iterator> art::regexMatch	(	std::vector< std::string > const &	strings,
		std::regex const &	regexp
	)

std::vector<std::vector<std::string>::const_iterator> art::regexMatch	(	std::vector< std::string > const &	strings,
		std::string const &	pattern
	)

template<class L , class R , class D , Direction Dir>

constexpr auto const& art::right	(	const_AssnsIter< L, R, D, Dir > const &	a,
		const_AssnsIter< L, R, D, Dir > const &	b
	)

Definition at line 112 of file AssnsIter.h.

References a, and Forward.

Referenced by auto_legend(), CrossCheckDiag(), drawLabels(), novaddt::RateMonitor::endJob(), lem::dec::Forest::FromFile(), genie_syst_universe(), MarshaledObj::isUnmarshaling(), jointsensitivity(), cmf::StarPlot::MakeStarPlot(), fnex::StarPlot::MakeStarPlot(), Nue2018ThreeBinAxis_Reduced(), ana::Nue2018ThreeBinAxis_Reduced(), operator!=(), art::SortInvalidFirst< T >::operator()(), art::const_AssnsIter< L, R, D, Dir >::operator<(), rawdata::operator<<(), caldp::operator<<(), fnex::operator<<(), cmf::operator<<(), sim::operator<<(), rb::operator<<(), art::const_AssnsIter< L, R, D, Dir >::operator<=(), operator>(), art::const_AssnsIter< L, R, D, Dir >::operator>(), operator>=(), art::const_AssnsIter< L, R, D, Dir >::operator>=(), plot_datamcpred(), genie::geometry::PathSegment::Print(), calib::CalibAna::PrintHit(), stan::mcmc::chains< RNG >::quantile(), stan::mcmc::chains< RNG >::quantiles(), stan::io::stan_csv_reader::read_samples(), remakeresultsplots_nue(), boost::python::detail::proxy_group< Proxy >::replace(), set_labels_1D(), set_labels_2D(), and lem::dec::Forest::TrainSingleTransformed().

   {
     return (Dir == Direction::Forward) ? b : a;
   }

int art::run_art	(	int	argc,
		char **	argv,
		bpo::options_description &	all_desc,
		cet::filepath_maker &	lookupPolicy,
		art::OptionsHandlers &&	handlers
	)

int art::run_art_common_ ( fhicl::ParameterSet const & main_pset )

int art::run_art_string_config ( std::string const & config_string )

constexpr auto art::runFragment ( )

Definition at line 33 of file ProductSemantics.h.

   {
     return FragmentSemantic<Level::Run>{};
   }

auto art::runFragment ( RangeSet const & rs )

inline

Definition at line 44 of file ProductSemantics.h.

   {
     return RangedFragmentSemantic<Level::Run>{rs};
   }

template<class T , class U >

std::enable_if_t<detail::are_handles<T, U>::value, bool> art::same_ranges	(	T const &	a,
		U const &	b
	)

Referenced by same_ranges(), art::ValidHandle< T >::swap(), art::detail::throw_if_invalid(), and art::SummedValue< T >::update_impl().

bool art::same_ranges	(	RangeSet const &	l,
		RangeSet const &	r
	)

template<class T , class U >

bool art::same_ranges	(	SummedValue< T > const &	a,
		SummedValue< U > const &	b
	)

Definition at line 175 of file SummedValue.h.

References art::SummedValue< T >::rangeOfValidity(), and same_ranges().

   {
     return same_ranges(a.rangeOfValidity(), b.rangeOfValidity());
   }

auto art::sampled_from ( std::string process_name )

inline

Definition at line 110 of file Sampled.h.

   {
     return process_name.insert(0, "SampledFrom");
   }

template<class COLLECTION >

void art::setPtr	(	COLLECTION const &	coll,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

template<typename T >

void art::setPtr	(	cet::map_vector< T > const &	obj,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 52 of file setPtr.h.

References ana::assert(), cet::map_vector< Value >::end(), cet::map_vector< Value >::findOrThrow(), it, art::detail::value_type_helper::look_past_pair(), art::detail::maybeCastObj(), elec2geo::pos, art::detail::value_type_helper::starts_with_pair(), T, and uniform_type_name().

 {
   detail::value_type_helper vh;
   std::string const wanted_type =
     uniform_type_name(cet::demangle_symbol(iToType.name()));
   static size_t pos = vh.look_past_pair<T>();
   auto const it = obj.findOrThrow(cet::map_vector_key{iIndex});
   assert(it != obj.end());
   if ((pos < wanted_type.size()) && vh.starts_with_pair(wanted_type, pos)) {
     // Want value_type, not mapped_type;
     oPtr = detail::maybeCastObj(&*it, iToType);
   } else {
     oPtr = detail::maybeCastObj(&it->second, iToType);
   }
 }

void art::setRootErrorHandler ( bool want_custom )

void art::setupSignals ( bool want_sigint_enabled )

void art::sigInventory ( )

template<Direction Dir>

constexpr int art::signed_one ( )

Definition at line 28 of file AssnsIter.h.

   {
     return static_cast<std::underlying_type_t<Direction>>(Dir);
   }

constexpr auto art::subRunFragment ( )

Definition at line 38 of file ProductSemantics.h.

   {
     return FragmentSemantic<Level::SubRun>{};
   }

auto art::subRunFragment ( RangeSet const & rs )

inline

Definition at line 49 of file ProductSemantics.h.

   {
     return RangedFragmentSemantic<Level::SubRun>{rs};
   }

void art::swap	(	art::ProcessHistory &	a,
		art::ProcessHistory &	b
	)

inline

Definition at line 155 of file ProcessHistory.h.

References art::ProcessHistory::swap().

 {
   a.swap(b);
 }

void art::swap	(	TypeID &	left,
		TypeID &	right
	)

inline

Definition at line 139 of file TypeID.h.

References art::TypeID::swap().

 {
   left.swap(right);
 }

void art::swap	(	art::RefCore &	lhs,
		art::RefCore &	rhs
	)

inline

Definition at line 155 of file RefCore.h.

References art::RefCore::swap().

 {
   lhs.swap(rhs);
 }

template<typename T >

void art::swap	(	PtrVector< T > &	lhs,
		PtrVector< T > &	rhs
	)

inline

Definition at line 599 of file PtrVector.h.

References art::PtrVector< T >::swap().

 {
   lhs.swap(rhs);
 }

void art::swap	(	Provenance &	x,
		Provenance &	y
	)

template<class T >

void art::swap	(	Handle< T > &	a,
		Handle< T > &	b
	)

Referenced by art::Assns< L, R, void >::swap_(), and art::BranchDescription::wrappedName().

template<class T >

void art::swap	(	ValidHandle< T > &	a,
		ValidHandle< T > &	b
	)

void art::swap	(	TriggerResults &	lhs,
		TriggerResults &	rhs
	)

inline

Definition at line 70 of file TriggerResults.h.

References art::TriggerResults::swap().

   {
     lhs.swap(rhs);
   }

void art::swap	(	OutputHandle &	a,
		OutputHandle &	b
	)

inline

Definition at line 110 of file OutputHandle.h.

References art::OutputHandle::swap().

   {
     a.swap(b);
   }

void art::swap	(	HLTGlobalStatus &	lhs,
		HLTGlobalStatus &	rhs
	)

inline

Definition at line 169 of file HLTGlobalStatus.h.

References art::HLTGlobalStatus::swap().

   {
     lhs.swap(rhs);
   }

template<int I>

void art::swap	(	Hash< I > &	a,
		Hash< I > &	b
	)

inline

Definition at line 243 of file Hash.h.

References art::Hash< I >::swap().

   {
     a.swap(b);
   }

void art::throw_if_not_disjoint	(	RunNumber_t const	rn,
		EventRange const &	left,
		EventRange const &	right
	)

noexcept

std::string art::to_string ( ModuleType mt )

inline

Definition at line 32 of file ModuleType.h.

References ANALYZER, FILTER, art::errors::LogicError, NON_ART, OUTPUT, and PRODUCER.

Referenced by ValidCalibPDF::AbsoluteCalibration(), accum_nue_numu_equivalent(), mono::Monopole::analyze(), cmf::CovarianceMatrixDecorrelator::beginJob(), mono::Monopole::beginJob(), CalculateXSec(), check_predinterp_numu(), ana::OscCovMxExperiment::ChiSq(), CombineHistograms(), compare_fits(), daqdataformats::DataFormatException::constructMessage(), ana::SpectrumHandler::CreateSpectrums(), CutFlow_NearDet(), DDTOnMonPlotMaker(), demo_numuOnly(), demoFitContours(), ValidCalibPDF::DiblockTex(), nueccinc_test::NueCCIncGlobalFitter::doFullFit(), draw_fn_coverage(), draw_percentiles(), DrawSurface(), ana::CovMxSurface::DrawSurfacePoint(), DrawSurfacePoint(), drawSystsShiftingNDdata(), MEUPerCell::DriftTex(), MEUPerFEB::DriftTex(), ValidCalibPDF::DriftTex(), electron_energy_bias(), novarwgt::EncodeGeneratorVersion(), ErrorBand(), ValidCalibPDF::EssentialComparisonTex(), Expression::Eval(), fake_future_data(), fcn_enu(), fcn_q2(), FillHists(), BrightnessModelPlots::FillHitPlots(), MEUPerCell::FillHitPlots(), MEUPerFEB::FillHitPlots(), ValidCalibPDF::FillHitPlots(), FillPCAContainers(), generate_fake_data(), generate_fc_binlists(), generate_fd_fake_events(), genie::NNBarOscPrimaryVtxGenerator::GenerateDecayProducts(), genie_contours(), genie_preds_make(), genie_syst_make(), genie_syst_pca(), genie_syst_shifts(), get_eventslist(), GetBinByEdge(), calib::AttenCache::GetCSVPath(), GetExtrapolationDefs(), novarwgt::internal::GetGenieKnobName(), ana::GetGeniePrincipals2018(), ana::GetGeniePrincipals2018Small(), ana::GetGeniePrincipals2020Small(), GetMockData(), ana::getNumu2018PredVar(), GetNumuCosmics2017(), GetNumuCosmics2018(), GetNumuCosmics2019(), ana::GetNumuCosmics2020(), GetNumuCosmicsFuture(), GetNumuData2017(), GetNumuData2018(), GetNumuData2019(), ana::GetNumuData2020(), GetNumuPredictionsFuture(), GetSliceHist(), ana::SpectrumHandler::Go(), goodness_of_fit(), grabNuMuHistograms(), GraphsToDataRelease(), hadEFrac_nd_data_mc_systs(), HCtag(), fhicl::Name::index(), cet::name_of< T[N]>::is(), joint_fit_2017_contours(), joint_fit_2017_fc_submit(), joint_fit_2017_make_fc_slice(), joint_fit_2017_make_fc_surf(), joint_fit_2018_contours(), joint_fit_2019_bestfit(), joint_fit_2019_contours(), joint_fit_2019_slices(), joint_fit_future_bestfit_univ(), joint_fit_future_contour_univ(), cet::sqlite::SelectStmt::limit(), LoadFakeData(), LoadFile_GetHists(), ana::TrivialBkgdEstimator::LoadFrom(), ana::FitInAnaBinsBkgdEstimator::LoadFrom(), ana::NumuCC2p2hBkgdEstimator::LoadFrom(), ana::FluxMultiverseSyst::LoadFrom(), ana::PredictionScaleComp::LoadFrom(), ana::GenieMultiverseSpectra::LoadFrom(), ana::nueccinc::NueCCIncCrossSectionTemplates::LoadFrom(), ana::nueccinc::NueCCIncEnhancedSamples::LoadFrom(), ana::GenieMultiverseNormalizedSpectra::LoadFrom(), LoadPPFX(), ana::LoadPredictions(), make_contours(), make_DataMCComp_numu(), make_fc_mass_and_oct_nersc_2018(), make_fc_mass_and_oct_nersc_2019(), make_fc_mh_nersc_2018(), make_fc_mh_nersc_2019(), make_fc_nus_surfs_nersc_2018(), make_fc_nus_surfs_nersc_2019(), make_fc_oct_nersc_2018(), make_fc_oct_nersc_2019(), make_fc_slices_nersc_2018(), make_fc_slices_nersc_2018_stats(), make_fc_slices_nersc_2019(), make_fc_surfaces_2020(), make_fc_surfaces_2020_validation(), make_fc_surfaces_nersc_2018(), make_fc_surfaces_nersc_2018_stats(), make_fc_surfaces_nersc_2019(), make_muonid_opt(), Make_NuMuCC_Inc_XS_v2(), make_nus17_fc_surfs(), make_nus17_pot(), make_nus_fc_surfs(), make_training_sample(), make_vertex_optimiz(), MakeCSV(), ana::MakeCutVec(), MakeFakeData(), MakePlot(), MakePlots1D(), MakePPFXRatios(), MakeRatio(), MakeStackNME(), MakeSuffix(), MakeSurface(), MakeSystematicPlots(), MEUPerFEB::MakeTex(), cmf::RandomUniverses::MakeUniverseHistograms(), MakeVennDiagram(), mec_tuning_fitter_2020(), mec_tuning_preds_2020(), median_contours(), mre_blessed(), muonid_opt(), ND_DataMC_Comp_Systs(), nova_t2k_comparison(), nuebar_signif(), OverlayGenerators(), calib::PCHitTransposer::PCHitTransposer(), Plot_Evals_BDTMLP_Algs(), plot_joint_fit_2020_contours(), plot_nd_spectra_2018(), plot_recoE_numu(), plot_uncertainty(), PlotCSV(), PlotDeltaFractionVsSignificance(), PlotDeltaFractionVsYear(), PlotGenRatios(), PlotSignificanceVsYear_FixDelta(), PlotSignificanceVsYear_FixTh23(), Plotting_Data2DataComp_SingleCanvas(), Plotting_DataAndPrediction(), Plotting_DataSpectra_MakeTGraph(), PlotXSec(), evd::SliceNavigator::postProcessEvent(), ppfx_smooth_weights_make(), ppfx_smooth_weights_save(), ppfx_syst_pca_fn(), ana::PredictionSyst3Flavor2020::PredictionSyst3Flavor2020(), ana::PredictionSystJoint2018::PredictionSystJoint2018(), ana::PredictionSystJointDemo::PredictionSystJointDemo(), ana::PredictionSystNumu2017::PredictionSystNumu2017(), prepareFactory(), PrintAllSlices(), prob_biprob_pedagogical(), calib::PCHitTransposer::produce(), ProducePlots(), fhicl::intermediate_table::put(), Plotter::q0q3Panel(), reach_2018_dCPfractions(), reduce_the_predfile_nue_numu(), resolution2018(), ResolutionPlot(), nerd::NERDEval::run_graph(), run_joint_fit_2020_bestfit(), run_joint_fit_2020_contours(), SavePCAShifts(), ana::TrivialBkgdEstimator::SaveTo(), ana::FitInAnaBinsBkgdEstimator::SaveTo(), ana::NumuCC2p2hBkgdEstimator::SaveTo(), ana::FluxMultiverseSyst::SaveTo(), ana::PredictionScaleComp::SaveTo(), ana::GenieMultiverseSpectra::SaveTo(), ana::DataMCPair::SaveTo(), ana::nueccinc::NueCCIncCrossSectionTemplates::SaveTo(), ana::nueccinc::NueCCIncEnhancedSamples::SaveTo(), LSTME::ProngBPFVars::saveToDict(), MEUPerFEB::SchedulePlots(), MEUPerCell::SchedulePlots(), ValidCalibPDF::SchedulePlots(), evgen::GENIENeutronOscGen::selectAnnihilationMode(), SelectAnnihilationMode(), sensitivity_plot(), ana::SpectrumHandler::SetSpillCuts(), cet::search_path::showenv(), specprod_numuccinc(), SplitFakeData(), SplitHistograms(), novarwgt::StoredGenSupportCfg(), systematics_summary_from_pred_interp(), systematics_table_from_pred_interp(), tmva_new_train(), train(), trimmubarid(), Tutorial2019Fit(), Tutorial2019FitContours(), Tutorial2019FitSlices(), uncertainty1png(), uncertainty2png(), UnfoldGenie(), UnfoldInOut(), UnfoldMethodRooUnfold(), UnfoldPPFX(), UnfoldXSec(), vertex_optimize(), moonshadowana::MoonShadowAna::WriteEventInfo(), moonshadowana::MoonShadowAnaHough::WriteEventInfo(), cvn::CVNEventDump::WriteMapTH2(), cvn::CVNCosmicEventDump::WriteMapTH2(), and cvn::CVNEventProngDump::WriteMapTH2().

 {
   switch (mt) {
     case ModuleType::NON_ART:
       return "non-art";
     case ModuleType::ANALYZER:
       return "analyzer";
     case ModuleType::FILTER:
       return "filter";
     case ModuleType::PRODUCER:
       return "producer";
     case ModuleType::OUTPUT:
       return "output module";
     default:
       throw Exception(errors::LogicError)
         << "Unable to find string for unrecognized ModuleType value "
         << static_cast<int>(mt) << ".\n";
   }
 }

std::string art::translateFileDeliveryStatus ( FileDeliveryStatus stat )

std::string art::translateFileDisposition ( FileDisposition fd )

std::string art::translateFileTransferStatus ( FileTransferStatus stat )

constexpr auto art::underlying_value ( Level const l )

noexcept

Definition at line 25 of file Level.h.

References submit_hadd::l.

Referenced by is_above_most_deeply_nested_level(), is_level_contained_by(), level_down(), level_up(), and operator<<().

   {
     return static_cast<std::underlying_type_t<Level>>(l);
   }

std::string art::uniform_type_name ( std::type_info const & tid )

inline

Definition at line 36 of file uniform_type_name.h.

Referenced by getElementAddresses(), and setPtr().

 {
   return uniform_type_name(cet::demangle_symbol(tid.name()));
 }

std::string art::uniform_type_name ( std::string name )

Parameters

[in] name The already-demangled name for a type.

std::string art::unique_filename	(	std::string	stem,
		std::string	extension = `".root"`
	)

Referenced by art::RootOutput::fileNameAtOpen(), and art::TFileService::fileNameAtOpen_().

void art::unloadRootSigHandler ( )

std::string art::wrappedClassName ( std::string const & iFullName )

Variable Documentation

debugvalue art::debugit

std::atomic<int> art::shutdown_flag

std::mutex art::usr2_lock

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation