CMS 3D CMS Logo

Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
edm Namespace Reference

HLT enums. More...

Namespaces

 clonehelper
 
 convertException
 
 detail
 
 details
 
 detailsTrie
 
 dqh
 
 dsrvdetail
 
 edmmltest
 
 errors
 
 es
 
 eventsetup
 
 evtSel
 
 exception_actions
 
 extensioncord
 
 fillDetails
 
 friendlyname
 
 global
 
 graph
 
 handleimpl
 
 hash_detail
 
 helper
 
 helpers
 
 hlt
 
 impl
 
 limited
 
 maker
 
 math_private
 
 messagedrop
 
 MixingCache
 
 module
 
 multicore
 
 one
 
 pathStatusExpression
 
 pdtentry
 
 poolNames
 
 principal_get_adapter_detail
 
 producerbasehelper
 
 productholderindexhelper
 
 pset
 
 python
 
 rec_dep
 
 refcore
 
 refcoreimpl
 
 refhelper
 
 refitem
 
 reftobase
 
 releaseversion
 
 root
 
 roottree
 
 service
 
 serviceregistry
 
 signalslot
 
 soa
 
 soahelper
 
 storage
 
 stream
 
 test
 
 threadLocalException
 
 typelookup
 
 waitingtask
 
 workerhelper
 
 workerimpl
 
 writeParameterValue
 

Classes

struct  Accumulator
 
class  ActivityRegistry
 
class  Adjuster
 
class  AdjusterBase
 
class  AliasProductResolver
 
class  AllowedLabelsDescription
 
class  AllowedLabelsDescription< ParameterSetDescription >
 
class  AllowedLabelsDescription< std::vector< ParameterSet > >
 
class  AllowedLabelsDescriptionBase
 
class  AnalyzerWrapper
 
class  ANDGroupDescription
 
class  AsciiOutputModule
 
class  AssertHandler
 
class  Association
 
class  AssociationMap
 
class  AssociationVector
 
class  AssociativeIterator
 
class  atomic_value_ptr
 
struct  atomic_value_ptr_traits
 
class  AtomicPtrCache
 
class  BaseFlatGunProducer
 
class  BaseRandomtXiGunProducer
 
class  BaseWithDict
 
class  BasicAnalyzer
 
class  BasicHandle
 
class  BeamHaloProducer
 
struct  BeginLuminosityBlockProducer
 
struct  BeginRunProducer
 
class  BMixingModule
 
class  BoolCache
 
class  BranchChildren
 
class  BranchDescription
 
class  BranchID
 
class  BranchIDListHelper
 
class  BranchKey
 
struct  BranchToCount
 
class  BunchCrossingFilter
 
class  CallNTimesNoWait
 
class  CallOnceNoWait
 
class  CFWriter
 
struct  CheckAbility
 
struct  CheckAbility< ABILITY >
 
struct  CheckAbility< ABILITY, T, VArgs... >
 
struct  ClonePolicy
 
class  CloningPtr
 
class  Comment
 
struct  CommonParams
 
class  Compare_Index
 
class  Compare_Index_Run
 
class  Compare_Run_Lumi_EventEntry
 
struct  CompareRefDetSet
 
class  ConditionsInEventBlock
 
class  ConditionsInLumiBlock
 
class  ConditionsInRunBlock
 
class  ConfigurationDescriptions
 
struct  ConfigurationHandshake
 
class  ConstProductRegistry
 
class  ConstPtrCache
 
class  ConstRespectingPtr
 
class  ConsumesCollector
 
class  ConsumesInfo
 
class  ContainerMask
 
class  ContainerMaskTraits
 
class  ContainerMaskTraits< edmNew::DetSetVector< T > >
 
struct  CopyPolicy
 
class  CosMuoGenProducer
 
class  CountAndLimit
 
class  CPUServiceBase
 
class  CPUTimer
 
class  CurrentModuleOnThread
 
class  CustomStreamer
 
struct  DaqProvenanceHelper
 
class  DataFrame
 
class  DataFrameContainer
 
class  DataManagingProductResolver
 
class  DataMixingEMDigiWorker
 
class  DataMixingEMWorker
 
class  DataMixingGeneralTrackWorker
 
class  DataMixingHcalDigiWorker
 
class  DataMixingHcalDigiWorkerProd
 
class  DataMixingHcalWorker
 
class  DataMixingModule
 
class  DataMixingMuonWorker
 
class  DataMixingPileupCopy
 
class  DataMixingSiPixelWorker
 
class  DataMixingSiStripRawWorker
 
class  DataMixingSiStripWorker
 
class  debugging_allocator
 
struct  debugvalue
 
class  DefaultRunHelper
 
class  DelayedReader
 
class  DescriptionFillerForESProducers
 
class  DescriptionFillerForESSources
 
class  DescriptionFillerForServices
 
class  DetSet
 
class  DetSetRefVector
 
class  DetSetVector
 
class  DigiAccumulatorMixModFactory
 
struct  do_nothing_deleter
 
class  DocFormatHelper
 
struct  DoNotPostInsert
 
struct  DoNotRecordParents
 
struct  DoNotSortUponInsertion
 
struct  DoPostInsert
 
class  DummyProvenanceReader
 
class  DummyVT
 
class  DuplicateChecker
 
class  DuplicateTreeSentry
 
class  EarlyDeleteHelper
 
class  EcalNoiseStorage
 
class  EDAnalyzer
 
class  EDCollection
 
class  EDConsumerBase
 
class  EDFilter
 
class  EDGetToken
 
class  EDGetTokenT
 
class  EDLooper
 
class  EDLooperBase
 
class  EdmEventItemGetter
 Helper class that fetches some type of Ref given ProductID and index, using the edm::Event. More...
 
class  EDProducer
 
class  EDProductGetter
 
class  EDPutToken
 
class  EDPutTokenT
 
class  ELextendedID
 
class  ELseverityLevel
 
struct  ELslProxy
 
class  EmbeddedRootSource
 
class  EmptyESSource
 
class  EmptyGroupDescription
 
class  EmptySource
 
class  EmptyWaitingTask
 
struct  EndLuminosityBlockProducer
 
class  EndPathStatus
 
class  EndPathStatusInserter
 
struct  EndRunProducer
 
class  Entry
 
class  ErrorObj
 
struct  ErrorSummaryEntry
 
class  ESHandle
 
class  ESHandleBase
 
class  ESHandleExceptionFactory
 
class  ESInputTag
 
class  ESOutlet
 
class  ESProducer
 
class  ESProducerLooper
 
struct  ESProducts
 
class  ESProxyFactoryProducer
 
class  ESRecordAuxiliary
 
class  ESTransientHandle
 
class  ESWatcher
 
class  Event
 
class  EventAcquireSignalsSentry
 
class  EventAux
 
class  EventAuxiliary
 
class  EventAuxiliaryHistoryProducer
 
class  EventBase
 
class  EventContentAnalyzer
 
class  EventEntryDescription
 
class  EventEntryInfo
 
class  EventForOutput
 
class  EventID
 
class  EventPrincipal
 
class  EventProcessHistoryID
 
class  EventProcessor
 
class  EventRange
 
class  EventSelector
 
class  EventSetup
 
class  EventSetupCacheIdentifierChecker
 
class  EventSetupRecordDataGetter
 
class  EventSetupRecordIntervalFinder
 
class  EventSignalsSentry
 
class  EventSkipperByID
 
struct  EventSummary
 
class  EventTime
 
struct  EventTimingSummary
 
class  Exception
 
class  ExceptionCollector
 
class  ExceptionToActionTable
 
class  ExpoRandomPGunProducer
 
class  ExpoRandomPtGunProducer
 
class  ExtensionCord
 
struct  ExternalWork
 
class  Factory
 
class  FileBlock
 
class  FileCatalogItem
 
class  FileFormatVersion
 
class  FileID
 
class  FileIndex
 
class  FileInPath
 
class  FileLocator
 
class  FileRandomKEThetaGunProducer
 
struct  FilledProductPtr
 
class  FilterObjectWrapper
 
class  FilterValueMapWrapper
 
class  FilterWrapper
 
class  FixedPUGenerator
 
class  FlatBaseThetaGunProducer
 
class  FlatEGunASCIIWriter
 
class  FlatRandomEGunProducer
 
class  FlatRandomEThetaGunProducer
 
class  FlatRandomMultiParticlePGunProducer
 
class  FlatRandomOneOverPtGunProducer
 
class  FlatRandomPtAndDxyGunProducer
 
class  FlatRandomPtGunProducer
 
class  FlatRandomPtThetaGunProducer
 
class  FromFiles
 
class  FullProvenanceReader
 
class  FunctionWithDict
 
class  FunctorESHandleExceptionFactory
 
class  FunctorHandleExceptionFactory
 
class  FunctorTask
 
class  FunctorWaitingTask
 
class  FwdPtr
 
class  FwdPtrCollectionFilter
 Selects a list of FwdPtr's to a product T (templated) that satisfy a method S(T) (templated). Can also handle input as View<T>. Can also have a factory class to create new instances of clones if desired. More...
 
class  FwdPtrFromProductFactory
 
class  FwdPtrProducer
 Produces a list of FwdPtr's to an input collection. More...
 
class  FwdRef
 
struct  FWGenericObject
 This class is just a 'tag' used to allow a specialization of edm::Handle. More...
 
class  FWLiteFilterWrapper
 
class  GaussRandomPThetaGunProducer
 
class  GeneratorFilter
 
struct  GenericObject
 This class is just a 'tag' used to allow a specialization of edm::Handle. More...
 
class  GenericSelectorByValueMap
 
class  GenHIEvent
 
class  GetProductCheckerOutputModule
 
class  GetterOfProducts
 
struct  GlobalCache
 
class  GlobalContext
 
class  GlobalSchedule
 
class  Guid
 
class  HadronizerFilter
 
class  Handle
 
class  Handle< FWGenericObject >
 
class  Handle< GenericObject >
 
class  HandleBase
 
class  HandleExceptionFactory
 
struct  has_fillView
 
struct  has_fillView< AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > >
 
struct  has_fillView< edm::DetSetVector< T > >
 
struct  has_fillView< edm::OwnArray< T, M, P > >
 
struct  has_fillView< edm::OwnVector< T, P > >
 
struct  has_fillView< edm::SortedCollection< T, SORT > >
 
struct  has_fillView< PtrVector< T > >
 
struct  has_fillView< RefToBaseVector< T > >
 
struct  has_fillView< RefVector< C, T, F > >
 
struct  has_fillView< std::deque< T, A > >
 
struct  has_fillView< std::list< T, A > >
 
struct  has_fillView< std::set< T, A > >
 
struct  has_fillView< std::vector< bool, A > >
 
struct  has_fillView< std::vector< T, A > >
 
struct  has_setPtr
 
struct  has_setPtr< edm::OwnArray< T, M, P > >
 
struct  has_setPtr< edm::OwnVector< T, P > >
 
struct  has_setPtr< edm::SortedCollection< T, SORT > >
 
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  HasAbilityToProduceInLumis
 
struct  HasAbilityToProduceInRuns
 
class  Hash
 
class  HcalNoiseStorage
 
class  HepMCProduct
 
class  HiMixingModule
 
class  HiMixingWorker
 
class  HiMixingWorkerBase
 
class  History
 
class  HistoryAppender
 
class  HLTGlobalStatus
 
class  HLTPathStatus
 
class  IDVectorMap
 
class  IfExistsDescription
 
class  IllegalParameters
 
class  IndexIntoFile
 
class  IndexSet
 
class  InputAnalyzer
 
class  InputFile
 
class  InputFileCatalog
 
class  InputProductResolver
 
class  InputSource
 
struct  InputSourceDescription
 
class  InputSourceFactory
 
class  InputTag
 
class  InputTagMatch
 
class  InternalContext
 
class  IOVSyncValue
 
class  IterateNTimesLooper
 
class  IterWithDict
 
class  IterWithDictBase
 
class  JobReport
 
struct  key_traits
 
struct  key_traits< std::pair< U, V > >
 
struct  key_traits< std::string >
 
struct  LHEProvenanceHelper
 
class  LimitAndTimespan
 
class  LimitedTaskQueue
 
class  LogAbsolute
 
class  LogDebug_
 
class  LogError
 
class  LogErrorHarvester
 
class  LogImportant
 
class  LogInfo
 
class  LogPrint
 
class  LogProblem
 
class  LogSystem
 
class  LogTrace_
 
class  LogVerbatim
 
class  LogWarning
 
class  Lumi3DReWeighting
 
class  LuminosityBlock
 
class  LuminosityBlockAux
 
class  LuminosityBlockAuxiliary
 
class  LuminosityBlockBase
 
struct  LuminosityBlockCache
 
class  LuminosityBlockForOutput
 
class  LuminosityBlockID
 
class  LuminosityBlockIndex
 
class  LuminosityBlockPrincipal
 
class  LuminosityBlockProcessingStatus
 
class  LuminosityBlockRange
 
struct  LuminosityBlockSummaryCache
 
class  LumiReWeighting
 
struct  MainParameterSet
 
class  MakeDummyProvenanceReader
 
class  MakeFullProvenanceReader
 
class  MakeModuleHelper
 
class  MakeModuleHelper< edm::stream::EDAnalyzerAdaptorBase >
 
class  MakeModuleHelper< edm::stream::EDFilterAdaptorBase >
 
class  MakeModuleHelper< edm::stream::EDProducerAdaptorBase >
 
struct  MakeModuleParams
 
class  MakeOldProvenanceReader
 
class  MakeProvenanceReader
 
class  Maker
 
class  MakeReducedProvenanceReader
 
class  MallocOptionSetter
 
struct  MallocOpts
 
class  MapOfVectors
 
class  MCFileSource
 
class  MemberWithDict
 
struct  MergeableCounter
 
struct  MessageDrop
 
class  MessageLoggerQ
 
class  MessageSender
 
class  MixingModule
 
class  MixingWorker
 
class  MixingWorkerBase
 
class  ModelFilter
 
class  ModuleCallingContext
 
class  ModuleChanger
 
class  ModuleContextSentry
 
class  ModuleDescription
 
struct  ModuleInPathSummary
 
struct  ModuleInPathTimingSummary
 
class  ModuleLabelMatch
 
class  ModuleRegistry
 
class  ModuleTime
 
class  ModuloEventIDFilter
 
class  ModuloStreamIDFilter
 
class  MultiAssociation
 
class  MultiParticleInConeGunProducer
 
class  MultipleException
 
class  NavigateEventsLooper
 
struct  NewPolicy
 
class  NoProcessProductResolver
 
class  ObjectWithDict
 
class  OccurrenceForOutput
 
class  OccurrenceTraits
 
class  OccurrenceTraits< EventPrincipal, BranchActionStreamBegin >
 
class  OccurrenceTraits< LuminosityBlockPrincipal, BranchActionGlobalBegin >
 
class  OccurrenceTraits< LuminosityBlockPrincipal, BranchActionGlobalEnd >
 
class  OccurrenceTraits< LuminosityBlockPrincipal, BranchActionStreamBegin >
 
class  OccurrenceTraits< LuminosityBlockPrincipal, BranchActionStreamEnd >
 
class  OccurrenceTraits< RunPrincipal, BranchActionGlobalBegin >
 
class  OccurrenceTraits< RunPrincipal, BranchActionGlobalEnd >
 
class  OccurrenceTraits< RunPrincipal, BranchActionStreamBegin >
 
class  OccurrenceTraits< RunPrincipal, BranchActionStreamEnd >
 
class  OffsetToBase
 
class  OldProvenanceReader
 
class  OneLumiPoolSource
 
class  OneToMany
 
class  OneToManyWithQuality
 
class  OneToManyWithQualityGeneric
 
class  OneToOne
 
class  OneToOneGeneric
 
class  OneToValue
 
class  ORGroupDescription
 
class  OrphanHandle
 
class  OrphanHandleBase
 
class  OStreamColumn
 
struct  OStreamColumnEntry
 
struct  Other
 
class  OutletBase
 
class  OutputModule
 
class  OutputModuleCommunicator
 
class  OutputModuleCommunicatorT
 
struct  OutputModuleDescription
 
class  OwnArray
 
class  OwnVector
 
class  ParameterDescription
 
class  ParameterDescription< ParameterSetDescription >
 
class  ParameterDescription< std::vector< ParameterSet > >
 
class  ParameterDescriptionBase
 
class  ParameterDescriptionCases
 
class  ParameterDescriptionNode
 
class  ParameterSet
 
class  ParameterSetBlob
 
class  ParameterSetConverter
 
class  ParameterSetDescription
 
class  ParameterSetDescriptionFiller
 
class  ParameterSetDescriptionFillerBase
 
class  ParameterSetEntry
 
class  ParameterSwitch
 
class  ParameterSwitchBase
 
struct  ParameterTypeToEnum
 
class  ParameterWildcard
 
class  ParameterWildcard< ParameterSetDescription >
 
class  ParameterWildcard< std::vector< ParameterSet > >
 
class  ParameterWildcardBase
 
class  Parentage
 
class  ParentageRegistry
 
class  ParentContext
 
class  ParentProcessProductResolver
 
class  Path
 
class  PathContext
 
class  PathsAndConsumesOfModules
 
class  PathsAndConsumesOfModulesBase
 
class  PathStatusFilter
 
class  PathStatusInserter
 
struct  PathSummary
 
struct  PathTimingSummary
 
class  PileUp
 
struct  PileUpConfig
 
class  PlaceInPathContext
 
class  PoissonPUGenerator
 
class  PoolOutputModule
 
class  PoolSource
 
class  PreallocationConfiguration
 
class  PreMixingCrossingFrameWorker
 
class  PreMixingModule
 
class  PreMixingPileupCopy
 
class  Prescaler
 
class  Presence
 
class  PresenceFactory
 
class  Principal
 
class  PrincipalCache
 
class  PrincipalGetAdapter
 
class  PrintEventSetupContent
 
class  PrintEventSetupDataRetrieval
 
class  ProblemTracker
 
class  ProcessConfiguration
 
class  ProcessContext
 
class  ProcessDesc
 
class  ProcessHistory
 
class  ProcessHistoryRegistry
 
class  ProcessingController
 
class  ProcessMatch
 
class  ProducedProductResolver
 
class  ProducerBase
 
class  ProducerSourceBase
 
class  ProducerSourceFromFiles
 
class  ProductData
 
class  ProductDeletedException
 
class  ProductFromFwdPtrFactory
 
class  ProductFromFwdPtrProducer
 Produces a list of objects "by value" that correspond to the FwdPtr's from an input collection. More...
 
class  ProductID
 
struct  ProductLabels
 
class  ProductProvenance
 
struct  ProductProvenanceEqual
 
struct  ProductProvenanceHasher
 
class  ProductProvenanceRetriever
 
class  ProductRegistry
 
class  ProductRegistryHelper
 
class  ProductResolverBase
 
class  ProductResolverIndexAndSkipBit
 
class  ProductResolverIndexHelper
 
class  ProductSelector
 
class  ProductSelectorRules
 
class  propagate_const
 
class  Provenance
 
class  ProvenanceAdaptor
 
class  ProvenanceCheckerOutputModule
 
class  ProvenanceReaderBase
 
class  Ptr
 
class  PtrHolder
 
class  PtrVector
 
class  PtrVectorBase
 
class  PtrVectorItr
 
class  PUGenerator
 
class  PuttableProductResolver
 
class  PuttableSourceBase
 
class  RandomEngineSentry
 
class  RandomEngineStates
 
class  RandomFilter
 
class  RandomMultiParticlePGunProducer
 
class  RandomNumberGenerator
 
class  RandomtXiGunProducer
 
class  RangeMap
 
class  RawInputSource
 
class  RawInputSourceFromFiles
 
class  RecordEventID
 
class  ReducedProvenanceReader
 
class  Ref
 
class  Ref< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value, typename refhelper::FindTrait< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value >::value >
 
class  RefBase
 
class  RefCore
 
class  RefCoreStreamer
 
class  RefCoreWithIndex
 
class  RefCoreWithIndexStreamer
 
class  RefProd
 
class  RefToBase
 
class  RefToBaseProd
 
class  RefToBaseVector
 
class  RefVector
 
class  RefVectorBase
 
class  RefVectorIterator
 
class  RefVectorMemberPointersHolder
 
class  ReusableObjectHolder
 
class  RootDebug
 
class  RootDelayedReader
 
class  RootEmbeddedFileSequence
 
class  RootFile
 
class  RootFileEventFinder
 
class  RootHandlers
 
class  RootInputFileSequence
 
class  RootOutputFile
 
class  RootOutputTree
 
class  RootPrimaryFileSequence
 
class  RootSecondaryFileSequence
 
class  RootServiceChecker
 
class  RootTree
 
class  Run
 
class  RunAux
 
class  RunAuxiliary
 
class  RunBase
 
struct  RunCache
 
class  RunForOutput
 
class  RunHelperBase
 
class  RunID
 
class  RunIndex
 
class  RunLumiEntryInfo
 
class  RunningAverage
 
class  RunPrincipal
 
struct  RunSummaryCache
 
class  Schedule
 
class  ScheduleInfo
 
struct  ScheduleItems
 
class  SecondaryEventIDAndFileInfo
 
class  SecondaryEventProvider
 
class  SecSourceAnalyzer
 
class  SendEvent
 
class  SendJobHeader
 
class  SerialTaskQueue
 
class  SerialTaskQueueChain
 
class  Service
 
class  ServiceRegistry
 
class  ServiceToken
 
class  SetRunForEachLumiHelper
 
class  SetRunHelper
 
class  SharedResourceNames
 
class  SharedResourcesAcquirer
 
class  SharedResourcesRegistry
 
class  SignallingProductRegistry
 
class  SimpleOutlet
 
class  SingleChoiceNoProcessProductResolver
 
class  SingleConsumerQ
 
class  SiteLocalConfig
 
class  SoATuple
 
class  SortedCollection
 
class  StableProvenance
 
class  StatsCount
 
class  StoredMergeableRunProductMetadata
 
struct  StoredProductProvenance
 
struct  StreamCache
 
class  StreamContext
 
class  StreamedProduct
 
class  StreamerFileReader
 
class  StreamerFileWriter
 
class  StreamerInputFile
 
class  StreamerInputModule
 
class  StreamerInputSource
 
class  StreamerOutputModule
 
class  StreamerOutputModuleBase
 
class  StreamID
 
class  StreamSchedule
 
class  StreamSerializer
 
struct  StrictWeakOrdering
 
class  SubProcess
 
class  SubProcessParentageHelper
 
class  Suppress_LogDebug_
 
class  SystemTimeKeeper
 
class  TerminationOrigin
 
class  TestHandle
 
class  TestMix
 
class  TestMixedSource
 
class  TestSource
 
class  ThinnedAssociation
 
class  ThinnedAssociationBranches
 
class  ThinnedAssociationsHelper
 
class  ThinningProducer
 
class  ThreadSafeAddOnlyContainer
 
class  ThreadSafeOutputFileStream
 
struct  TimeOfDay
 
class  TimeoutPoolOutputModule
 
class  Timestamp
 
class  TimingServiceBase
 
class  TRandomAdaptor
 
class  TransientDataFrame
 
class  Trie
 
class  TrieFactory
 
class  TrieNode
 this class represent the node of a trie, it contains a link to a sub node and a link to a brother (node which have the same father) More...
 
class  TrieNodeIter
 
class  TriggerNames
 
struct  TriggerPath
 
struct  TriggerReport
 
class  TriggerResultInserter
 
class  TriggerResults
 
class  TriggerResultsByName
 
struct  TriggerTimingReport
 
class  TypeBases
 
class  TypeDataMembers
 
class  TypeFunctionMembers
 
class  TypeID
 
class  TypeIDBase
 
struct  TypeIDHasher
 
class  TypeInBranchType
 
class  TypeToGet
 
class  TypeWithDict
 
class  UnknownModuleException
 Exception thrown when trying to instance a module which is not registered to the system. More...
 
class  UnscheduledAuxiliary
 
class  UnscheduledCallProducer
 
class  UnscheduledConfigurator
 
class  UnscheduledProductResolver
 
class  ValidityInterval
 
class  value_ptr
 
struct  value_ptr_traits
 
struct  value_ptr_traits< IndexIntoFile::IndexIntoFileItrImpl >
 
struct  value_ptr_traits< ParameterDescriptionNode >
 
struct  value_ptr_traits< ParameterSetDescription >
 
class  ValueHolderECGetter
 
class  ValueMap
 
class  VecArray
 
class  VectorInputSource
 
struct  VectorInputSourceDescription
 
class  VectorInputSourceFactory
 
class  View
 
class  View< T >
 
class  ViewBase
 
class  ViewTypeChecker
 
class  VParameterSetEntry
 
class  WaitingTask
 
class  WaitingTaskHolder
 
class  WaitingTaskList
 
class  WaitingTaskWithArenaHolder
 
class  WallclockTimer
 
struct  WantsGlobalLuminosityBlockTransitions
 
struct  WantsGlobalRunTransitions
 
struct  WantsStreamLuminosityBlockTransitions
 
struct  WantsStreamRunTransitions
 
struct  WatchInputFiles
 
class  WillGetIfMatch
 
class  Worker
 
class  WorkerInPath
 
class  WorkerMaker
 
class  WorkerManager
 
struct  WorkerParams
 
class  WorkerRegistry
 The Registry of all workers that where requested Holds all instances of workers. In this implementation, Workers are owned. More...
 
struct  WorkerSummary
 
class  WorkerT
 
struct  WorkerTimingSummary
 
class  Wrapper
 
class  WrapperBase
 
class  XORGroupDescription
 
class  ZombieKillerService
 

Typedefs

template<typename T >
using AlignedVec = Aligned< T, 16 >
 
typedef unsigned int BranchDescriptionIndex
 
typedef std::vector< BranchID::value_typeBranchIDList
 
typedef std::vector< BranchIDListBranchIDLists
 
typedef unsigned short BranchListIndex
 
typedef std::vector< BranchListIndexBranchListIndexes
 
typedef void(* CFUNC) (int, siginfo_t *, void *)
 
typedef std::vector< CTPPSFastRecHitCTPPSFastRecHitContainer
 
typedef std::vector< CTPPSFastTrackCTPPSFastTrackContainer
 
typedef DigiAccumulatorMixMod *( DAFunc) (ParameterSet const &, ProducerBase &, ConsumesCollector &)
 
typedef uint32_t det_id_type
 
typedef edmplugin::PluginFactory< DAFuncDigiAccumulatorMixModPluginFactory
 
typedef std::list< ELdestination * > ELlist_dest
 
typedef std::list< ELstringELlist_string
 
typedef std::map< ELstring const, ELseverityLevel::ELsev_ELmap
 
typedef std::map< ELextendedID, CountAndLimitELmap_counts
 
typedef std::map< ELstring, LimitAndTimespanELmap_limits
 
typedef std::map< ELextendedID, StatsCountELmap_stats
 
typedef ELseverityLevel const ELslGen()
 
typedef std::string ELstring
 
typedef Hash< EntryDescriptionTypeEntryDescriptionID
 
typedef std::map< EntryDescriptionID, EventEntryDescriptionEntryDescriptionMap
 
typedef std::vector< EventEntryInfoEventEntryInfoVector
 
typedef unsigned long long EventNumber_t
 
typedef ParameterSetID EventSelectionID
 
typedef std::vector< EventSelectionIDEventSelectionIDVector
 
typedef std::vector< std::pair< edm::ProductID, unsigned long > > FillViewHelperVector
 
typedef Handle< FWGenericObjectFWGenericHandle
 
typedef Handle< GenericObjectGenericHandle
 
typedef long long int HRTimeDiffType
 
typedef unsigned long long int HRTimeType
 
typedef edmplugin::PluginFactory< ISFuncInputSourcePluginFactory
 
typedef InputSource *( ISFunc) (ParameterSet const &, InputSourceDescription const &)
 
typedef VectorInputSource *( ISVecFunc) (ParameterSet const &, VectorInputSourceDescription const &)
 
typedef std::vector< LHCTransportLinkLHCTransportLinkContainer
 
typedef RunLumiEntryInfo LumiEntryInfo
 
typedef unsigned int LuminosityBlockNumber_t
 
typedef edmplugin::PluginFactory< Maker *()> MakerPluginFactory
 
typedef Hash< ModuleDescriptionTypeModuleDescriptionID
 
typedef edmplugin::PluginFactory< ParameterSetDescriptionFillerBase *(void)> ParameterSetDescriptionFillerPluginFactory
 
typedef Hash< ParameterSetTypeParameterSetID
 
typedef std::map< ParameterSetID, ParameterSetBlobParameterSetMap
 
typedef Hash< ParentageTypeParentageID
 
typedef std::string PassID
 
typedef std::vector< PassiveHitPassiveHitContainer
 
using PathStatus = HLTPathStatus
 
typedef std::vector< PCaloHitPCaloHitContainer
 
typedef std::shared_ptr< Pointer_to_new_exception_on_heapPlace_for_passing_exception_ptr
 
typedef std::shared_ptr< edm::ExceptionPointer_to_new_exception_on_heap
 
typedef Presence *( PresenceFunc) ()
 
typedef edmplugin::PluginFactory< Presence *()> PresencePluginFactory
 
typedef Hash< ProcessConfigurationTypeProcessConfigurationID
 
typedef std::vector< ProcessConfigurationProcessConfigurationVector
 
typedef Hash< ProcessHistoryTypeProcessHistoryID
 
typedef std::map< ProcessHistoryID, ProcessHistoryProcessHistoryMap
 
typedef std::vector< ProcessHistoryProcessHistoryVector
 
typedef unsigned short ProcessIndex
 
typedef std::string ProcessingTask
 
typedef unsigned short ProductIndex
 
typedef std::vector< ProductProvenanceProductProvenanceVector
 
typedef unsigned int ProductResolverIndex
 
typedef std::vector< PSimHitPSimHitContainer
 
typedef std::multimap< EventSetupRecordKey, FactoryInfoRecord2Factories
 
typedef std::string ReleaseVersion
 
typedef RunLumiEntryInfo RunEntryInfo
 
typedef unsigned int RunNumber_t
 
typedef std::vector< std::pair< BranchDescription const *, EDGetToken > > SelectedProducts
 
typedef std::array< SelectedProducts, NumBranchTypesSelectedProductsForBranchType
 
typedef std::vector< BranchDescriptionSendDescs
 
typedef std::vector< StreamedProductSendProds
 
typedef std::vector< SimTrackSimTrackContainer
 
typedef std::vector< SimVertexSimVertexContainer
 
typedef edm::Ref< std::vector< SimVertex > > SimVertexRef
 
typedef edm::RefProd< std::vector< SimVertex > > SimVertexRefProd
 
typedef edm::RefVector< std::vector< SimVertex > > SimVertexRefVector
 
typedef std::vector< StoredProductProvenanceStoredProductProvenanceVector
 
using Strings = EventSelector::Strings
 
typedef std::vector< std::string > StringVector
 
typedef unsigned long long TimeValue_t
 
typedef detail::TriggerResultsBasedEventSelector::handle_t Trig
 
typedef std::map< std::string, char > Type2Code
 
typedef std::vector< edm::BranchDescription const * > VCBDP
 
typedef edmplugin::PluginFactory< ISVecFuncVectorInputSourcePluginFactory
 
typedef std::vector< ParameterSetVParameterSet
 
typedef std::vector< std::string > vstring
 

Enumerations

enum  BranchActionType { BranchActionGlobalBegin = 0, BranchActionStreamBegin = 1, BranchActionStreamEnd = 2, BranchActionGlobalEnd = 3 }
 
enum  BranchType { InEvent = 0, InLumi = 1, InRun = 2, NumBranchTypes }
 
enum  EDMModuleType {
  EDMModuleType::kUnknown, EDMModuleType::kSource, EDMModuleType::kESSource, EDMModuleType::kESProducer,
  EDMModuleType::kEDAnalyzer, EDMModuleType::kEDProducer, EDMModuleType::kEDFilter, EDMModuleType::kOutputModule
}
 
enum  HashedTypes {
  ModuleDescriptionType, ParameterSetType, ProcessHistoryType, ProcessConfigurationType,
  EntryDescriptionType, ParentageType
}
 
enum  InputType { InputType::Primary, InputType::SecondaryFile, InputType::SecondarySource }
 
enum  JobMode { GridJobMode, ReleaseValidationJobMode, AnalysisJobMode, NilJobMode }
 
enum  KindOfType { PRODUCT_TYPE, ELEMENT_TYPE }
 
enum  ParameterTypes {
  k_int32 = 'I', k_vint32 = 'i', k_uint32 = 'U', k_vuint32 = 'u',
  k_int64 = 'L', k_vint64 = 'l', k_uint64 = 'X', k_vuint64 = 'x',
  k_double = 'D', k_vdouble = 'd', k_bool = 'B', k_string = 'S',
  k_vstring = 's', k_EventID = 'E', k_VEventID = 'e', k_LuminosityBlockID = 'M',
  k_VLuminosityBlockID = 'm', k_InputTag = 't', k_VInputTag = 'v', k_FileInPath = 'F',
  k_LuminosityBlockRange = 'A', k_VLuminosityBlockRange = 'a', k_EventRange = 'R', k_VEventRange = 'r',
  k_PSet = 'Q', k_VPSet = 'q'
}
 
enum  ProductResolverIndexValues { ProductResolverIndexValuesBit = 1U << 30, ProductResolverIndexInvalid = std::numeric_limits<unsigned int>::max(), ProductResolverIndexInitializing = std::numeric_limits<unsigned int>::max() - 1, ProductResolverIndexAmbiguous = std::numeric_limits<unsigned int>::max() - 2 }
 
enum  TerminationOrigin { TerminationOrigin::ExceptionFromThisContext, TerminationOrigin::ExceptionFromAnotherContext, TerminationOrigin::ExternalSignal }
 
enum  Transition {
  Transition::Event, Transition::BeginLuminosityBlock, Transition::EndLuminosityBlock, Transition::BeginRun,
  Transition::EndRun
}
 
enum  Verbosity { Silent =0, Concise =2, Normal =5, Detailed =10 }
 
enum  WildcardValidationCriteria { RequireZeroOrMore, RequireAtLeastOne, RequireExactlyOne }
 

Functions

void addContextAndPrintException (char const *context, cms::Exception &ex, bool disablePrint)
 
void addToMissingDictionariesException (edm::Exception &exception, std::vector< std::string > &missingDictionaries, std::string const &context)
 
static std::string appendCurrentProcessIfAlias (std::string const &processFromInputTag, std::string const &currentProcess)
 
template<class FP >
bool asm_isnan (FP x)
 
template<typename Traits , typename P , typename SC >
void beginGlobalTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &token, SC &iSubProcesses)
 
template<typename Traits , typename P , typename SC >
void beginStreamsTransitionAsync (WaitingTask *iWait, Schedule &iSchedule, unsigned int iNStreams, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &token, SC &iSubProcesses)
 
template<typename Traits , typename P , typename SC >
void beginStreamTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, unsigned int iStreamIndex, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &token, SC &iSubProcesses)
 
template<typename ForwardSequence , typename Datum >
bool binary_search_all (ForwardSequence const &s, Datum const &d)
 wrappers for std::binary_search More...
 
template<typename ForwardSequence , typename Datum , typename Predicate >
bool binary_search_all (ForwardSequence const &s, Datum const &d, Predicate p)
 
std::string const & BranchTypeToAuxBranchName (BranchType const &branchType)
 
std::string const & BranchTypeToAuxiliaryBranchName (BranchType const &branchType)
 
std::string const & BranchTypeToBranchEntryInfoBranchName (BranchType const &branchType)
 
std::string const & BranchTypeToInfoTreeName (BranchType const &branchType)
 
std::string const & BranchTypeToMajorIndexName (BranchType const &branchType)
 
std::string const & BranchTypeToMetaDataTreeName (BranchType const &branchType)
 
std::string const & BranchTypeToMinorIndexName (BranchType const &branchType)
 
std::string const & BranchTypeToProductProvenanceBranchName (BranchType const &BranchType)
 
std::string const & BranchTypeToProductStatusBranchName (BranchType const &branchType)
 
std::string const & BranchTypeToProductTreeName (BranchType const &branchType)
 
std::string const & BranchTypeToString (BranchType const &branchType)
 
template<typename TReturn >
TReturn callWithTryCatchAndPrint (std::function< TReturn(void)> iFunc, char const *context=0, bool disablePrint=false)
 
template<typename T >
static void check (T const &p, std::string const &id, SelectedProducts const &iProducts)
 
bool checkClassDictionaries (std::vector< std::string > &missingDictionaries, TypeID const &typeID)
 
bool checkClassDictionaries (std::vector< std::string > &missingDictionaries, std::string const &name, TypeWithDict const &typeWithDict)
 
bool checkDictionary (std::vector< std::string > &missingDictionaries, TypeID const &typeID)
 
bool checkDictionary (std::vector< std::string > &missingDictionaries, std::string const &name, TypeWithDict const &typeWithDict)
 
bool checkDictionaryOfWrappedType (std::vector< std::string > &missingDictionaries, TypeID const &unwrappedTypeID)
 
bool checkDictionaryOfWrappedType (std::vector< std::string > &missingDictionaries, std::string const &unwrappedName)
 
void checkForModuleDependencyCorrectness (edm::PathsAndConsumesOfModulesBase const &iPnC, bool iPrintDependencies)
 
void checkForWrongProduct (ProductID const &keyID, ProductID const &refID)
 
static void cleanup (const Factory::MakerMap::value_type &v)
 
void clearLoggedErrorsSummary (unsigned int iStreamID)
 
void clearMessageLog ()
 
bool combinable (BranchDescription const &a, BranchDescription const &b)
 
bool contains (LuminosityBlockRange const &lh, LuminosityBlockID const &rh)
 
bool contains (EventRange const &lh, EventID const &rh)
 
bool contains (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
 
bool contains (EventRange const &lh, EventRange const &rh)
 
bool contains_ (EventRange const &lh, EventID const &rh)
 
template<class FwdIter >
FwdIter contextual_find (FwdIter b, FwdIter e, char first, char sep, char last)
 
template<class FwdIter >
FwdIter contextual_find_not (FwdIter b, FwdIter e, char first, char sep, char last)
 
void conversion (LuminosityBlockAux const &from, LuminosityBlockAuxiliary &to)
 
void conversion (RunAux const &from, RunAuxiliary &to)
 
void conversion (EventAux const &from, EventAuxiliary &to)
 
template<typename T >
void convert_handle (BasicHandle &&bh, Handle< T > &result)
 
void convert_handle (BasicHandle const &orig, Handle< FWGenericObject > &result)
 specialize this function forFWGenericHandle More...
 
void convert_handle (BasicHandle &&orig, Handle< GenericObject > &result)
 specialize this function for GenericHandle More...
 
constexpr BranchType convertToBranchType (Transition iValue)
 
constexpr Transition convertToTransition (BranchType iValue)
 
template<typename ForwardSequence , typename Func >
Func copy_all (ForwardSequence &s, Func f)
 wrappers for copy More...
 
template<typename T1 , typename T2 , typename T3 , typename ToT >
void copyFromTo (ESProducts< T1, T2, T3 > &iFrom, ToT &iTo)
 
std::string createGlobalIdentifier ()
 
bool decode (bool &, std::string const &)
 
bool decode (std::vector< bool > &, std::string const &)
 
bool decode (int &, std::string const &)
 
bool decode (std::vector< int > &, std::string const &)
 
bool decode (unsigned int &, std::string const &)
 
bool decode (std::vector< unsigned int > &, std::string const &)
 
bool decode (long long &, std::string const &)
 
bool decode (std::vector< long long > &, std::string const &)
 
bool decode (unsigned long long &, std::string const &)
 
bool decode (std::vector< unsigned long long > &, std::string const &)
 
bool decode (double &, std::string const &)
 
bool decode (std::vector< double > &, std::string const &)
 
bool decode (std::string &, std::string const &)
 
bool decode (std::vector< std::string > &, std::string const &)
 
bool decode (edm::FileInPath &, std::string const &)
 
bool decode (edm::InputTag &, std::string const &)
 
bool decode (std::vector< edm::InputTag > &, std::string const &)
 
bool decode (edm::ESInputTag &, std::string const &)
 
bool decode (std::vector< edm::ESInputTag > &, std::string const &)
 
bool decode (edm::EventID &, std::string const &)
 
bool decode (std::vector< edm::EventID > &, std::string const &)
 
bool decode (edm::LuminosityBlockID &, std::string const &)
 
bool decode (std::vector< edm::LuminosityBlockID > &, std::string const &)
 
bool decode (edm::LuminosityBlockRange &, std::string const &)
 
bool decode (std::vector< edm::LuminosityBlockRange > &, std::string const &)
 
bool decode (edm::EventRange &, std::string const &)
 
bool decode (std::vector< edm::EventRange > &, std::string const &)
 
bool decode (ParameterSet &, std::string const &)
 
bool decode (std::vector< ParameterSet > &, std::string const &)
 
std::vector< std::string > defaultCmsRunServices ()
 
std::string defaultModuleLabel (std::string label)
 
void disableAllSigs (sigset_t *oldset)
 
bool DisableLoggedErrorsSummary ()
 
void disableRTSigs ()
 
void disableSignal (sigset_t *newset, int signum)
 
bool distinct (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
 
bool distinct (EventRange const &lh, EventRange const &rh)
 
void doBuildRealData (std::string const &name)
 
void doBuildRealData (const std::string &name)
 
const char * edmModuleType (edm::ModuleDescription const &module)
 
EDMModuleType edmModuleTypeEnum (edm::ModuleDescription const &module)
 
void edmodule_mightGet_config (ConfigurationDescriptions &iDesc)
 
ELseverityLevel const ELdebugGen ()
 
ELseverityLevel const ELerrorGen ()
 
ELseverityLevel const ELhighestSeverityGen ()
 
ELseverityLevel const ELinfoGen ()
 
ELseverityLevel const ELsevereGen ()
 
ELseverityLevel const ELunspecifiedGen ()
 
ELseverityLevel const ELwarningGen ()
 
ELseverityLevel const ELzeroSeverityGen ()
 
bool EnableLoggedErrorsSummary ()
 
void enableSignal (sigset_t *newset, int signum)
 
bool encode (std::string &, bool)
 
bool encode (std::string &, std::vector< bool > const &)
 
bool encode (std::string &, int)
 
bool encode (std::string &, std::vector< int > const &)
 
bool encode (std::string &, unsigned int)
 
bool encode (std::string &, std::vector< unsigned int > const &)
 
bool encode (std::string &, long long)
 
bool encode (std::string &, std::vector< long long > const &)
 
bool encode (std::string &, unsigned long long)
 
bool encode (std::string &, std::vector< unsigned long long > const &)
 
bool encode (std::string &, double)
 
bool encode (std::string &, std::vector< double > const &)
 
bool encode (std::string &, std::string const &)
 
bool encode (std::string &, std::vector< std::string > const &)
 
bool encode (std::string &, edm::FileInPath const &)
 
bool encode (std::string &, edm::InputTag const &)
 
bool encode (std::string &, std::vector< edm::InputTag > const &)
 
bool encode (std::string &, edm::ESInputTag const &)
 
bool encode (std::string &, std::vector< edm::ESInputTag > const &)
 
bool encode (std::string &, edm::EventID const &)
 
bool encode (std::string &, std::vector< edm::EventID > const &)
 
bool encode (std::string &, edm::LuminosityBlockID const &)
 
bool encode (std::string &, std::vector< edm::LuminosityBlockID > const &)
 
bool encode (std::string &, edm::LuminosityBlockRange const &)
 
bool encode (std::string &, std::vector< edm::LuminosityBlockRange > const &)
 
bool encode (std::string &, edm::EventRange const &)
 
bool encode (std::string &, std::vector< edm::EventRange > const &)
 
bool encode (std::string &, ParameterSet const &)
 
bool encode (std::string &, std::vector< ParameterSet > const &)
 
template<typename Traits , typename P , typename SC >
void endGlobalTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &token, SC &iSubProcesses, bool cleaningUpAfterException)
 
template<typename Traits , typename P , typename SC >
void endStreamsTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, unsigned int iNStreams, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &iToken, SC &iSubProcesses, bool cleaningUpAfterException)
 
template<typename Traits , typename P , typename SC >
void endStreamTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, unsigned int iStreamIndex, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &token, SC &iSubProcesses, bool cleaningUpAfterException)
 
void ep_sigusr2 (int, siginfo_t *, void *)
 
bool eq (const ELstring &s1, const ELstring s2)
 
bool eq_nocase (const ELstring &s1, const char s2[])
 
template<class FP >
bool equal_isnan (FP x)
 
void exceptionContext (std::ostream &, GlobalContext const &)
 
void exceptionContext (std::ostream &, StreamContext const &)
 
void fillDescriptionFromPSet (ParameterSet const &pset, ParameterSetDescription &desc)
 
std::shared_ptr< EDLooperBasefillLooper (eventsetup::EventSetupsController &esController, eventsetup::EventSetupProvider &cp, ParameterSet &params)
 
void fillMaxEventsDescription (ParameterSetDescription &description)
 
void fillMaxLuminosityBlocksDescription (ParameterSetDescription &description)
 
void fillMaxSecondsUntilRampdownDescription (ParameterSetDescription &description)
 
static void fillModuleInPathSummary (Path const &path, size_t which, ModuleInPathSummary &sum)
 
void fillOptionsDescription (ParameterSetDescription &description)
 
void fillParameterSetBranch (TTree *parameterSetsTree, int basketSize)
 
static void fillPathSummary (Path const &path, PathSummary &sum)
 
void fillProcessHistoryBranch (TTree *metaDataTree, int basketSize, ProcessHistoryRegistry const &processHistoryRegistry)
 
template<typename T , typename A >
void fillPtrVector (std::vector< T, A > const &obj, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const * > &oPtr)
 
template<typename T , typename A >
void fillPtrVector (std::list< T, A > const &obj, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const * > &oPtr)
 
template<typename T , typename A >
void fillPtrVector (std::deque< T, A > const &obj, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const * > &oPtr)
 
template<typename T , typename A , typename Comp >
void fillPtrVector (std::set< T, A, Comp > const &obj, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const * > &oPtr)
 
template<typename T , typename SORT >
void fillPtrVector (SortedCollection< T, SORT > const &obj, std::type_info const &toType, std::vector< unsigned long > const &indices, std::vector< void const * > &ptrs)
 
template<typename T , unsigned int M, typename P >
void fillPtrVector (OwnArray< T, M, P > const &obj, std::type_info const &toType, std::vector< unsigned long > const &indices, std::vector< void const * > &ptrs)
 
template<typename T , typename P >
void fillPtrVector (OwnVector< T, P > const &obj, std::type_info const &toType, std::vector< unsigned long > const &indices, std::vector< void const * > &ptrs)
 
template<class T , class A >
void fillView (std::vector< T, A > const &obj, ProductID const &id, std::vector< void const * > &ptrs, FillViewHelperVector &helpers)
 
template<class T , class A >
void fillView (std::list< T, A > const &obj, ProductID const &id, std::vector< void const * > &ptrs, FillViewHelperVector &helpers)
 
template<class T , class A >
void fillView (std::deque< T, A > const &obj, ProductID const &id, std::vector< void const * > &ptrs, FillViewHelperVector &helpers)
 
template<class T , class A , class Comp >
void fillView (std::set< T, A, Comp > const &obj, ProductID const &id, std::vector< void const * > &ptrs, FillViewHelperVector &helpers)
 
template<typename T >
void fillView (PtrVector< T > const &obj, ProductID const &, std::vector< void const * > &pointers, FillViewHelperVector &helpers)
 
template<typename C , typename T , typename F >
void fillView (RefVector< C, T, F > const &obj, ProductID const &id, std::vector< void const * > &pointers, FillViewHelperVector &helpers)
 
template<typename T >
void fillView (RefToBaseVector< T > const &obj, ProductID const &, std::vector< void const * > &pointers, FillViewHelperVector &helpers)
 
template<typename KeyRefProd , typename CVal , typename KeyRef , typename SizeType , typename KeyReferenceHelper >
void fillView (AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > const &obj, ProductID const &id, std::vector< void const * > &pointers, FillViewHelperVector &helpers)
 
template<typename T >
void fillView (std::vector< edm::Ptr< T > > const &obj, ProductID const &id, std::vector< void const * > &pointers, FillViewHelperVector &helpers)
 
template<class T >
void fillView (DetSetVector< T > const &obj, ProductID const &id, std::vector< void const * > &pointers, FillViewHelperVector &helpers)
 
template<typename T , unsigned int M, typename P >
void fillView (OwnArray< T, M, P > const &obj, ProductID const &id, std::vector< void const * > &pointers, FillViewHelperVector &helpers)
 
template<typename T , typename SORT >
void fillView (SortedCollection< T, SORT > const &obj, ProductID const &id, std::vector< void const * > &pointers, FillViewHelperVector &helpers)
 
template<typename T , typename P >
void fillView (OwnVector< T, P > const &obj, ProductID const &id, std::vector< void const * > &pointers, FillViewHelperVector &helpers)
 
static void fillWorkerSummary (Worker const *pw, WorkerSummary &sum)
 
static void fillWorkerSummaryAux (Worker const &w, WorkerSummary &sum)
 
template<typename ForwardSequence , typename Predicate >
ForwardSequence::const_iterator find_if_in_all (ForwardSequence const &s, Predicate const &p)
 wrappers for std::find More...
 
template<typename ForwardSequence , typename Predicate >
ForwardSequence::iterator find_if_in_all (ForwardSequence &s, Predicate const &p)
 
template<typename ForwardSequence , typename Datum >
ForwardSequence::const_iterator find_in_all (ForwardSequence const &s, Datum const &d)
 wrappers for std::find More...
 
template<typename ForwardSequence , typename Datum >
ForwardSequence::iterator find_in_all (ForwardSequence &s, Datum const &d)
 
template<typename Key , typename Value >
Value const & findOrAssert (std::map< Key, Value > const &m, Key const &k)
 
template<typename Key , typename Value >
Value & findOrAssert (std::map< Key, Value > &m, Key const &k)
 
template<typename Key , typename Value >
Value const & findOrDefault (std::map< Key, Value > const &m, Key const &k, Value const &defaultValue)
 
template<typename Key , typename Value >
Value & findOrDefault (std::map< Key, Value > &m, Key const &k, Value &defaultValue)
 
template<typename Key , typename Value >
Value findOrDefault (std::map< Key, Value > const &m, Key const &k)
 
template<typename Key , typename Value >
Value & findOrInsert (std::map< Key, Value > &m, Key const &k)
 
template<typename T , typename U >
T first (std::pair< T, U > const &p)
 
void FlushMessageLog ()
 
template<typename ForwardSequence , typename Func >
Func for_all (ForwardSequence &s, Func f)
 wrapper for std::for_each More...
 
template<typename S , typename T >
SformatFile (T const &f, S &os)
 
bool FreshErrorsExist (unsigned int iStreamID)
 
template<typename T , typename R = typename eventsetup::data_default_record_trait<typename T::value_type>::type>
T const & get (EventSetup const &setup)
 
template<typename T , typename R = typename eventsetup::data_default_record_trait<typename T::value_type>::type, typename L >
T const & get (EventSetup const &setup, L &&label)
 
template<typename T >
T const & get (LuminosityBlock const &event, InputTag const &tag)
 
template<typename T >
T const & get (LuminosityBlock const &event, EDGetToken const &token)
 
template<typename T >
T const & get (Run const &event, InputTag const &tag)
 
template<typename T >
T const & get (LuminosityBlock const &event, EDGetTokenT< T > const &token)
 
template<typename T >
T const & get (Run const &event, EDGetToken const &token)
 
template<typename T >
T const & get (Run const &event, EDGetTokenT< T > const &token)
 
template<typename T >
T const & get (Event const &event, InputTag const &tag)
 
template<typename T >
T const & get (Event const &event, EDGetToken const &token)
 
template<typename T >
T const & get (Event const &event, EDGetTokenT< T > const &token)
 
template<typename T >
Tget_underlying (propagate_const< T > &)
 
template<typename T >
T const & get_underlying (propagate_const< T > const &)
 
template<typename T >
std::shared_ptr< T > & get_underlying_safe (propagate_const< std::shared_ptr< T >> &iP)
 
template<typename T >
std::shared_ptr< T const > get_underlying_safe (propagate_const< std::shared_ptr< T >> const &iP)
 
template<typename T >
T *& get_underlying_safe (propagate_const< T * > &iP)
 
template<typename T >
T const * get_underlying_safe (propagate_const< T * > const &iP)
 
template<typename T >
std::unique_ptr< T > & get_underlying_safe (propagate_const< std::unique_ptr< T >> &iP)
 
template<typename T >
std::unique_ptr< T const > get_underlying_safe (propagate_const< std::unique_ptr< T >> const &iP)
 
std::vector< std::string > const & getAllTriggerNames ()
 
template<typename T >
std::unique_ptr< TgetAnyPtr (void *p, int offset)
 
std::string getEnvironmentVariable (std::string const &name, std::string const &defaultValue=std::string())
 
int getFileFormatVersion ()
 
template<class T , std::size_t N>
std::array< T, NgetFixedSizeArray (ParameterSet const &pset, std::string const &name)
 
MallocOptionSettergetGlobalOptionSetter ()
 
ParameterSet const & getParameterSet (ParameterSetID const &id)
 
std::string getPassID ()
 
ParameterSet const & getProcessParameterSetContainingModule (ModuleDescription const &moduleDescription)
 
ParameterSet const * getProducerParameterSet (Provenance const &provenance)
 
template<typename T >
T const * getProduct (RefCore const &ref)
 
template<typename PROD >
std::shared_ptr< Wrapper< PROD > const > getProductByTag (Principal const &ep, InputTag const &tag, ModuleCallingContext const *mcc)
 
template<typename T >
T const * getProductWithCoreFromRef (RefCore const &ref, EDProductGetter const *prodGetter)
 
template<typename C >
helper::MatcherGetRef< C >::ref_type getRef (const Handle< C > &c, size_t k)
 
template<typename C , typename T , typename F , typename KEY >
T const * getRefPtr (RefCore const &product, KEY const &iKey)
 
std::string getReleaseVersion ()
 
TClass * getTClass (const std::type_info &ti)
 
TClass * getTClass (std::type_info const &ti)
 
template<typename T >
T const * getThinnedProduct (RefCore const &ref, unsigned int &thinnedKey, EDProductGetter const *prodGetter)
 
std::string getUuid (TTree *uuidTree)
 
std::unique_ptr< WrapperBasegetWrapperBasePtr (void *p, int offset)
 
std::string glob2reg (std::string const &pattern)
 
void GroupLogStatistics (std::string const &category)
 
void HaltMessageLogging ()
 
bool hasDictionary (std::type_info const &)
 
HRTimeType hrRealTime ()
 
void installCustomHandler (int signum, CFUNC func)
 
void installSig (int signum, CFUNC func)
 
bool is_glob (std::string const &pattern)
 
bool isAncestor (ProcessHistory const &a, ProcessHistory const &b)
 
bool isDebugEnabled ()
 
bool isDescendant (ProcessHistory const &a, ProcessHistory const &b)
 
constexpr bool isEndTransition (Transition iValue)
 
bool isErrorEnabled ()
 
template<typename T >
bool isFinite (T x)
 
template<>
bool isFinite (float x)
 
template<>
bool isFinite (double x)
 
template<>
bool isFinite (long double x)
 
bool isInfoEnabled ()
 
bool isMessageProcessingSetUp ()
 
bool isnan (float f)
 
bool isnan (double d)
 
bool isnan (long double q)
 
template<typename T >
bool isNotFinite (T x)
 
bool isSameEvent (EventAuxiliary const &a, EventAuxiliary const &b)
 
bool isSameEvent (EventPrincipal const &a, EventPrincipal const &b)
 
template<typename C , typename KEY >
bool isThinnedAvailable (RefCore const &product, KEY const &iKey)
 
bool isTransientEqual (ParameterSet const &a, ParameterSet const &b)
 
bool isWarningEnabled ()
 
template<typename V , typename T >
bool iterateTrieLeaves (V &v, TrieNode< T > const &n, std::string const &label="")
 visits only leaf nodes More...
 
static std::string const kBaseType ("Source")
 
static const std::string kBaseType ("EDProducer")
 
static const std::string kBaseType ("EDFilter")
 
static const std::string kBaseType ("EDAnalyzer")
 
static const std::string kBaseType ("OutputModule")
 
bool lessThan (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
 
bool lessThan (EventRange const &lh, EventRange const &rh)
 
bool lessThanSpecial (EventRange const &lh, EventRange const &rh)
 
bool loadCap (std::string const &name, std::vector< std::string > &missingDictionaries)
 
bool loadCap (const std::string &name, std::vector< std::string > &missingDictionaries)
 
void loadExtraClasses ()
 
static ELmap const & loadMap ()
 
std::vector< ErrorSummaryEntryLoggedErrorsOnlySummary (unsigned int iStreamID)
 
std::vector< ErrorSummaryEntryLoggedErrorsSummary (unsigned int iStreamID)
 
void LogStatistics ()
 
void longBranchPrint (TTree *tr)
 
template<typename ForwardSequence , typename Datum >
ForwardSequence::const_iterator lower_bound_all (ForwardSequence const &s, Datum const &d)
 wrappers for std::lower_bound More...
 
template<typename ForwardSequence , typename Datum >
ForwardSequence::iterator lower_bound_all (ForwardSequence &s, Datum const &d)
 
template<typename ForwardSequence , typename Datum , typename Predicate >
ForwardSequence::const_iterator lower_bound_all (ForwardSequence const &s, Datum const &d, Predicate p)
 
template<typename ForwardSequence , typename Datum , typename Predicate >
ForwardSequence::iterator lower_bound_all (ForwardSequence &s, Datum const &d, Predicate p)
 
std::unique_ptr< edm::EmptyWaitingTask, waitingtask::TaskDestroyermake_empty_waiting_task ()
 Create an EmptyWaitingTask which will properly be destroyed. More...
 
template<typename ALLOC , typename F >
FunctorTask< F > * make_functor_task (ALLOC &&iAlloc, F f)
 
template<typename T , typename F >
std::unique_ptr< T, Fmake_sentry (T *iObject, F iFunc)
 NOTE: if iObject is null, then iFunc will not be called. More...
 
template<typename ALLOC , typename F >
FunctorWaitingTask< F > * make_waiting_task (ALLOC &&iAlloc, F f)
 
template<typename T >
std::shared_ptr< ESHandleExceptionFactorymakeESHandleExceptionFactory (T &&iFunctor)
 
template<typename T >
std::shared_ptr< HandleExceptionFactorymakeHandleExceptionFactory (T &&iFunctor)
 
std::unique_ptr< InputSourcemakeInput (ParameterSet &params, CommonParams const &common, std::shared_ptr< ProductRegistry > preg, std::shared_ptr< BranchIDListHelper > branchIDListHelper, std::shared_ptr< ThinnedAssociationsHelper > thinnedAssociationsHelper, std::shared_ptr< ActivityRegistry > areg, std::shared_ptr< ProcessConfiguration const > processConfiguration, PreallocationConfiguration const &allocations)
 
static std::shared_ptr< cms::ExceptionmakeNotFoundException (char const *where, KindOfType kindOfType, TypeID const &productType, std::string const &label, std::string const &instance, std::string const &process)
 
void makeParameterSets (std::string const &configtext, std::shared_ptr< ParameterSet > &main)
 essentially the same as the previous method More...
 
template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type > makeRefTo (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::const_iterator itIter)
 
template<typename T >
RefToBaseProd< TmakeRefToBaseProdFrom (RefToBase< T > const &iRef, Event const &iEvent)
 
template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type > makeRefToDetSetRefVector (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::const_iterator itIter)
 
template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type > makeRefToDetSetRefVector (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::iterator itIter)
 
template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type > makeRefToDetSetVector (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::iterator itIter)
 
std::unique_ptr< RunHelperBasemakeRunHelper (ParameterSet const &pset)
 
std::string match (BranchDescription const &a, BranchDescription const &b, std::string const &fileName)
 
LuminosityBlockID const & max (LuminosityBlockID const &lh, LuminosityBlockID const &rh)
 
EventID const & max (EventID const &lh, EventID const &rh)
 
const unsigned int maxIDlength (200)
 
bool merge (LuminosityBlockRange &lh, LuminosityBlockRange &rh)
 
LuminosityBlockID const & min (LuminosityBlockID const &lh, LuminosityBlockID const &rh)
 
EventID const & min (EventID const &lh, EventID const &rh)
 
std::string moduleName (Provenance const &provenance)
 
EDProductGetter const * mustBeNonZero (EDProductGetter const *prodGetter, std::string refType, ProductID const &productID)
 
static Principal::CacheIdentifier_t nextIdentifier ()
 
Long64_t numEntries (TFile *hdl, const std::string &trname)
 
Long64_t numEntries (TFile *hdl, std::string const &trname)
 
TFile * openFileHdl (const std::string &fname)
 
TFile * openFileHdl (std::string const &fname)
 
bool operator!= (FileID const &lh, FileID const &rh)
 
bool operator!= (RunLumiEntryInfo const &a, RunLumiEntryInfo const &b)
 
bool operator!= (EventEntryInfo const &a, EventEntryInfo const &b)
 
bool operator!= (ProductID const &lh, ProductID const &rh)
 
bool operator!= (EventEntryDescription const &a, EventEntryDescription const &b)
 
bool operator!= (TypeID const &a, TypeID const &b)
 
bool operator!= (BranchKey const &a, BranchKey const &b)
 
bool operator!= (ProductProvenance const &a, ProductProvenance const &b)
 
bool operator!= (const TypeIDBase &a, const TypeIDBase &b)
 
template<class X , class Y >
bool operator!= (debugging_allocator< X > const &, debugging_allocator< Y > const &) noexcept
 
bool operator!= (Parentage const &a, Parentage const &b)
 
bool operator!= (ProcessConfiguration const &a, ProcessConfiguration const &b)
 
bool operator!= (ProcessHistory const &a, ProcessHistory const &b)
 
bool operator!= (TypeWithDict const &a, TypeWithDict const &b)
 
template<typename T >
bool operator!= (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
 
bool operator!= (RefCore const &lhs, RefCore const &rhs)
 
bool operator!= (TypeWithDict const &a, std::type_info const &b)
 
template<typename KEY >
bool operator!= (RefVectorBase< KEY > const &lhs, RefVectorBase< KEY > const &rhs)
 Inequality operator. More...
 
template<typename T >
bool operator!= (View< T > const &, View< T > const &)
 
bool operator!= (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
bool operator!= (std::type_info const &a, TypeWithDict const &b)
 
template<typename T >
bool operator!= (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)
 
template<typename T , typename U >
bool operator!= (atomic_value_ptr< T > const &lhs, U const &rhs)
 
bool operator!= (ProductRegistry const &a, ProductRegistry const &b)
 
template<typename T , typename U >
bool operator!= (U const &lhs, atomic_value_ptr< T > const &rhs)
 
template<typename C >
bool operator!= (RefProd< C > const &lhs, RefProd< C > const &rhs)
 
bool operator!= (Entry const &a, Entry const &b)
 
bool operator!= (ELseverityLevel const &e1, ELseverityLevel const &e2)
 
template<typename T , typename U >
bool operator!= (value_ptr< T > const &lhs, U const &rhs)
 
template<typename T , typename U >
bool operator!= (U const &lhs, value_ptr< T > const &rhs)
 
template<typename C , typename T , typename F >
bool operator!= (RefVector< C, T, F > const &lhs, RefVector< C, T, F > const &rhs)
 
template<typename T >
bool operator!= (Ptr< T > const &lhs, Ptr< T > const &rhs)
 
template<typename C , typename T , typename F >
bool operator!= (FwdRef< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
 
template<typename C , typename T , typename F >
bool operator!= (Ref< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
 
template<typename C , typename T , typename F >
bool operator!= (FwdRef< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
 
bool operator!= (ParameterSet const &a, ParameterSet const &b)
 
template<typename C , typename T , typename F >
bool operator!= (Ref< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
 
std::unique_ptr< ParameterDescriptionNodeoperator&& (ParameterDescriptionNode const &node_left, ParameterDescriptionNode const &node_right)
 
std::unique_ptr< ParameterDescriptionNodeoperator&& (std::unique_ptr< ParameterDescriptionNode > node_left, ParameterDescriptionNode const &node_right)
 
std::unique_ptr< ParameterDescriptionNodeoperator&& (ParameterDescriptionNode const &node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
 
std::unique_ptr< ParameterDescriptionNodeoperator&& (std::unique_ptr< ParameterDescriptionNode > node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
 
ParameterSet::Bool operator&& (ParameterSet::Bool a, ParameterSet::Bool b)
 
template<typename C , typename T , typename F >
RefVectorIterator< C, T, Foperator+ (typename RefVectorIterator< C, T, F >::difference n, RefVectorIterator< C, T, F > const &iter)
 
template<typename C >
Association< C > operator+ (const Association< C > &a1, const Association< C > &a2)
 
template<typename T >
ValueMap< Toperator+ (const ValueMap< T > &a1, const ValueMap< T > &a2)
 
bool operator< (EventProcessHistoryID const &lh, EventProcessHistoryID const &rh)
 
bool operator< (RunLumiEntryInfo const &a, RunLumiEntryInfo const &b)
 
bool operator< (StoredProductProvenance const &a, StoredProductProvenance const &b)
 
bool operator< (EventEntryInfo const &a, EventEntryInfo const &b)
 
bool operator< (BranchKey const &a, BranchKey const &b)
 
bool operator< (ProductProvenance const &a, ProductProvenance const &b)
 
bool operator< (WorkerTimingSummary const &a, WorkerTimingSummary const &b)
 
bool operator< (WorkerSummary const &a, WorkerSummary const &b)
 
bool operator< (ProductID const &lh, ProductID const &rh)
 
bool operator< (ProcessConfiguration const &a, ProcessConfiguration const &b)
 
template<class T >
bool operator< (DetSet< T > const &x, DetSet< T > const &y)
 
template<class T >
bool operator< (DetSet< T > const &x, det_id_type y)
 
template<class T >
bool operator< (det_id_type x, DetSet< T > const &y)
 
bool operator< (TypeWithDict const &a, TypeWithDict const &b)
 
bool operator< (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
bool operator< (RefCore const &lhs, RefCore const &rhs)
 
template<typename T >
bool operator< (View< T > const &, View< T > const &)
 
template<typename T >
bool operator< (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
 
template<typename T >
bool operator< (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)
 
bool operator< (ELseverityLevel const &e1, ELseverityLevel const &e2)
 
template<typename C >
bool operator< (RefProd< C > const &lhs, RefProd< C > const &rhs)
 
bool operator< (BranchDescription const &a, BranchDescription const &b)
 
template<typename T >
bool operator< (Ptr< T > const &lhs, Ptr< T > const &rhs)
 
template<typename C , typename T , typename F >
bool operator< (FwdRef< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
 
template<typename C , typename T , typename F >
bool operator< (Ref< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
 
template<typename C , typename T , typename F >
bool operator< (FwdRef< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
 
template<typename C , typename T , typename F >
bool operator< (Ref< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
 
std::ostream & operator<< (std::ostream &os, TimeOfDay const &tod)
 
std::ostream & operator<< (std::ostream &os, ParameterSetBlob const &blob)
 
std::ostream & operator<< (std::ostream &os, FileID const &id)
 
std::ostream & operator<< (std::ostream &os, BranchType const &branchType)
 
std::ostream & operator<< (std::ostream &, PlaceInPathContext const &)
 
std::ostream & operator<< (std::ostream &os, BranchID const &id)
 
std::ostream & operator<< (std::ostream &, InternalContext const &)
 
std::ostream & operator<< (std::ostream &os, RunLumiEntryInfo const &p)
 
std::ostream & operator<< (std::ostream &os, FileFormatVersion const &ff)
 
std::ostream & operator<< (std::ostream &os, EventEntryInfo const &p)
 
std::ostream & operator<< (std::ostream &, ProcessContext const &)
 
std::ostream & operator<< (std::ostream &, PathContext const &)
 
std::ostream & operator<< (std::ostream &os, EventEntryDescription const &p)
 
std::ostream & operator<< (std::ostream &os, ProductProvenance const &p)
 
std::ostream & operator<< (std::ostream &ost, const MallocOpts &)
 
std::ostream & operator<< (std::ostream &os, const ProductSelector &gs)
 
std::ostream & operator<< (std::ostream &os, ProductID const &id)
 
std::ostream & operator<< (std::ostream &os, TypeID const &id)
 
std::ostream & operator<< (std::ostream &oStream, LuminosityBlockRange const &iID)
 
std::ostream & operator<< (std::ostream &oStream, EventRange const &iID)
 
std::ostream & operator<< (std::ostream &os, const RunAuxiliary &p)
 
std::ostream & operator<< (std::ostream &os, Parentage const &p)
 
std::ostream & operator<< (std::ostream &, ParentContext const &)
 
std::ostream & operator<< (std::ostream &os, BranchKey const &bk)
 
std::ostream & operator<< (std::ostream &ost, InputTag const &tag)
 
std::ostream & operator<< (std::ostream &, GlobalContext const &)
 
std::ostream & operator<< (std::ostream &os, const LuminosityBlockAuxiliary &p)
 
std::ostream & operator<< (std::ostream &t, OStreamColumn const &c)
 
std::ostream & operator<< (std::ostream &os, StableProvenance const &p)
 
template<typename E >
std::ostream & operator<< (std::ostream &t, OStreamColumnEntry< E > const &ce)
 
std::ostream & operator<< (std::ostream &os, ProcessConfiguration const &pc)
 
std::ostream & operator<< (std::ostream &, StreamContext const &)
 
std::ostream & operator<< (std::ostream &, ModuleCallingContext const &)
 
std::ostream & operator<< (std::ostream &oStream, RunID const &iID)
 
std::ostream & operator<< (std::ostream &os, Provenance const &p)
 
std::ostream & operator<< (std::ostream &os, ModuleDescription const &p)
 
std::ostream & operator<< (std::ostream &os, const EventAuxiliary &p)
 
std::ostream & operator<< (std::ostream &os, ParameterSetEntry const &psetEntry)
 
std::ostream & operator<< (std::ostream &ost, const HLTGlobalStatus &hlt)
 Formatted printout of trigger tbale. More...
 
std::ostream & operator<< (std::ostream &os, JobReport::RunReport const &f)
 
template<class T >
ErrorObjoperator<< (ErrorObj &e, const T &t)
 
std::ostream & operator<< (std::ostream &ost, ProcessHistory const &ph)
 
ErrorObjoperator<< (ErrorObj &e, const char s[])
 
std::ostream & operator<< (std::ostream &oStream, LuminosityBlockID const &iID)
 
std::ostream & operator<< (std::ostream &oStream, EventID const &iID)
 
std::ostream & operator<< (std::ostream &os, const edm::FileInPath &fip)
 
std::ostream & operator<< (std::ostream &os, VParameterSetEntry const &vpsetEntry)
 
std::ostream & operator<< (std::ostream &os, TypeWithDict const &id)
 
std::ostream & operator<< (std::ostream &os, FileIndex const &fileIndex)
 
std::ostream & operator<< (std::ostream &os, ProductResolverBase const &phb)
 
std::ostream & operator<< (std::ostream &os, ProductRegistry const &pr)
 
std::ostream & operator<< (std::ostream &os, BranchDescription const &p)
 
std::ostream & operator<< (std::ostream &os, const ELseverityLevel &sev)
 
template<int I>
std::ostream & operator<< (std::ostream &os, Hash< I > const &h)
 
template<typename PROD >
std::ostream & operator<< (std::ostream &os, Handle< PROD > const &h)
 
template<typename C , typename T , typename F >
std::ostream & operator<< (std::ostream &os, RefVector< C, T, F > const &r)
 
std::ostream & operator<< (std::ostream &os, JobReport::InputFile const &f)
 
std::ostream & operator<< (std::ostream &os, JobReport::OutputFile const &f)
 
std::ostream & operator<< (std::ostream &os, ParameterSet const &pset)
 
std::ostream & operator<< (std::ostream &os, Entry const &entry)
 
bool operator<= (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
template<typename T >
bool operator<= (View< T > const &, View< T > const &)
 
bool operator<= (ELseverityLevel const &e1, ELseverityLevel const &e2)
 
bool operator== (FileID const &lh, FileID const &rh)
 
bool operator== (RunLumiEntryInfo const &a, RunLumiEntryInfo const &b)
 
bool operator== (ProductID const &lh, ProductID const &rh)
 
bool operator== (EventEntryInfo const &a, EventEntryInfo const &b)
 
bool operator== (EventEntryDescription const &a, EventEntryDescription const &b)
 
bool operator== (BranchKey const &a, BranchKey const &b)
 
bool operator== (ProductProvenance const &a, ProductProvenance const &b)
 
bool operator== (ProcessConfiguration const &a, ProcessConfiguration const &b)
 
template<class X , class Y >
bool operator== (debugging_allocator< X > const &, debugging_allocator< Y > const &) noexcept
 
bool operator== (Parentage const &a, Parentage const &b)
 
bool operator== (StableProvenance const &a, StableProvenance const &b)
 
template<class T >
bool operator== (RefToBaseVector< T > const &a, RefToBaseVector< T > const &b)
 
bool operator== (Provenance const &a, Provenance const &b)
 
bool operator== (ProcessHistory const &a, ProcessHistory const &b)
 
template<typename T >
bool operator== (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
 
bool operator== (TypeWithDict const &a, TypeWithDict const &b)
 
bool operator== (RefCore const &lhs, RefCore const &rhs)
 
template<typename KEY >
bool operator== (RefVectorBase< KEY > const &lhs, RefVectorBase< KEY > const &rhs)
 Equality operator. More...
 
bool operator== (TypeWithDict const &a, std::type_info const &b)
 
template<typename T >
bool operator== (View< T > const &, View< T > const &)
 
bool operator== (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
bool operator== (std::type_info const &a, TypeWithDict const &b)
 
bool operator== (edm::FileInPath const &a, edm::FileInPath const &b)
 
template<typename T >
bool operator== (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)
 
template<typename T , typename U >
bool operator== (atomic_value_ptr< T > const &lhs, U const &rhs)
 
bool operator== (ProductRegistry const &a, ProductRegistry const &b)
 
template<typename T , typename U >
bool operator== (U const &lhs, atomic_value_ptr< T > const &rhs)
 
template<typename C >
bool operator== (RefProd< C > const &lhs, RefProd< C > const &rhs)
 
bool operator== (Entry const &a, Entry const &b)
 
bool operator== (ELseverityLevel const &e1, ELseverityLevel const &e2)
 
template<typename T , typename U >
bool operator== (value_ptr< T > const &lhs, U const &rhs)
 
template<typename T , typename U >
bool operator== (U const &lhs, value_ptr< T > const &rhs)
 
bool operator== (BranchDescription const &a, BranchDescription const &b)
 
template<typename C , typename T , typename F >
bool operator== (RefVector< C, T, F > const &lhs, RefVector< C, T, F > const &rhs)
 
template<typename C , typename T , typename F >
bool operator== (FwdRef< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
 
template<typename C , typename T , typename F >
bool operator== (Ref< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
 
template<typename C , typename T , typename F >
bool operator== (FwdRef< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
 
template<typename T >
bool operator== (Ptr< T > const &lhs, Ptr< T > const &rhs)
 
bool operator== (ParameterSet const &a, ParameterSet const &b)
 
template<typename T , typename SORT , typename ALLOC >
bool operator== (SortedCollection< T, SORT > const &c, std::vector< T, ALLOC > const &v)
 
template<typename T , typename SORT >
bool operator== (SortedCollection< T, SORT > const &a, SortedCollection< T, SORT > const &b)
 
template<typename C , typename T , typename F >
bool operator== (Ref< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
 
bool operator> (TypeID const &a, TypeID const &b)
 
bool operator> (const TypeIDBase &a, const TypeIDBase &b)
 
bool operator> (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
template<typename T >
bool operator> (View< T > const &, View< T > const &)
 
bool operator> (ELseverityLevel const &e1, ELseverityLevel const &e2)
 
bool operator>= (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
template<typename T >
bool operator>= (View< T > const &, View< T > const &)
 
bool operator>= (ELseverityLevel const &e1, ELseverityLevel const &e2)
 
std::istream & operator>> (std::istream &is, FileInPath &fip)
 
std::unique_ptr< ParameterDescriptionCases< bool > > operator>> (bool caseValue, ParameterDescriptionNode const &node)
 
std::unique_ptr< ParameterDescriptionCases< int > > operator>> (int caseValue, ParameterDescriptionNode const &node)
 
std::unique_ptr< ParameterDescriptionCases< std::string > > operator>> (std::string const &caseValue, ParameterDescriptionNode const &node)
 
std::unique_ptr< ParameterDescriptionCases< std::string > > operator>> (char const *caseValue, ParameterDescriptionNode const &node)
 
std::unique_ptr< ParameterDescriptionCases< bool > > operator>> (bool caseValue, std::unique_ptr< ParameterDescriptionNode > node)
 
std::unique_ptr< ParameterDescriptionCases< int > > operator>> (int caseValue, std::unique_ptr< ParameterDescriptionNode > node)
 
std::unique_ptr< ParameterDescriptionCases< std::string > > operator>> (std::string const &caseValue, std::unique_ptr< ParameterDescriptionNode > node)
 
std::unique_ptr< ParameterDescriptionCases< std::string > > operator>> (char const *caseValue, std::unique_ptr< ParameterDescriptionNode > node)
 
std::unique_ptr< ParameterDescriptionNodeoperator^ (ParameterDescriptionNode const &node_left, ParameterDescriptionNode const &node_right)
 
std::unique_ptr< ParameterDescriptionNodeoperator^ (std::unique_ptr< ParameterDescriptionNode > node_left, ParameterDescriptionNode const &node_right)
 
std::unique_ptr< ParameterDescriptionNodeoperator^ (ParameterDescriptionNode const &node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
 
std::unique_ptr< ParameterDescriptionNodeoperator^ (std::unique_ptr< ParameterDescriptionNode > node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
 
std::unique_ptr< ParameterDescriptionCases< bool > > operator|| (std::unique_ptr< ParameterDescriptionCases< bool > >, std::unique_ptr< ParameterDescriptionCases< bool > >)
 
std::unique_ptr< ParameterDescriptionCases< int > > operator|| (std::unique_ptr< ParameterDescriptionCases< int > >, std::unique_ptr< ParameterDescriptionCases< int > >)
 
std::unique_ptr< ParameterDescriptionCases< std::string > > operator|| (std::unique_ptr< ParameterDescriptionCases< std::string > >, std::unique_ptr< ParameterDescriptionCases< std::string > >)
 
std::unique_ptr< ParameterDescriptionNodeoperator|| (ParameterDescriptionNode const &node_left, ParameterDescriptionNode const &node_right)
 
std::unique_ptr< ParameterDescriptionNodeoperator|| (std::unique_ptr< ParameterDescriptionNode > node_left, ParameterDescriptionNode const &node_right)
 
std::unique_ptr< ParameterDescriptionNodeoperator|| (ParameterDescriptionNode const &node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
 
std::unique_ptr< ParameterDescriptionNodeoperator|| (std::unique_ptr< ParameterDescriptionNode > node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
 
static std::atomic< int > ourSerial (0)
 
bool overlaps (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
 
bool overlaps (EventRange const &lh, EventRange const &rh)
 
ParameterSet const & parameterSet (Provenance const &provenance)
 
template<>
std::string ParameterSet::getParameter< std::string > (std::string const &name) const
 
template<>
std::string ParameterSet::getParameter< std::string > (char const *name) const
 
template<>
std::vector< double > ParameterSet::getParameter< std::vector< double > > (std::string const &name) const
 
template<>
std::vector< double > ParameterSet::getParameter< std::vector< double > > (char const *name) const
 
template<>
std::vector< ESInputTagParameterSet::getParameter< std::vector< ESInputTag > > (std::string const &name) const
 
template<>
std::vector< ESInputTagParameterSet::getParameter< std::vector< ESInputTag > > (char const *name) const
 
template<>
std::vector< EventIDParameterSet::getParameter< std::vector< EventID > > (std::string const &name) const
 
template<>
std::vector< EventIDParameterSet::getParameter< std::vector< EventID > > (char const *name) const
 
template<>
std::vector< EventRangeParameterSet::getParameter< std::vector< EventRange > > (std::string const &name) const
 
template<>
std::vector< EventRangeParameterSet::getParameter< std::vector< EventRange > > (char const *name) const
 
template<>
std::vector< InputTagParameterSet::getParameter< std::vector< InputTag > > (std::string const &name) const
 
template<>
std::vector< InputTagParameterSet::getParameter< std::vector< InputTag > > (char const *name) const
 
template<>
std::vector< int > ParameterSet::getParameter< std::vector< int > > (std::string const &name) const
 
template<>
std::vector< int > ParameterSet::getParameter< std::vector< int > > (char const *name) const
 
template<>
std::vector< long long > ParameterSet::getParameter< std::vector< long long > > (std::string const &name) const
 
template<>
std::vector< long long > ParameterSet::getParameter< std::vector< long long > > (char const *name) const
 
template<>
std::vector< LuminosityBlockIDParameterSet::getParameter< std::vector< LuminosityBlockID > > (std::string const &name) const
 
template<>
std::vector< LuminosityBlockIDParameterSet::getParameter< std::vector< LuminosityBlockID > > (char const *name) const
 
template<>
std::vector< LuminosityBlockRangeParameterSet::getParameter< std::vector< LuminosityBlockRange > > (std::string const &name) const
 
template<>
std::vector< LuminosityBlockRangeParameterSet::getParameter< std::vector< LuminosityBlockRange > > (char const *name) const
 
template<>
std::vector< PdtEntryParameterSet::getParameter< std::vector< PdtEntry > > (char const *name) const
 
template<>
std::vector< PdtEntryParameterSet::getParameter< std::vector< PdtEntry > > (std::string const &name) const
 
template<>
std::vector< std::string > ParameterSet::getParameter< std::vector< std::string > > (std::string const &name) const
 
template<>
std::vector< std::string > ParameterSet::getParameter< std::vector< std::string > > (char const *name) const
 
template<>
std::vector< unsigned int > ParameterSet::getParameter< std::vector< unsigned int > > (std::string const &name) const
 
template<>
std::vector< unsigned int > ParameterSet::getParameter< std::vector< unsigned int > > (char const *name) const
 
template<>
std::vector< unsigned long long > ParameterSet::getParameter< std::vector< unsigned long long > > (std::string const &name) const
 
template<>
std::vector< unsigned long long > ParameterSet::getParameter< std::vector< unsigned long long > > (char const *name) const
 
template<>
std::vector< std::string > ParameterSet::getParameterNamesForType< std::vector< PdtEntry > > (bool trackiness) const
 
template<>
std::string ParameterSet::getUntrackedParameter< std::string > (std::string const &name, std::string const &defaultValue) const
 
template<>
std::string ParameterSet::getUntrackedParameter< std::string > (std::string const &name) const
 
template<>
std::string ParameterSet::getUntrackedParameter< std::string > (char const *name, std::string const &defaultValue) const
 
template<>
std::string ParameterSet::getUntrackedParameter< std::string > (char const *name) const
 
template<>
std::vector< double > ParameterSet::getUntrackedParameter< std::vector< double > > (std::string const &name) const
 
template<>
std::vector< double > ParameterSet::getUntrackedParameter< std::vector< double > > (std::string const &name, std::vector< double > const &defaultValue) const
 
template<>
std::vector< double > ParameterSet::getUntrackedParameter< std::vector< double > > (char const *name) const
 
template<>
std::vector< double > ParameterSet::getUntrackedParameter< std::vector< double > > (char const *name, std::vector< double > const &defaultValue) const
 
template<>
std::vector< ESInputTagParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (std::string const &name) const
 
template<>
std::vector< ESInputTagParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (std::string const &name, std::vector< ESInputTag > const &defaultValue) const
 
template<>
std::vector< ESInputTagParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (char const *name, std::vector< ESInputTag > const &defaultValue) const
 
template<>
std::vector< ESInputTagParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (char const *name) const
 
template<>
std::vector< EventIDParameterSet::getUntrackedParameter< std::vector< EventID > > (std::string const &name, std::vector< EventID > const &defaultValue) const
 
template<>
std::vector< EventIDParameterSet::getUntrackedParameter< std::vector< EventID > > (std::string const &name) const
 
template<>
std::vector< EventIDParameterSet::getUntrackedParameter< std::vector< EventID > > (char const *name, std::vector< EventID > const &defaultValue) const
 
template<>
std::vector< EventIDParameterSet::getUntrackedParameter< std::vector< EventID > > (char const *name) const
 
template<>
std::vector< EventRangeParameterSet::getUntrackedParameter< std::vector< EventRange > > (std::string const &name, std::vector< EventRange > const &defaultValue) const
 
template<>
std::vector< EventRangeParameterSet::getUntrackedParameter< std::vector< EventRange > > (std::string const &name) const
 
template<>
std::vector< EventRangeParameterSet::getUntrackedParameter< std::vector< EventRange > > (char const *name) const
 
template<>
std::vector< EventRangeParameterSet::getUntrackedParameter< std::vector< EventRange > > (char const *name, std::vector< EventRange > const &defaultValue) const
 
template<>
std::vector< InputTagParameterSet::getUntrackedParameter< std::vector< InputTag > > (std::string const &name) const
 
template<>
std::vector< InputTagParameterSet::getUntrackedParameter< std::vector< InputTag > > (std::string const &name, std::vector< InputTag > const &defaultValue) const
 
template<>
std::vector< InputTagParameterSet::getUntrackedParameter< std::vector< InputTag > > (char const *name, std::vector< InputTag > const &defaultValue) const
 
template<>
std::vector< InputTagParameterSet::getUntrackedParameter< std::vector< InputTag > > (char const *name) const
 
template<>
std::vector< int > ParameterSet::getUntrackedParameter< std::vector< int > > (std::string const &name, std::vector< int > const &defaultValue) const
 
template<>
std::vector< int > ParameterSet::getUntrackedParameter< std::vector< int > > (std::string const &name) const
 
template<>
std::vector< int > ParameterSet::getUntrackedParameter< std::vector< int > > (char const *name, std::vector< int > const &defaultValue) const
 
template<>
std::vector< int > ParameterSet::getUntrackedParameter< std::vector< int > > (char const *name) const
 
template<>
std::vector< long long > ParameterSet::getUntrackedParameter< std::vector< long long > > (std::string const &name) const
 
template<>
std::vector< long long > ParameterSet::getUntrackedParameter< std::vector< long long > > (std::string const &name, std::vector< long long > const &defaultValue) const
 
template<>
std::vector< long long > ParameterSet::getUntrackedParameter< std::vector< long long > > (char const *name) const
 
template<>
std::vector< long long > ParameterSet::getUntrackedParameter< std::vector< long long > > (char const *name, std::vector< long long > const &defaultValue) const
 
template<>
std::vector< LuminosityBlockIDParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (std::string const &name) const
 
template<>
std::vector< LuminosityBlockIDParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (std::string const &name, std::vector< LuminosityBlockID > const &defaultValue) const
 
template<>
std::vector< LuminosityBlockIDParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (char const *name) const
 
template<>
std::vector< LuminosityBlockIDParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (char const *name, std::vector< LuminosityBlockID > const &defaultValue) const
 
template<>
std::vector< LuminosityBlockRangeParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (std::string const &name) const
 
template<>
std::vector< LuminosityBlockRangeParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (std::string const &name, std::vector< LuminosityBlockRange > const &defaultValue) const
 
template<>
std::vector< LuminosityBlockRangeParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (char const *name, std::vector< LuminosityBlockRange > const &defaultValue) const
 
template<>
std::vector< LuminosityBlockRangeParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (char const *name) const
 
template<>
std::vector< PdtEntryParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (std::string const &name) const
 
template<>
std::vector< PdtEntryParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (char const *name) const
 
template<>
std::vector< PdtEntryParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (std::string const &name, std::vector< PdtEntry > const &defaultValue) const
 
template<>
std::vector< PdtEntryParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (char const *name, std::vector< PdtEntry > const &defaultValue) const
 
template<>
std::vector< std::string > ParameterSet::getUntrackedParameter< std::vector< std::string > > (std::string const &name, std::vector< std::string > const &defaultValue) const
 
template<>
std::vector< std::string > ParameterSet::getUntrackedParameter< std::vector< std::string > > (std::string const &name) const
 
template<>
std::vector< std::string > ParameterSet::getUntrackedParameter< std::vector< std::string > > (char const *name, std::vector< std::string > const &defaultValue) const
 
template<>
std::vector< std::string > ParameterSet::getUntrackedParameter< std::vector< std::string > > (char const *name) const
 
template<>
std::vector< unsigned int > ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (std::string const &name) const
 
template<>
std::vector< unsigned int > ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (std::string const &name, std::vector< unsigned int > const &defaultValue) const
 
template<>
std::vector< unsigned int > ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (char const *name, std::vector< unsigned int > const &defaultValue) const
 
template<>
std::vector< unsigned int > ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (char const *name) const
 
template<>
std::vector< unsigned long long > ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (std::string const &name) const
 
template<>
std::vector< unsigned long long > ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (std::string const &name, std::vector< unsigned long long > const &defaultValue) const
 
template<>
std::vector< unsigned long long > ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (char const *name, std::vector< unsigned long long > const &defaultValue) const
 
template<>
std::vector< unsigned long long > ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (char const *name) const
 
std::string parameterTypeEnumToString (ParameterTypes iType)
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::string > ()
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::vector< double > > ()
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::vector< EventID > > ()
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::vector< EventRange > > ()
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::vector< InputTag > > ()
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::vector< int > > ()
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::vector< long long > > ()
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::vector< LuminosityBlockID > > ()
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::vector< LuminosityBlockRange > > ()
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::vector< std::string > > ()
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::vector< unsigned > > ()
 
template<>
ParameterTypes ParameterTypeToEnum::toEnum< std::vector< unsigned long long > > ()
 
template<typename T >
void const * pointerToBase (std::type_info const &baseTypeInfo, T const *address)
 
std::vector< ParameterSetpopSubProcessVParameterSet (ParameterSet &parameterSet)
 
static void postIndexIntoFilePrintEventLists (TFile *tfl, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
 
static void postIndexIntoFilePrintEventsInLumis (TFile *tfl, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
 
static void preIndexIntoFilePrintEventLists (TFile *, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
 
static void preIndexIntoFilePrintEventsInLumis (TFile *, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
 
template<typename S >
Sprint (S &os, JobReport::InputFile const &f)
 
template<typename S >
Sprint (S &os, JobReport::OutputFile const &f)
 
template<typename S >
Sprint (S &os, JobReport::RunReport const &rep)
 
template<typename RecordT >
void print_eventsetup_record_dependencies (std::ostream &oStream, std::string const &iIndent=std::string())
 
template<typename T >
void print_eventsetup_record_dependencies (std::ostream &, std::string, T const *, T const *)
 
template<typename TFirst , typename TEnd >
void print_eventsetup_record_dependencies (std::ostream &oStream, std::string iIndent, TFirst const *, TEnd const *iEnd)
 
template<typename RecordT >
void print_eventsetup_record_dependencies_recursive (std::ostream &oStream, std::string const &iIndent, boost::mpl::true_)
 
template<typename RecordT >
void print_eventsetup_record_dependencies_recursive (std::ostream &, std::string const &, boost::mpl::false_)
 
void printBranchNames (TTree *tree)
 
void printCmsException (cms::Exception &e, edm::JobReport *jobRep=nullptr, int rc=-1)
 
void printCmsExceptionWarning (char const *behavior, cms::Exception const &e)
 
void printEventLists (TFile *tfl)
 
void printEventsInLumis (TFile *tfl)
 
void printTrees (TFile *hdl)
 
void printUuids (TTree *uuidTree)
 
BranchID productIDToBranchID (ProductID const &pid, BranchIDLists const &lists, BranchListIndexes const &indexes)
 
bool public_base_classes (std::vector< std::string > &missingDictionaries, TypeID const &typeID, std::vector< TypeWithDict > &baseTypes)
 
std::string pythonFileToConfigure (const std::string &iPythonFileName)
 
void pythonToCppException (const std::string &iType)
 
void read_from_cin (std::string &output)
 
std::string read_whole_file (std::string const &filename)
 only does the yacc interpretation More...
 
std::shared_ptr< ParameterSetreadConfig (std::string const &config)
 
std::shared_ptr< ParameterSetreadConfig (std::string const &config, int argc, char *argv[])
 same, but with arguments More...
 
std::shared_ptr< ParameterSetreadPSetsFrom (std::string const &fileOrString)
 
void reenableSigs (sigset_t *oldset)
 
template<typename C >
Ptr< typename C::value_type > refToPtr (Ref< C, typename C::value_type, refhelper::FindUsingAdvance< C, typename C::value_type > > const &ref)
 
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)
 
void replaceString (std::string &demangledName, std::string const &from, std::string const &to)
 
void resolveSymbolicLinks (std::string &fullPath)
 
static const edm::ParameterSetDescriptionFillerPluginFactory::PMaker< edm::ParameterSetDescriptionFiller< HiMixingModule > > s_filler__LINE__ ("HiMixingModule")
 
static const edm::MakerPluginFactory::PMaker< edm::WorkerMaker< HiMixingModule > > s_maker__LINE__ ("HiMixingModule")
 
template<typename ForwardSequence , typename Datum >
bool search_all (ForwardSequence const &s, Datum const &d)
 
template<typename ForwardSequence , typename Predicate >
bool search_if_in_all (ForwardSequence const &s, Predicate const &p)
 
template<typename T , typename U >
second (std::pair< T, U > const &p)
 
static std::string const separator (":")
 
template<typename T >
void SetCustomStreamer ()
 
template<typename T >
void SetCustomStreamer (T const &)
 
void setMaxLoggedErrorsSummaryIndicies (unsigned int iMax)
 
template<typename T , typename A >
void setPtr (std::vector< T, A > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
 
template<typename T , typename A >
void setPtr (std::list< T, A > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
 
template<typename T , typename A >
void setPtr (std::deque< T, A > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
 
template<typename T , typename A , typename Comp >
void setPtr (std::set< T, A, Comp > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
 
template<typename T , typename SORT >
void setPtr (SortedCollection< T, SORT > const &obj, std::type_info const &toType, unsigned long index, void const *&ptr)
 
template<typename T , unsigned int M, typename P >
void setPtr (OwnArray< T, M, P > const &obj, std::type_info const &toType, unsigned long index, void const *&ptr)
 
template<typename T , typename P >
void setPtr (OwnVector< T, P > const &obj, std::type_info const &toType, unsigned long index, void const *&ptr)
 
void setRefCoreStreamer (bool resetAll=false)
 
EDProductGetter const * setRefCoreStreamer (EDProductGetter const *ep)
 
void setRefCoreStreamerInTClass ()
 
void setStandAloneMessageThreshold (edm::ELseverityLevel const &severity)
 
void sigInventory ()
 
template<typename RandomAccessSequence >
void sort_all (RandomAccessSequence &s)
 wrappers for std::sort More...
 
template<typename RandomAccessSequence , typename Predicate >
void sort_all (RandomAccessSequence &s, Predicate p)
 
std::vector< LuminosityBlockRange > & sortAndRemoveOverlaps (std::vector< LuminosityBlockRange > &lumiRange)
 
std::vector< EventRange > & sortAndRemoveOverlaps (std::vector< EventRange > &eventRange)
 
static std::string const source ("source")
 
template<class OutIter >
bool split (OutIter result, std::string const &string_to_split, char first, char sep, char last)
 
void squelchStandAloneMessageCategory (std::string const &category)
 
template<typename RandomAccessSequence >
void stable_sort_all (RandomAccessSequence &s)
 wrappers for std::stable_sort More...
 
template<typename RandomAccessSequence , typename Predicate >
void stable_sort_all (RandomAccessSequence &s, Predicate p)
 
std::string_view stemFromPath (std::string_view path)
 
std::string stripLeadingDirectoryTree (const std::string &file)
 
std::string stripNamespace (std::string const &theName)
 
bool stripTemplate (std::string &theName)
 
void subProcessDoGlobalBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, LuminosityBlockPrincipal &iPrincipal, IOVSyncValue const &iTS)
 
void subProcessDoGlobalBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, RunPrincipal &iPrincipal, IOVSyncValue const &iTS)
 
void subProcessDoGlobalEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, LuminosityBlockPrincipal &iPrincipal, IOVSyncValue const &iTS, bool cleaningUpAfterException)
 
void subProcessDoGlobalEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, RunPrincipal &iPrincipal, IOVSyncValue const &iTS, bool cleaningUpAfterException)
 
void subProcessDoStreamBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, LuminosityBlockPrincipal &iPrincipal, IOVSyncValue const &iTS)
 
void subProcessDoStreamBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, RunPrincipal &iPrincipal, IOVSyncValue const &iTS)
 
void subProcessDoStreamEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, LuminosityBlockPrincipal &iPrincipal, IOVSyncValue const &iTS, bool cleaningUpAfterException)
 
void subProcessDoStreamEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, RunPrincipal &iPrincipal, IOVSyncValue const &iTS, bool cleaningUpAfterException)
 
void swap (ProductID &a, ProductID &b)
 
void swap (Parentage &a, Parentage &b)
 
template<class T , class P >
void swap (CloningPtr< T, P > &a, CloningPtr< T, P > &b)
 
void swap (OrphanHandleBase &a, OrphanHandleBase &b)
 
void swap (ProductData &a, ProductData &b)
 
template<class T >
void swap (RefToBaseVector< T > &a, RefToBaseVector< T > &b)
 
void swap (ProcessHistory &a, ProcessHistory &b)
 
void swap (TriggerResults &lhs, TriggerResults &rhs)
 
void swap (ESHandleBase &a, ESHandleBase &b)
 
void swap (HLTGlobalStatus &lhs, HLTGlobalStatus &rhs)
 Free swap function. More...
 
template<typename C >
void swap (Association< C > &lhs, Association< C > &rhs)
 
template<class T >
void swap (DetSet< T > &a, DetSet< T > &b)
 
void swap (BasicHandle &a, BasicHandle &b)
 
void swap (HandleBase &a, HandleBase &b)
 
void swap (ErrorObj &a, ErrorObj &b)
 
void swap (FileInPath &a, FileInPath &b)
 
template<typename KEY >
void swap (RefVectorBase< KEY > &a, RefVectorBase< KEY > &b)
 swap two vectors More...
 
template<class T >
void swap (EDCollection< T > &a, EDCollection< T > &b)
 
void swap (edm::RefCore &lhs, edm::RefCore &rhs)
 
template<typename K , typename T >
void swap (MapOfVectors< K, T > &lhs, MapOfVectors< K, T > &rhs)
 
void swap (edm::RefCoreWithIndex &lhs, edm::RefCoreWithIndex &rhs)
 
template<typename C , typename T , typename F >
void swap (RefVector< C, T, F > &a, RefVector< C, T, F > &b)
 
template<typename T >
void swap (edm::RefToBaseProd< T > const &lhs, edm::RefToBaseProd< T > const &rhs)
 
template<typename ID , typename C , typename P >
void swap (IDVectorMap< ID, C, P > &a, IDVectorMap< ID, C, P > &b)
 
template<typename T >
void swap (value_ptr< T > &vp1, value_ptr< T > &vp2)
 
template<typename T >
void swap (PtrVector< T > &lhs, PtrVector< T > &rhs)
 
template<typename C >
void swap (RefProd< C > const &lhs, RefProd< C > const &rhs)
 
template<typename ID , typename C , typename P >
void swap (RangeMap< ID, C, P > &a, RangeMap< ID, C, P > &b)
 
void swap (DataFrameContainer &lhs, DataFrameContainer &rhs)
 
template<int I>
void swap (Hash< I > &a, Hash< I > &b)
 
template<typename T >
void swap (ValueMap< T > &lhs, ValueMap< T > &rhs)
 
template<typename KeyRefProd , typename CVal , typename KeyRef , typename SizeType , typename KeyReferenceHelper >
void swap (AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &a, AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &b)
 
template<typename T , typename C >
void swap (DetSetRefVector< T, C > &a, DetSetRefVector< T, C > &b)
 
template<typename C >
void swap (MultiAssociation< C > &lhs, MultiAssociation< C > &rhs)
 
void swap (ParameterSet &a, ParameterSet &b)
 
template<typename T >
void swap (View< T > &lhs, View< T > &rhs)
 
template<class T >
void swap (RefToBase< T > &a, RefToBase< T > &b)
 
template<typename T , typename SORT >
void swap (SortedCollection< T, SORT > &a, SortedCollection< T, SORT > &b)
 
template<typename T , unsigned int M, typename P >
void swap (OwnArray< T, M, P > &a, OwnArray< T, M, P > &b)
 
template<class T >
void swap (DetSetVector< T > &a, DetSetVector< T > &b)
 
template<typename T , typename P >
void swap (OwnVector< T, P > &a, OwnVector< T, P > &b)
 
static void throwAmbiguousException (const char *where, TypeID const &productType, std::string const &label, std::string const &instance, std::string const &process)
 
void throwExceptionWithText (char const *txt)
 
void throwMissingDictionariesException (std::vector< std::string > &missingDictionaries, std::string const &context)
 
void throwMissingDictionariesException (std::vector< std::string > &missingDictionaries, std::string const &context, std::vector< std::string > &producedTypes)
 
void throwMissingDictionariesException (std::vector< std::string > &missingDictionaries, std::string const &context, std::vector< std::string > &producedTypes, std::vector< std::string > &branchNames, bool fromStreamerSource=false)
 
void throwMissingDictionariesException (std::vector< std::string > &missingDictionaries, std::string const &context, std::set< std::string > &producedTypes, bool consumedWithView)
 
static void throwProductDeletedException (ProductID const &pid, edm::EventPrincipal::ConstProductResolverPtr const phb)
 
static void throwProductNotFoundException (char const *where, errors::ErrorCodes error, BranchID const &bid)
 
static void throwTypeException (std::string const &function, std::string const &typeName)
 
std::vector< std::string > tokenize (std::string const &input, std::string const &separator)
 breaks the input string into tokens, delimited by the separator More...
 
std::vector< std::string > tokenize (const std::string &input, const std::string &separator)
 
template<typename T >
boost::python::list toPythonList (const std::vector< T > &v)
 
template<typename T >
std::vector< TtoVector (boost::python::list &l)
 
static std::string const triggerResults ("TriggerResults")
 
static std::string const triggerResultsInserter ("TriggerResultsInserter")
 
template<typename T >
T const * tryToGetProductWithCoreFromRef (RefCore const &ref, EDProductGetter const *prodGetter)
 
std::string typeDemangle (char const *mangledName)
 
std::string uniqueSharedResourceName ()
 
bool untaintString (char const *pattern, char const *regexp)
 
void validateTopLevelParameterSets (ParameterSet *processParameterSet)
 
template<typename InputType , typename Function >
auto vector_transform (std::vector< InputType > const &input, Function predicate) -> std::vector< typename std::remove_cv< typename std::remove_reference< decltype(predicate(input.front()))>::type >::type >
 
template<typename V , typename T >
void walkTrie (V &v, TrieNode< T > const &n, std::string const &label="")
 visit each node of the trie More...
 
std::string withoutQuotes (std::string const &from)
 
std::string withoutQuotes (const std::string &from)
 
std::string wrappedClassName (std::string const &iFullName)
 

Variables

static int const bufSize = 128
 
debugvalue debugit
 
ELslProxy< ELdebugGen > const ELdebug
 
ELslGen ELdebugGen
 
ELslProxy< ELerrorGen > const ELerror
 
ELslGen ELerrorGen
 
ELslProxy< ELhighestSeverityGen > const ELhighestSeverity
 
ELslGen ELhighestSeverityGen
 
ELslProxy< ELinfoGen > const ELinfo
 
ELslGen ELinfoGen
 
ELslProxy< ELsevereGen > const ELsevere
 
ELslGen ELsevereGen
 
ELslProxy< ELunspecifiedGen > const ELunspecified
 
ELslGen ELunspecifiedGen
 
ELslProxy< ELwarningGen > const ELwarning
 
ELslGen ELwarningGen
 
ELslProxy< ELzeroSeverityGen > const ELzeroSeverity
 
ELslGen ELzeroSeverityGen
 
static char const * fmt_Guid
 
MallocOptionSetter global_malloc_options
 
EventNumber_t const invalidEventNumber = 0U
 
LuminosityBlockNumber_t const invalidLuminosityBlockNumber = 0U
 
RunNumber_t const invalidRunNumber = 0U
 
static unsigned long long const kAveEventPerSec = 200ULL
 
static unsigned long long const kNanoSecPerSec = 1000000000ULL
 
static const unsigned char MLSCRIBE_RUNNING_INDICATOR = 29
 
constexpr const char * module_type_desc []
 
constexpr unsigned int s_defaultNumberOfThreads = 1
 
static const std::vector< void const * > s_emptyCache {}
 
static ProcessHistory const s_emptyProcessHistory
 
static std::atomic< Principal::CacheIdentifier_ts_nextIdentifier {1}
 
thread_local EDProductGetter const * s_productGetter = 0
 
static unsigned int const shift = 8 * sizeof(unsigned int)
 
volatile std::atomic< bool > shutdown_flag {false}
 
static pset::TypeTrans const sTypeTranslations
 

Detailed Description

HLT enums.

why defined in namespace edm:: ?? (L.L.)

Register the record.

classes declaration

Find a non-event-data file, given a relative path.

This class manages the storage and retrieval of correlations between Alignables for the AlignmentParameterStore. This implementation does not stores the entries of the "big covariance matrix" itself, but the statistical correlations, i.e. R_ij=C_ij/sqrt(C_ii*C_jj) rather than C_ij.

If a correlation exceeds a certain value (especially corrupted correlations with an absolute value bigger than 1) it is downweighted.

This module is an source module reading continously file as they are copied in the input directory. The processed file is moved to directoryt inprocessDir before being processed. Once it is processed it is moved to processedDir. To prevent processing files before their transfer is finished, it is waited than file size is stable during one second before the file is processed. This protection is obviously not full proof, especially to transfer lag.

Description: Forward declare standard edm::fillPtrVector functions

Usage:

Description: Forward declare the standard setPtr functions

Usage:

Summary

The edm::FwdRef<> is a storable reference to an item in a stored "forward" container, which also contains a reference to an item in a "backward" container that the "forward" container is derived from.

For example, you could use one to hold a reference back to one particular track within a derived std::vector<> of tracks, but you want to keep the original Ref's to the original std::vector<> of tracks (for instance, if you've made a selection on the tracks in the list and want to remove the unnecessary ones from the event).

Usage

The edm::FwdRef<> works just like a pointer

edm::FwdRef<Foo> fooPtr = ... //set the value
functionTakingConstFoo(*fooPtr); //get the Foo object
fooPtr->bar(); //call a method of the held Foo object

The main purpose of an edm::FwdRef<> is it can be used as a member datum for a class that is to be stored in the edm::Event where the user can simultaneously check the "backwards" ref as well as the default "forward" ref.

Customization

The edm::FwdRef<> takes three template parameters, and both "forward" and "backward" refs must be the same types:

1) C: The type of the container which is holding the item

2) T: The type of the item. This defaults to C::value_type

3) F: A helper class (a functor) which knows how to find a particular 'T' within the container given an appropriate key. The type of the key is deduced from F::second_argument. The default for F is refhelper::FindTrait<C,T>::value. If no specialization of FindTrait<> is available for the combination (C,T) then it defaults to getting the iterator to be beginning of the container and using std::advance() to move to the appropriate key in the container.

It is possible to customize the 'lookup' algorithm used.

1) The helper class F should inherit from std::binary_function<const C&, typename IndexT, const T*> (or must provide the typedefs obtained from that inheritance directly).

2) The helper class F must define the function call operator in such a way that the following call is well-formed: f is an instance of type F coll is an instance of type C k is an instance of type F::key_type

     result_type r = f(coll,k);     

 If one wishes to make a specialized lookup the default lookup for
 the container/type pair then one needs to partially specialize
 the templated class edm::refhelper::FindTrait<C,T> such that it
 has a typedef named 'value' which refers to the specialized
 helper class (i.e., F)

 The class template FwdRef<C,T,F> supports 'null' references.

 -- a default-constructed FwdRef is 'null'; furthermore, it also
    has an invalid (or 'null') ProductID.
 -- a FwdRef constructed through the single-arguement constructor
    that takes a ProductID is also null.        

Definition of common HLT enums

Author
Martin Grunewald

Declaration of the enum HashedTypes, used in defining several "id" classes.

Author
W. David Dagenhart, created 1 August, 2014

Functions to return atomic properties of the material A_eff and Z_eff are computed as the A-weighted sums of the A's and the Z's of Pb, W and O

Author
Patrick Janot
Date
: 25-Jan-2004

Functions to return atomic properties of the material A_eff and Z_eff are computed as the A-weighted sums of the A's and the Z's of Cu and Zn (brass) - For now assume it is all Copper, and it'll be good enough.

Author
Patrick Janot
Date
: 25-Jan-2004

Parameters used in the hadron fast simulation

findDependentRecordsFor findDependentRecordsFor.h "findDependentRecordsFor.h"

Description: [one line class summary]

Usage: <usage>

getAllTriggerNames getAllTriggerNames.h "FWCore/Framework/interface/getAllTriggerNames.h"

Description: Returns a list of all the trigger names in the current process Usage: <usage>

edm::getProducerParameterSet

Description: Returns the ParameterSet of the module that produced the product corresponding to the Provenance.

This shouldn't ever fail if the Provenance and other objects it uses have been properly initialized, which should always be the case when called from a module using the Provenance from a Handle returned by a function like getByToken. If it does fail it will throw an exception.

Helper functions for making stream modules

Description: [one line class summary]

Usage: <usage>

globalTransitionAsync globalTransitionAsync.h "globalTransitionAsync.h"

Description: Helper functions for handling asynchronous global transitions

Usage: <usage>


This struct is used to communication parameters into the module factory.


-------------------------------------------------------------------—

streamTransitionAsync streamTransitionAsync.h "streamTransitionAsync.h"

Description: Helper functions for handling asynchronous stream transitions

Usage: <usage>

throwIfImproperDependencies throwIfImproperDependencies.h "throwIfImproperDependencies.h"

Description: Function which uses the graph of dependencies to determine if there are any cycles

Usage: <usage>


This struct is used to communication parameters into the worker factory.


Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

FileInPath knows how to take a string, interpreted as a relative path to a file, and to interpret using the "standard CMS non-event-data file searching mechanism".

The mechanism using the environment variables: CMSSW_SEARCH_PATH: may be set by the end-user CMSSW_RELEASE_BASE: should be set by a site administrator CMSSW_DATA_PATH: should be set by a site administrator

CMSSW_SEARCH_PATH is a 'search path' limited to 1 to 3 components. The legal values are:

  "." or "LOCAL", which means to search for files under
       the top level of the "local working area", which is
       defined as ${SCRAMRT_LOCALRT}/src

  "CMSSW_RELEASE_BASE", which means search the "official place",
        defined by the value of the CMSSW_RELEASE_BASE environment
        variable, for files.

  "CMSSW_DATA_PATH", which means search the "official place",
        defined by the value of the CMSSW_DATA_PATH environment
        variable, for files.

  ".:CMSSW_RELEASE_BASE" or "LOCAL:CMSSW_RELEASE_BASE",
         which means look first in the current working
         directory, then in the "official place", for files.

  ".:CMSSW_DATA_PATH" or "LOCAL:CMSSW_DATA_PATH",
         which means look first in the current working
         directory, then in the "official place", for files.

  ".:CMSSW_RELEASE_BASE:CMSSW_DATA_PATH" or "LOCAL:CMSSW_RELEASE_BASE:CMSSW_DATA_PATH",
         which means look first in the current working
         directory, then in both "official places", for files.

How ParameterSets are nested inside ParameterSets The main feature is that they're made persistent using a ParameterSetID, and only reconstituted as needed, when the value_ptr = 0;

A singleton for managing the plugin feedback function and assert hook function. It is unclear how this will react in a multithreaded application.

It is possible that in the future this object will allow arbitrary state object to be pushed in and pulled out so that when asserts occur, good state information can be printed.

connect_but_block_self connect_but_block_self.h FWCore/ServiceRegistry/interface/connect_but_block_self.h

Description: Connects a functional object to a signal, but guarantees that the functional object will never see a signal caused by its own action.

Usage: <usage>

Description: classes and functions used by edm::soa::Table

Usage: These are internal details of Table's implementation

This is the basic exception that is thrown by the framework code. It exists primarily to distinguish framework thrown exception types from developer thrown exception types. As such there is very little interface other than constructors specific to this derived type.

make_sentry make_sentry.h "FWCore/Utilities/interface/make_sentry.h"

Description: Creates a std::unique_ptr from a lambda to be used as a sentry

Usage: <usage>

A ThreadSafeRegistry is used to keep track of the instances of some type 'value_typed'. These objects are each associated with a given 'key_type' object, which must be retrievable from the value_type object, and which must uniquely identify the value_type's value.

This class is sufficiently thread-safe to be usable in a thread-safe manner. Don't let the name mislead you into thinking it provides more guarantee than that!

If 'm' is of type 'value_type const&', the expression

key_type k = m.id();

must be legal, and must return the unique key associated with the value of 'm'.

//////////////////////////////////////// Stacked Tracker Simulations /// Written by: /// Andrew W. Rose /// 2008 /// ////////////////////////////////////////

class HLTJetPairDzMatchFilter an HLT filter which picks up a JetCollection (supposedly, of L2 tau jets) and passes only events with at least one pair of non-overlapping jets with vertices within some dz

HLT filter by muon+track mass (taken from two RecoChargedCandidate collections). Tracks are subject to quality and momentum cuts. The match with previous muon (and possibly track, if run after another mass filter) candidates is checked.

Description: Producer for EcalRecHits to be used for pi0/eta ECAL calibration.

Implementation: <Notes on="" implementation>="">

See header file for a description of this class.

Author
Jo. Weng - CERN, Ph Division & Uni Karlsruhe
F.Moortgat - CERN, Ph Division

StreamSerializer.cc

Utility class for serializing framework objects (e.g. ProductRegistry and Event) into streamer message objects.

jet parton energy corrections

Author
Andrew W. Rose
Date
2013, Jul 12
Author
Andrew W. Rose
Date
2013, Jul 18

The ModelFilter class will select events in a "soup" MC (like the SUSY signal MC) from the comments of LHEEventProduct that match "modelTag". The user can require the value of that parameter to lie between a min and max value.

This is derived from EDFilterValueMapWrapper but rather than filtering it just stores a valuemap with the result

Description: simple NxN ( 3x3 etc) clustering ,( for low energy photon reconstrution, currently used for pi0/eta HLT path)

Implementation: <Notes on="" implementation>="">

A HitTripletGenerator from HitPairGenerator and vector of Layers. The HitPairGenerator provides a set of hit pairs. For each pair the search for compatible hit(s) is done among provided Layers

A MultiHitGenerator from HitPairGenerator and vector of Layers. The HitPairGenerator provides a set of hit pairs. For each pair the search for compatible hit(s) is done among provided Layers


class: BeamFitter.h package: RecoVertex/BeamSpotProducer

author: Francisco Yumiceva, Fermilab (yumic.nosp@m.eva@.nosp@m.fnal..nosp@m.gov) Geng-Yuan Jeng, UC Riverside (Geng-.nosp@m.Yuan.nosp@m..Jeng.nosp@m.@cer.nosp@m.n.ch)



class: PVFitter.h package: RecoVertex/BeamSpotProducer

author: Francisco Yumiceva, Fermilab (yumic.nosp@m.eva@.nosp@m.fnal..nosp@m.gov) Geng-Yuan Jeng, UC Riverside (Geng-.nosp@m.Yuan.nosp@m..Jeng.nosp@m.@cer.nosp@m.n.ch)


Converts digis back into analog signals, to be used as noise

Typedef Documentation

template<typename T >
using edm::AlignedVec = typedef Aligned<T,16>

Definition at line 104 of file SoATuple.h.

typedef unsigned int edm::BranchDescriptionIndex

Definition at line 28 of file BranchDescriptionIndex.h.

Definition at line 18 of file BranchIDList.h.

typedef std::vector<BranchIDList> edm::BranchIDLists

Definition at line 19 of file BranchIDList.h.

typedef unsigned short edm::BranchListIndex

Definition at line 17 of file BranchListIndex.h.

Definition at line 18 of file BranchListIndex.h.

typedef void(* edm::CFUNC) (int, siginfo_t *, void *)

Definition at line 20 of file UnixSignalHandlers.h.

Definition at line 13 of file CTPPSFastRecHitContainer.h.

Definition at line 11 of file CTPPSFastTrackContainer.h.

typedef DigiAccumulatorMixMod*( edm::DAFunc) (ParameterSet const &, ProducerBase &, ConsumesCollector &)

Definition at line 12 of file DigiAccumulatorMixModFactory.h.

typedef uint32_t edm::det_id_type

Definition at line 21 of file DetSet.h.

Definition at line 13 of file DigiAccumulatorMixModFactory.h.

typedef std::list<ELdestination *> edm::ELlist_dest

Definition at line 39 of file ELlist.h.

Definition at line 42 of file ELlist.h.

typedef std::map< ELstring const, ELseverityLevel::ELsev_ > edm::ELmap

Definition at line 59 of file ELseverityLevel.cc.

Definition at line 101 of file ELmap.h.

Definition at line 99 of file ELmap.h.

typedef std::map< ELextendedID , StatsCount > edm::ELmap_stats

Definition at line 103 of file ELmap.h.

typedef ELseverityLevel const edm::ELslGen()

Definition at line 61 of file ELseverityLevel.h.

typedef std::string edm::ELstring

Definition at line 26 of file ELstring.h.

Definition at line 9 of file EntryDescriptionID.h.

Definition at line 51 of file RootFile.h.

Definition at line 57 of file EventEntryInfo.h.

typedef unsigned long long edm::EventNumber_t

Definition at line 12 of file RunLumiEventNumber.h.

Definition at line 16 of file EventSelectionID.h.

Definition at line 17 of file EventSelectionID.h.

typedef std::vector<std::pair<edm::ProductID,unsigned long> > edm::FillViewHelperVector

Definition at line 30 of file FillViewHelperVector.h.

Definition at line 140 of file FWGenericHandle.h.

Definition at line 132 of file GenericHandle.h.

typedef long long int edm::HRTimeDiffType

Definition at line 97 of file HRRealTime.h.

typedef unsigned long long int edm::HRTimeType

Definition at line 98 of file HRRealTime.h.

Definition at line 14 of file InputSourceFactory.h.

typedef InputSource*( edm::ISFunc) (ParameterSet const &, InputSourceDescription const &)

Definition at line 12 of file InputSourceFactory.h.

typedef VectorInputSource*( edm::ISVecFunc) (ParameterSet const &, VectorInputSourceDescription const &)

Definition at line 14 of file VectorInputSourceFactory.h.

Definition at line 8 of file LHCTransportLinkContainer.h.

Definition at line 49 of file RunLumiEntryInfo.h.

typedef unsigned int edm::LuminosityBlockNumber_t

Definition at line 13 of file RunLumiEventNumber.h.

Definition at line 16 of file Factory.h.

Definition at line 58 of file classes.h.

Definition at line 30 of file ParameterSetDescriptionFillerPluginFactory.h.

Definition at line 22 of file ParameterSetID.h.

Definition at line 40 of file ParameterSetConverter.h.

Definition at line 9 of file ParentageID.h.

typedef std::string edm::PassID

Definition at line 8 of file PassID.h.

typedef std::vector<PassiveHit> edm::PassiveHitContainer

Definition at line 60 of file PassiveHit.h.

using edm::PathStatus = typedef HLTPathStatus

Definition at line 7 of file PathStatus.h.

typedef std::vector<PCaloHit> edm::PCaloHitContainer

Definition at line 8 of file PCaloHitContainer.h.

Definition at line 13 of file ConfigurationHandshake.h.

Definition at line 10 of file ConfigurationHandshake.h.

typedef Presence*( edm::PresenceFunc) ()

Definition at line 13 of file PresenceFactory.h.

Definition at line 11 of file PresenceFactory.h.

Definition at line 9 of file ProcessConfigurationID.h.

Definition at line 64 of file ProcessConfiguration.h.

Definition at line 9 of file ProcessHistoryID.h.

Definition at line 15 of file ProcessHistoryRegistry.h.

Definition at line 16 of file ProcessHistoryRegistry.h.

typedef unsigned short edm::ProcessIndex

Definition at line 25 of file ProductID.h.

typedef std::string edm::ProcessingTask

Definition at line 8 of file ProcessingTask.h.

typedef unsigned short edm::ProductIndex

Definition at line 26 of file ProductID.h.

Definition at line 67 of file ProductProvenance.h.

typedef unsigned int edm::ProductResolverIndex

Definition at line 8 of file ProductResolverIndex.h.

typedef std::vector<PSimHit> edm::PSimHitContainer

Definition at line 11 of file PSimHitContainer.h.

Definition at line 30 of file ESProxyFactoryProducer.cc.

typedef std::string edm::ReleaseVersion

Definition at line 7 of file ReleaseVersion.h.

Definition at line 50 of file RunLumiEntryInfo.h.

typedef unsigned int edm::RunNumber_t

Definition at line 14 of file RunLumiEventNumber.h.

typedef std::vector<std::pair<BranchDescription const *, EDGetToken> > edm::SelectedProducts

Definition at line 11 of file SelectedProducts.h.

Definition at line 13 of file SelectedProducts.h.

typedef std::vector<BranchDescription> edm::SendDescs

Definition at line 99 of file StreamedProducts.h.

typedef std::vector<StreamedProduct> edm::SendProds

Definition at line 67 of file StreamedProducts.h.

typedef std::vector<SimTrack> edm::SimTrackContainer

Definition at line 12 of file SimTrackContainer.h.

typedef std::vector<SimVertex> edm::SimVertexContainer

Definition at line 13 of file SimVertexContainer.h.

typedef edm::Ref<std::vector<SimVertex> > edm::SimVertexRef

Definition at line 14 of file SimVertexContainer.h.

Definition at line 15 of file SimVertexContainer.h.

Definition at line 16 of file SimVertexContainer.h.

Definition at line 34 of file StoredProductProvenance.h.

using edm::Strings = typedef EventSelector::Strings

Definition at line 50 of file EventSelector.cc.

typedef std::vector<std::string> edm::StringVector

Definition at line 17 of file ParameterSetConverter.h.

typedef unsigned long long edm::TimeValue_t

Definition at line 28 of file Timestamp.h.

Definition at line 49 of file OutputModule.h.

typedef std::map<std::string, char> edm::Type2Code

Definition at line 79 of file Entry.cc.

typedef std::vector< edm::BranchDescription const * > edm::VCBDP

Definition at line 17 of file ProductSelector.cc.

Definition at line 15 of file VectorInputSourceFactory.h.

typedef std::vector<ParameterSet> edm::VParameterSet

Definition at line 33 of file ParameterSet.h.

typedef std::vector< std::string > edm::vstring

Definition at line 430 of file Schedule.cc.

Enumeration Type Documentation

Enumerator
BranchActionGlobalBegin 
BranchActionStreamBegin 
BranchActionStreamEnd 
BranchActionGlobalEnd 

Definition at line 11 of file BranchActionType.h.

Enumerator
InEvent 
InLumi 
InRun 
NumBranchTypes 

Definition at line 11 of file BranchType.h.

11  {
12  InEvent = 0,
13  InLumi = 1,
14  InRun = 2,
16  };
enum edm::EDMModuleType
strong
Enumerator
kUnknown 
kSource 
kESSource 
kESProducer 
kEDAnalyzer 
kEDProducer 
kEDFilter 
kOutputModule 

Definition at line 8 of file EDMModuleType.h.

Enumerator
ModuleDescriptionType 
ParameterSetType 
ProcessHistoryType 
ProcessConfigurationType 
EntryDescriptionType 
ParentageType 

Definition at line 10 of file HashedTypes.h.

enum edm::InputType
strong
Enumerator
Primary 
SecondaryFile 
SecondarySource 

Definition at line 5 of file InputType.h.

Enumerator
GridJobMode 
ReleaseValidationJobMode 
AnalysisJobMode 
NilJobMode 

Definition at line 15 of file JobMode.h.

Enumerator
PRODUCT_TYPE 
ELEMENT_TYPE 

Definition at line 5 of file ProductKindOfType.h.

Enumerator
k_int32 
k_vint32 
k_uint32 
k_vuint32 
k_int64 
k_vint64 
k_uint64 
k_vuint64 
k_double 
k_vdouble 
k_bool 
k_string 
k_vstring 
k_EventID 
k_VEventID 
k_LuminosityBlockID 
k_VLuminosityBlockID 
k_InputTag 
k_VInputTag 
k_FileInPath 
k_LuminosityBlockRange 
k_VLuminosityBlockRange 
k_EventRange 
k_VEventRange 
k_PSet 
k_VPSet 

Definition at line 32 of file ParameterDescriptionNode.h.

32  {
33  k_int32 = 'I',
34  k_vint32 = 'i',
35  k_uint32 = 'U',
36  k_vuint32 = 'u',
37  k_int64 = 'L',
38  k_vint64 = 'l',
39  k_uint64 = 'X',
40  k_vuint64 = 'x',
41  k_double = 'D',
42  k_vdouble = 'd',
43  k_bool = 'B',
44  k_string = 'S',
45  k_vstring = 's',
46  k_EventID = 'E',
47  k_VEventID = 'e',
48  k_LuminosityBlockID = 'M',
50  k_InputTag = 't',
51  k_VInputTag = 'v',
52  k_FileInPath = 'F',
55  k_EventRange = 'R',
56  k_VEventRange = 'r',
57  k_PSet = 'Q',
58  k_VPSet = 'q'
59  };
Enumerator
ProductResolverIndexValuesBit 
ProductResolverIndexInvalid 
ProductResolverIndexInitializing 
ProductResolverIndexAmbiguous 

Definition at line 10 of file ProductResolverIndex.h.

Enumerator
ExceptionFromThisContext 
ExceptionFromAnotherContext 
ExternalSignal 

Definition at line 28 of file TerminationOrigin.h.

enum edm::Transition
strong
Enumerator
Event 
BeginLuminosityBlock 
EndLuminosityBlock 
BeginRun 
EndRun 

Definition at line 12 of file Transition.h.

Enumerator
Silent 
Concise 
Normal 
Detailed 

Definition at line 5 of file Verbosity.h.

5  {
6  Silent=0,
7  Concise=2,
8  Normal=5,
9  Detailed=10
10  };
Enumerator
RequireZeroOrMore 
RequireAtLeastOne 
RequireExactlyOne 

Definition at line 18 of file ParameterWildcardBase.h.

Function Documentation

void edm::addContextAndPrintException ( char const *  context,
cms::Exception ex,
bool  disablePrint 
)

Definition at line 12 of file ExceptionHelpers.cc.

References cms::Exception::addContext(), edm::Service< T >::isAvailable(), printCmsException(), cms::Exception::returnCode(), cms::Exception::setAlreadyPrinted(), and mitigatedMETSequence_cff::U.

Referenced by callWithTryCatchAndPrint(), edm::StreamSchedule::finishProcessOneEvent(), edm::GlobalSchedule::processOneGlobalAsync(), edm::WorkerManager::processOneOccurrence(), and edm::StreamSchedule::processOneStreamAsync().

14  {
15  if (context != nullptr && strlen(context) != 0U) {
16  ex.addContext(context);
17  }
18  if (!disablePrint) {
19  Service<JobReport> jobReportSvc;
20  if (jobReportSvc.isAvailable()) {
21  JobReport *jobRep = jobReportSvc.operator->();
22  edm::printCmsException(ex, jobRep, ex.returnCode());
23  }
24  else {
26  }
27  ex.setAlreadyPrinted(true);
28  }
29  }
void setAlreadyPrinted(bool value)
Definition: Exception.cc:255
void printCmsException(cms::Exception &e, edm::JobReport *jobRep=nullptr, int rc=-1)
void addContext(std::string const &context)
Definition: Exception.cc:227
int returnCode() const
Definition: Exception.cc:199
void edm::addToMissingDictionariesException ( edm::Exception exception,
std::vector< std::string > &  missingDictionaries,
std::string const &  context 
)

Definition at line 177 of file DictionaryTools.cc.

References cms::Exception::addContext(), and tier0::unique().

Referenced by throwMissingDictionariesException().

179  {
180 
181  std::sort(missingDictionaries.begin(), missingDictionaries.end());
182  missingDictionaries.erase(std::unique(missingDictionaries.begin(), missingDictionaries.end()), missingDictionaries.end());
183 
184  std::ostringstream ostr;
185  for(auto const& item : missingDictionaries) {
186  ostr << " " << item << "\n";
187  }
188  exception << "No data dictionary found for the following classes:\n\n"
189  << ostr.str() << "\n"
190  << "Most likely each dictionary was never generated, but it may\n"
191  << "be that it was generated in the wrong package. Please add\n"
192  << "(or move) the specification \'<class name=\"whatever\"/>\' to\n"
193  << "the appropriate classes_def.xml file along with any other\n"
194  << "information needed there. For example, if this class has any\n"
195  << "transient members, you need to specify them in classes_def.xml.\n"
196  << "Also include the class header in classes.h\n";
197 
198  if (!context.empty()) {
199  exception.addContext(context);
200  }
201  }
def unique(seq, keepstr=True)
Definition: tier0.py:24
void addContext(std::string const &context)
Definition: Exception.cc:227
static std::string edm::appendCurrentProcessIfAlias ( std::string const &  processFromInputTag,
std::string const &  currentProcess 
)
static

Definition at line 37 of file Principal.cc.

References edm::InputTag::kCurrentProcess, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::Principal::findProductByLabel(), and edm::Principal::getByLabel().

37  {
38  if (processFromInputTag == InputTag::kCurrentProcess) {
39  std::string returnValue = processFromInputTag;
40  returnValue += " (";
41  returnValue += currentProcess;
42  returnValue += ")";
43  return returnValue;
44  }
45  return processFromInputTag;
46  }
template<class FP >
bool edm::asm_isnan ( FP  x)
inline

Definition at line 43 of file math.h.

References flags.

44  {
45  // I do not know of a preprocessor symbol used to identify the
46  // presence of an x87 floating-point processor.
47 #if defined(__i386__)||defined(__x86_64)
48  u_int16_t flags;
49  __asm__("fxam\n\t"
50  "fstsw %%ax"
51  : "=a" (flags) /* output */
52  : "t" (x) /* input */
53  : /* clobbered */
54  );
55  return (flags & 0x4500)==0x0100;
56 #else
57  #error No asm_isnan for this architecture.
58 #endif
59  }
std::vector< Variable::Flags > flags
Definition: MVATrainer.cc:135
template<typename Traits , typename P , typename SC >
void edm::beginGlobalTransitionAsync ( WaitingTaskHolder  iWait,
Schedule iSchedule,
P iPrincipal,
IOVSyncValue const &  iTS,
EventSetup const &  iES,
ServiceToken const &  token,
SC &  iSubProcesses 
)

Definition at line 55 of file globalTransitionAsync.h.

References edm::WaitingTaskHolder::doneWaiting(), h, make_waiting_task(), eostools::move(), edm::Schedule::processOneGlobalAsync(), and subProcessDoGlobalBeginTransitionAsync().

61  {
62 
63  //When we are done processing the global for this process,
64  // we need to run the global for all SubProcesses
65  auto subs = make_waiting_task(tbb::task::allocate_root(), [&iSubProcesses, iWait,&iPrincipal,iTS](std::exception_ptr const* iPtr) mutable {
66  if(iPtr) {
67  auto excpt = *iPtr;
68  auto delayError = make_waiting_task(tbb::task::allocate_root(), [iWait,excpt](std::exception_ptr const* ) mutable {
69  iWait.doneWaiting(excpt);
70  });
71  WaitingTaskHolder h(delayError);
72  for(auto& subProcess: iSubProcesses) {
73  subProcessDoGlobalBeginTransitionAsync(h,subProcess,iPrincipal, iTS);
74  }
75  } else {
76  for(auto& subProcess:iSubProcesses){
77  subProcessDoGlobalBeginTransitionAsync(iWait,subProcess,iPrincipal, iTS);
78  }
79  }
80  });
81 
82  WaitingTaskHolder h(subs);
83  iSchedule.processOneGlobalAsync<Traits>(std::move(h),iPrincipal, iES,token);
84  }
FWCore Framework interface EventSetupRecordImplementation h
Helper function to determine trigger accepts.
void subProcessDoGlobalBeginTransitionAsync(WaitingTaskHolder iHolder, SubProcess &iSubProcess, RunPrincipal &iPrincipal, IOVSyncValue const &iTS)
FunctorWaitingTask< F > * make_waiting_task(ALLOC &&iAlloc, F f)
Definition: WaitingTask.h:92
def move(src, dest)
Definition: eostools.py:510
template<typename Traits , typename P , typename SC >
void edm::beginStreamsTransitionAsync ( WaitingTask iWait,
Schedule iSchedule,
unsigned int  iNStreams,
P iPrincipal,
IOVSyncValue const &  iTS,
EventSetup const &  iES,
ServiceToken const &  token,
SC &  iSubProcesses 
)

Definition at line 91 of file streamTransitionAsync.h.

References mps_fire::i.

99  {
100  WaitingTaskHolder holdUntilAllStreamsCalled(iWait);
101  for(unsigned int i=0; i<iNStreams;++i) {
102  beginStreamTransitionAsync<Traits>(WaitingTaskHolder(iWait), iSchedule,i,iPrincipal,iTS,iES,token, iSubProcesses);
103  }
104  }
template<typename Traits , typename P , typename SC >
void edm::beginStreamTransitionAsync ( WaitingTaskHolder  iWait,
Schedule iSchedule,
unsigned int  iStreamIndex,
P iPrincipal,
IOVSyncValue const &  iTS,
EventSetup const &  iES,
ServiceToken const &  token,
SC &  iSubProcesses 
)

Definition at line 56 of file streamTransitionAsync.h.

References edm::WaitingTaskHolder::doneWaiting(), h, make_waiting_task(), eostools::move(), edm::Schedule::processOneStreamAsync(), and subProcessDoStreamBeginTransitionAsync().

63  {
64  //When we are done processing the stream for this process,
65  // we need to run the stream for all SubProcesses
66  //NOTE: The subprocesses set their own service tokens
67  auto subs = make_waiting_task(tbb::task::allocate_root(), [&iSubProcesses, iWait,iStreamIndex,&iPrincipal,iTS](std::exception_ptr const* iPtr) mutable {
68  if(iPtr) {
69  auto excpt = *iPtr;
70  auto delayError = make_waiting_task(tbb::task::allocate_root(), [iWait,excpt](std::exception_ptr const* ) mutable {
71  iWait.doneWaiting(excpt);
72  });
73  WaitingTaskHolder h(delayError);
74  for(auto& subProcess: iSubProcesses){
75  subProcessDoStreamBeginTransitionAsync(h,subProcess,iStreamIndex,iPrincipal, iTS);
76 
77  };
78  } else {
79  for(auto& subProcess: iSubProcesses){
80  subProcessDoStreamBeginTransitionAsync(iWait,subProcess,iStreamIndex,iPrincipal, iTS);
81  };
82  }
83  });
84 
85  WaitingTaskHolder h(subs);
86  iSchedule.processOneStreamAsync<Traits>(std::move(h), iStreamIndex,iPrincipal, iES,token);
87  }
FWCore Framework interface EventSetupRecordImplementation h
Helper function to determine trigger accepts.
void subProcessDoStreamBeginTransitionAsync(WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, RunPrincipal &iPrincipal, IOVSyncValue const &iTS)
FunctorWaitingTask< F > * make_waiting_task(ALLOC &&iAlloc, F f)
Definition: WaitingTask.h:92
def move(src, dest)
Definition: eostools.py:510
template<typename ForwardSequence , typename Datum >
bool edm::binary_search_all ( ForwardSequence const &  s,
Datum const &  d 
)
inline
template<typename ForwardSequence , typename Datum , typename Predicate >
bool edm::binary_search_all ( ForwardSequence const &  s,
Datum const &  d,
Predicate  p 
)
inline

Definition at line 83 of file Algorithms.h.

References edmIntegrityCheck::d, and AlCaHLTBitMon_ParallelJobs::p.

83  {
84  return std::binary_search(s.begin(), s.end(), d, p);
85  }
std::string const & edm::BranchTypeToAuxBranchName ( BranchType const &  branchType)

Definition at line 119 of file BranchType.cc.

References InEvent, and InRun.

Referenced by fwlite::Event::Event().

119  { // backward compatibility
120  return ((branchType == InEvent) ? eventAux : ((branchType == InRun) ? runAux : lumiAux)); // backward compatibility
121  } // backward compatibility
def branchType(schema, name)
Definition: revisionDML.py:112
std::string const & edm::BranchTypeToAuxiliaryBranchName ( BranchType const &  branchType)
std::string const & edm::BranchTypeToBranchEntryInfoBranchName ( BranchType const &  branchType)

Definition at line 127 of file BranchType.cc.

References InEvent, and InRun.

Referenced by fwlite::internal::BranchMapReaderStrategyV8::updateFile(), and ProvenanceDumper::work_().

127  {
128  return ((branchType == InEvent) ? eventEventEntryInfo : ((branchType == InRun) ? runEventEntryInfo : lumiEventEntryInfo));
129  }
def branchType(schema, name)
Definition: revisionDML.py:112
std::string const & edm::BranchTypeToInfoTreeName ( BranchType const &  branchType)

Definition at line 111 of file BranchType.cc.

References dumpTauVariables_cfi::eventInfo, InEvent, InRun, and pileupCalc::lumiInfo.

Referenced by edm::RootTree::RootTree().

111  { // backward compatibility
112  return ((branchType == InEvent) ? eventInfo : ((branchType == InRun) ? runInfo : lumiInfo)); // backward compatibility
113  } // backward compatibility
eventInfo
add run, event number and lumi section
def branchType(schema, name)
Definition: revisionDML.py:112
std::string const & edm::BranchTypeToMajorIndexName ( BranchType const &  branchType)

Definition at line 135 of file BranchType.cc.

References InEvent, and InRun.

135  {
136  return ((branchType == InEvent) ? eventMajorIndex : ((branchType == InRun) ? runMajorIndex : lumiMajorIndex));
137  }
def branchType(schema, name)
Definition: revisionDML.py:112
std::string const & edm::BranchTypeToMetaDataTreeName ( BranchType const &  branchType)

Definition at line 107 of file BranchType.cc.

References InEvent, and InRun.

Referenced by ProvenanceDumper::work_().

107  {
108  return ((branchType == InEvent) ? eventMeta : ((branchType == InRun) ? runMeta : lumiMeta));
109  }
def branchType(schema, name)
Definition: revisionDML.py:112
std::string const & edm::BranchTypeToMinorIndexName ( BranchType const &  branchType)

Definition at line 139 of file BranchType.cc.

References InEvent, and InRun.

139  {
140  return ((branchType == InEvent) ? eventMinorIndex : ((branchType == InRun) ? runMinorIndex : lumiMinorIndex));
141  }
def branchType(schema, name)
Definition: revisionDML.py:112
std::string const & edm::BranchTypeToProductProvenanceBranchName ( BranchType const &  BranchType)

Definition at line 131 of file BranchType.cc.

References InEvent, and InRun.

Referenced by edm::ReducedProvenanceReader::ReducedProvenanceReader(), edm::RootOutputFile::RootOutputFile(), and ProvenanceDumper::work_().

131  {
132  return ((branchType == InEvent) ? eventProductProvenance : ((branchType == InRun) ? runProductProvenance : lumiProductProvenance));
133  }
def branchType(schema, name)
Definition: revisionDML.py:112
std::string const & edm::BranchTypeToProductStatusBranchName ( BranchType const &  branchType)

Definition at line 123 of file BranchType.cc.

References InEvent, and InRun.

123  { // backward compatibility
124  return ((branchType == InEvent) ? eventProductStatus : ((branchType == InRun) ? runProductStatus : lumiProductStatus)); // backward compatibility
125  } // backward compatibility
def branchType(schema, name)
Definition: revisionDML.py:112
std::string const & edm::BranchTypeToProductTreeName ( BranchType const &  branchType)
std::string const & edm::BranchTypeToString ( BranchType const &  branchType)

Definition at line 99 of file BranchType.cc.

References InEvent, InRun, and findQualityFiles::run.

Referenced by operator<<(), and edm::EDConsumerBase::throwBranchMismatch().

99  {
100  return ((branchType == InEvent) ? event : ((branchType == InRun) ? run : lumi));
101  }
def branchType(schema, name)
Definition: revisionDML.py:112
Definition: event.py:1
template<typename TReturn >
TReturn edm::callWithTryCatchAndPrint ( std::function< TReturn(void)>  iFunc,
char const *  context = 0,
bool  disablePrint = false 
)

Definition at line 51 of file ExceptionHelpers.h.

References addContextAndPrintException(), and edm::convertException::wrap().

53  {
54 
55  try {
56  return convertException::wrap([iFunc]() {
57  return iFunc();
58  });
59  }
60  catch(cms::Exception& ex) {
61  addContextAndPrintException(context, ex, disablePrint);
62  throw;
63  }
64  return TReturn();
65  }
void addContextAndPrintException(char const *context, cms::Exception &ex, bool disablePrint)
auto wrap(F iFunc) -> decltype(iFunc())
template<typename T >
static void edm::check ( T const &  p,
std::string const &  id,
SelectedProducts const &  iProducts 
)
static

Definition at line 83 of file GetProductCheckerOutputModule.cc.

References edm::Provenance::branchDescription(), edm::BranchDescription::branchID(), Exception, edm::BranchDescription::moduleLabel(), edm::BranchDescription::processName(), edm::BranchDescription::productInstanceName(), edm::BasicHandle::provenance(), and edm::BranchDescription::unwrappedTypeID().

Referenced by SegmentsTrackAssociator::associate(), L1TMenuHelper::getLUSOTrigger(), edm::StreamerInputFile::openStreamerFile(), fwlite::Handle< Collection >::operator*(), fwlite::Handle< Collection >::operator->(), fwlite::Handle< Collection >::product(), fwlite::Handle< Collection >::ptr(), edm::DataMixingMuonWorker::putMuon(), amc13::Header::raw(), amc13::Trailer::raw(), fwlite::Handle< Collection >::ref(), edm::GetProductCheckerOutputModule::write(), edm::GetProductCheckerOutputModule::writeLuminosityBlock(), and edm::GetProductCheckerOutputModule::writeRun().

83  {
84  for(auto const& product : iProducts) {
85  BranchDescription const* branchDescription = product.first;
86  TypeID const& tid = branchDescription->unwrappedTypeID();
87  EDGetToken const& token = product.second;
88  BasicHandle bh;
89  p.getByToken(token, tid, bh);
90  if(nullptr != bh.provenance() && bh.provenance()->branchDescription().branchID() != branchDescription->branchID()) {
91  throw cms::Exception("BranchIDMissMatch") << "While processing " << id << " getByToken request for " << branchDescription->moduleLabel()
92  << " '" << branchDescription->productInstanceName() << "' " << branchDescription->processName()
93  << "\n should have returned BranchID " << branchDescription->branchID() << " but returned BranchID " << bh.provenance()->branchDescription().branchID() << "\n";
94  }
95  }
96  }
bool edm::checkClassDictionaries ( std::vector< std::string > &  missingDictionaries,
TypeID const &  typeID 
)

Definition at line 109 of file DictionaryTools.cc.

References edm::TypeWithDict::byName(), GetRecoTauVFromDQM_MC_cff::cl, edm::TypeID::className(), hasDictionary(), mps_fire::result, and edm::TypeIDBase::typeInfo().

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::ProductRegistry::checkDictionariesOfConsumedTypes(), edm::ProductRegistry::initializeLookupTables(), and loadCap().

110  {
111 
112  // For a class type with a dictionary the TClass* will be
113  // non-null and hasDictionary will return true.
114  // For a type like "int", the TClass* pointer will be a
115  // nullptr and hasDictionary will return true.
116  // For a class type without a dictionary it is possible for
117  // TClass* to be non-null and hasDictionary to return false.
118 
119  TClass* tClass = TClass::GetClass(typeID.typeInfo());
120  if (!hasDictionary(typeID.typeInfo())) {
121  // a second attempt to load
122  TypeWithDict::byName(typeID.className());
123  tClass = TClass::GetClass(typeID.typeInfo());
124  }
125  if (!hasDictionary(typeID.typeInfo())) {
126  missingDictionaries.emplace_back(typeID.className());
127  return false;
128  }
129 
130  if (tClass == nullptr) {
131  return true;
132  }
133 
134  bool result = true;
135 
136  THashTable hashTable;
137  bool recursive = true;
138  tClass->GetMissingDictionaries(hashTable, recursive);
139 
140  for(auto const& item : hashTable) {
141  TClass const* cl = static_cast<TClass const*>(item);
142  missingDictionaries.emplace_back(cl->GetName());
143  result = false;
144  }
145  return result;
146  }
bool hasDictionary(std::type_info const &)
bool edm::checkClassDictionaries ( std::vector< std::string > &  missingDictionaries,
std::string const &  name,
TypeWithDict const &  typeWithDict 
)

Definition at line 149 of file DictionaryTools.cc.

References GetRecoTauVFromDQM_MC_cff::cl, edm::TypeWithDict::getClass(), edm::TypeWithDict::invalidTypeInfo(), and mps_fire::result.

151  {
152  if (!bool(typeWithDict) || typeWithDict.invalidTypeInfo()) {
153  missingDictionaries.emplace_back(name);
154  return false;
155  }
156 
157  TClass *tClass = typeWithDict.getClass();
158  if (tClass == nullptr) {
159  missingDictionaries.emplace_back(name);
160  return false;
161  }
162 
163  THashTable hashTable;
164  bool recursive = true;
165  tClass->GetMissingDictionaries(hashTable, recursive);
166 
167  bool result = true;
168 
169  for(auto const& item : hashTable) {
170  TClass const* cl = static_cast<TClass const*>(item);
171  missingDictionaries.emplace_back(cl->GetName());
172  result = false;
173  }
174  return result;
175  }
bool edm::checkDictionary ( std::vector< std::string > &  missingDictionaries,
TypeID const &  typeID 
)

Definition at line 68 of file DictionaryTools.cc.

References edm::TypeWithDict::byName(), edm::TypeID::className(), hasDictionary(), and edm::TypeIDBase::typeInfo().

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::ProductRegistry::checkDictionariesOfConsumedTypes(), checkDictionaryOfWrappedType(), edm::ProductRegistry::initializeLookupTables(), edm::OutputModule::keepThisBranch(), edm::one::OutputModuleBase::keepThisBranch(), and public_base_classes().

69  {
70 
71  TClass::GetClass(typeID.typeInfo());
72  if (!hasDictionary(typeID.typeInfo())) {
73  // a second attempt to load
74  TypeWithDict::byName(typeID.className());
75  }
76  if (!hasDictionary(typeID.typeInfo())) {
77  missingDictionaries.emplace_back(typeID.className());
78  return false;
79  }
80  return true;
81  }
bool hasDictionary(std::type_info const &)
bool edm::checkDictionary ( std::vector< std::string > &  missingDictionaries,
std::string const &  name,
TypeWithDict const &  typeWithDict 
)

Definition at line 98 of file DictionaryTools.cc.

References edm::TypeWithDict::invalidTypeInfo().

100  {
101  if (!bool(typeWithDict) || typeWithDict.invalidTypeInfo()) {
102  missingDictionaries.emplace_back(name);
103  return false;
104  }
105  return true;
106  }
bool edm::checkDictionaryOfWrappedType ( std::vector< std::string > &  missingDictionaries,
TypeID const &  unwrappedTypeID 
)

Definition at line 83 of file DictionaryTools.cc.

References edm::TypeWithDict::byName(), checkDictionary(), edm::TypeID::className(), AlCaHLTBitMon_QueryRunRegistry::string, and wrappedClassName().

Referenced by edm::ProductRegistryHelper::addToRegistry(), and edm::ProductRegistry::initializeLookupTables().

84  {
85  std::string wrappedName = wrappedClassName(unwrappedTypeID.className());
86  TypeWithDict wrappedTypeWithDict = TypeWithDict::byName(wrappedName);
87  return checkDictionary(missingDictionaries, wrappedName, wrappedTypeWithDict);
88  }
bool checkDictionary(std::vector< std::string > &missingDictionaries, TypeID const &typeID)
std::string wrappedClassName(std::string const &iFullName)
bool edm::checkDictionaryOfWrappedType ( std::vector< std::string > &  missingDictionaries,
std::string const &  unwrappedName 
)

Definition at line 90 of file DictionaryTools.cc.

References edm::TypeWithDict::byName(), checkDictionary(), AlCaHLTBitMon_QueryRunRegistry::string, and wrappedClassName().

91  {
92  std::string wrappedName = wrappedClassName(unwrappedName);
93  TypeWithDict wrappedTypeWithDict = TypeWithDict::byName(wrappedName);
94  return checkDictionary(missingDictionaries, wrappedName, wrappedTypeWithDict);
95  }
bool checkDictionary(std::vector< std::string > &missingDictionaries, TypeID const &typeID)
std::string wrappedClassName(std::string const &iFullName)
void edm::checkForModuleDependencyCorrectness ( edm::PathsAndConsumesOfModulesBase const &  iPnC,
bool  iPrintDependencies 
)

Definition at line 139 of file PathsAndConsumesOfModules.cc.

References edm::PathsAndConsumesOfModulesBase::allModules(), heppy_report::description, edm::PathsAndConsumesOfModulesBase::endPaths(), Exception, runEdmFileComparison::found, edm::graph::kDataDependencyIndex, edm::graph::kInvalidIndex, edm::errors::LogicError, edm::PathsAndConsumesOfModules::moduleIndex(), edm::PathsAndConsumesOfModulesBase::modulesOnEndPath(), edm::PathsAndConsumesOfModulesBase::modulesOnPath(), edm::PathsAndConsumesOfModulesBase::modulesWhoseProductsAreConsumedBy(), edm::PathsAndConsumesOfModulesBase::paths(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::graph::throwIfImproperDependencies().

Referenced by edm::EventProcessor::beginJob(), and edm::SubProcess::beginJob().

140  {
141  using namespace edm::graph;
142  //Need to lookup ids to names quickly
143  std::unordered_map<unsigned int, std::string> moduleIndexToNames;
144 
145  std::unordered_map<std::string, unsigned int> pathStatusInserterModuleLabelToModuleID;
146 
147  //for testing, state that TriggerResults is at the end of all paths
148  const std::string kTriggerResults("TriggerResults");
149  const std::string kPathStatusInserter("PathStatusInserter");
150  const std::string kEndPathStatusInserter("EndPathStatusInserter");
151  unsigned int kTriggerResultsIndex = kInvalidIndex;
152  unsigned int largestIndex = 0;
153  unsigned int kPathToTriggerResultsDependencyLastIndex = kInvalidIndex;
154  for(auto const& description: iPnC.allModules()) {
155  moduleIndexToNames.insert(std::make_pair(description->id(),
156  description->moduleLabel()));
157  if(kTriggerResults == description->moduleLabel()) {
158  kTriggerResultsIndex = description->id();
159  }
160  if(description->id() > largestIndex) {
161  largestIndex = description->id();
162  }
163  if(description->moduleName() == kPathStatusInserter || description->moduleName() == kEndPathStatusInserter) {
164  pathStatusInserterModuleLabelToModuleID[description->moduleLabel()] = description->id();
165  }
166  }
167  kPathToTriggerResultsDependencyLastIndex = largestIndex ;
168 
169 
170  /*
171  {
172  //We need to explicitly check that modules on Paths do not try to read data from
173  // Modules which are only on EndPaths. The circular dependency finder has been
174  // known to miss these.
175  std::unordered_set<unsigned int> modulesOnlyOnEndPaths;
176  auto const& endPaths = iPnC.endPaths();
177  for( unsigned int pathIndex = 0; pathIndex != endPaths.size(); ++pathIndex) {
178  auto const& moduleDescriptions = iPnC.modulesOnEndPath(pathIndex);
179  for(auto const& description: moduleDescriptions) {
180  modulesOnlyOnEndPaths.insert(description->id());
181  }
182  }
183 
184  std::unordered_set<unsigned int> modulesOnPaths;
185  auto const& paths = iPnC.paths();
186  for( unsigned int pathIndex = 0; pathIndex != paths.size(); ++pathIndex) {
187  auto const& moduleDescriptions = iPnC.modulesOnPath(pathIndex);
188  for(auto const& description: moduleDescriptions) {
189  auto itFind =modulesOnlyOnEndPaths.find(description->id());
190  if(modulesOnlyOnEndPaths.end() != itFind) {
191  modulesOnlyOnEndPaths.erase(itFind);
192  }
193  modulesOnPaths.insert(description->id());
194  }
195  }
196 
197  for(auto moduleIndex : modulesOnPaths) {
198  auto const& dependentModules = iPnC.modulesWhoseProductsAreConsumedBy(moduleIndex);
199  for(auto const& depDescription: dependentModules) {
200  auto itFind = modulesOnlyOnEndPaths.find(depDescription->id());
201  if(itFind != modulesOnlyOnEndPaths.end()) {
202  throw edm::Exception(edm::errors::ScheduleExecutionFailure, "Unrunnable schedule\n")
203  <<"The module "<<moduleIndexToNames[moduleIndex]<<" is on a Path and depends on data from module "
204  <<moduleIndexToNames[depDescription->id()]<<" which is on an EndPath.";
205  }
206  }
207  }
208 
209  }
210  */
211 
212  //If a module to module dependency comes from a path, remember which path
213  EdgeToPathMap edgeToPathMap;
214 
215  //Need to be able to quickly look up which paths a module appears on
216  std::unordered_map<unsigned int, std::vector<unsigned int>> moduleIndexToPathIndex;
217 
218  //determine the path dependencies
219  std::vector<std::string> pathNames = iPnC.paths();
220  const unsigned int kFirstEndPathIndex = pathNames.size();
221 
222  const std::string kPathEnded("@PathEnded");
223  const std::string kEndPathStart("@EndPathStart");
224 
225  //The finished processing depends on all paths and end paths
226  const std::string kFinishedProcessing("@FinishedProcessing");
227  const unsigned int kFinishedProcessingIndex{0};
228  moduleIndexToNames.insert(std::make_pair(kFinishedProcessingIndex,
229  kFinishedProcessing));
230 
231 
232  pathNames.insert(pathNames.end(), iPnC.endPaths().begin(), iPnC.endPaths().end());
233  std::vector<std::vector<unsigned int>> pathIndexToModuleIndexOrder(pathNames.size());
234  {
235 
236  for(unsigned int pathIndex = 0; pathIndex != pathNames.size(); ++pathIndex) {
237  std::set<unsigned int> alreadySeenIndex;
238 
239  std::vector<ModuleDescription const*> const* moduleDescriptions;
240  if(pathIndex < kFirstEndPathIndex) {
241  moduleDescriptions= &(iPnC.modulesOnPath(pathIndex));
242  } else {
243  moduleDescriptions= &(iPnC.modulesOnEndPath(pathIndex-kFirstEndPathIndex));
244  }
245  unsigned int lastModuleIndex = kInvalidIndex;
246  auto& pathOrder =pathIndexToModuleIndexOrder[pathIndex];
247  pathOrder.reserve(moduleDescriptions->size() + 1);
248  for(auto const& description: *moduleDescriptions) {
249  auto found = alreadySeenIndex.insert(description->id());
250  if(found.second) {
251  //first time for this path
252  unsigned int const moduleIndex = description->id();
253  pathOrder.push_back(moduleIndex);
254  auto& paths =moduleIndexToPathIndex[moduleIndex];
255  paths.push_back(pathIndex);
256  if(lastModuleIndex != kInvalidIndex ) {
257  edgeToPathMap[std::make_pair(moduleIndex,lastModuleIndex)].push_back(pathIndex);
258  }
259  lastModuleIndex = moduleIndex;
260  }
261  }
262  //Have TriggerResults depend on the end of all paths
263  // Have all EndPaths depend on TriggerResults
264  auto labelToID = pathStatusInserterModuleLabelToModuleID.find(pathNames[pathIndex]);
265  if(labelToID == pathStatusInserterModuleLabelToModuleID.end()) {
266  // should never happen
268  << "PathsAndConsumesOfModules::moduleDescription:checkForModuleDependencyCorrectness Could not find PathStatusInserter\n";
269  }
270  unsigned int pathStatusInserterModuleID = labelToID->second;
271  if( pathIndex < kFirstEndPathIndex) {
272  if( (lastModuleIndex != kInvalidIndex) ) {
273  edgeToPathMap[std::make_pair(pathStatusInserterModuleID, lastModuleIndex)].push_back(pathIndex);
274  moduleIndexToNames.insert(std::make_pair(pathStatusInserterModuleID,
275  kPathEnded));
276  if (kTriggerResultsIndex != kInvalidIndex) {
277  edgeToPathMap[std::make_pair(kTriggerResultsIndex, pathStatusInserterModuleID)].push_back(kDataDependencyIndex);
278  }
279  //Need to make dependency for finished process
280  edgeToPathMap[std::make_pair(kFinishedProcessingIndex, pathStatusInserterModuleID)].push_back(kDataDependencyIndex);
281  pathOrder.push_back(pathStatusInserterModuleID);
282  }
283  } else {
284  if( (not moduleDescriptions->empty()) ) {
285  if (kTriggerResultsIndex != kInvalidIndex) {
286  ++kPathToTriggerResultsDependencyLastIndex;
287  edgeToPathMap[std::make_pair(moduleDescriptions->front()->id(),kPathToTriggerResultsDependencyLastIndex)].push_back(pathIndex);
288  moduleIndexToNames.insert(std::make_pair(kPathToTriggerResultsDependencyLastIndex,
289  kEndPathStart));
290  edgeToPathMap[std::make_pair(kPathToTriggerResultsDependencyLastIndex,kTriggerResultsIndex)].push_back(kDataDependencyIndex);
291  pathOrder.insert(pathOrder.begin(),kPathToTriggerResultsDependencyLastIndex);
292  }
293  //Need to make dependency for finished process
294  ++kPathToTriggerResultsDependencyLastIndex;
295  edgeToPathMap[std::make_pair(pathStatusInserterModuleID, lastModuleIndex)].push_back(pathIndex);
296  moduleIndexToNames.insert(std::make_pair(pathStatusInserterModuleID,
297  kPathEnded));
298  edgeToPathMap[std::make_pair(kFinishedProcessingIndex, pathStatusInserterModuleID)].push_back(kDataDependencyIndex);
299  pathOrder.push_back(pathStatusInserterModuleID);
300  }
301  }
302  }
303  }
304  {
305 
306  //determine the data dependencies
307  for(auto const& description: iPnC.allModules()) {
308  unsigned int const moduleIndex = description->id();
309  auto const& dependentModules = iPnC.modulesWhoseProductsAreConsumedBy(moduleIndex);
310  for(auto const& depDescription: dependentModules) {
311  if(iPrintDependencies) {
312  edm::LogAbsolute("ModuleDependency") << "ModuleDependency '" << description->moduleLabel() <<
313  "' depends on data products from module '" << depDescription->moduleLabel()<<"'";
314  }
315  //see if all paths containing this module also contain the dependent module earlier in the path
316  // if it does, then treat this only as a path dependency and not a data dependency as this
317  // simplifies the circular dependency checking logic
318  auto depID =depDescription->id();
319  auto itPathsFound = moduleIndexToPathIndex.find(moduleIndex);
320  bool keepDataDependency = true;
321  auto itDepsPathsFound =moduleIndexToPathIndex.find(depID);
322  if(itPathsFound != moduleIndexToPathIndex.end() and itDepsPathsFound != moduleIndexToPathIndex.end()) {
323  keepDataDependency = false;
324  for(auto const pathIndex: itPathsFound->second) {
325  for(auto idToCheck: pathIndexToModuleIndexOrder[pathIndex]) {
326  if(idToCheck == depID) {
327  //found dependent module first so check next path
328  break;
329  }
330  if(idToCheck == moduleIndex) {
331  //did not find dependent module earlier on path so
332  // must keep data dependency
333  keepDataDependency = true;
334  break;
335  }
336  }
337  if(keepDataDependency) {
338  break;
339  }
340  }
341  }
342  if(keepDataDependency) {
343  edgeToPathMap[std::make_pair(moduleIndex, depID)].push_back(kDataDependencyIndex);
344  }
345  }
346  }
347  }
348  graph::throwIfImproperDependencies(edgeToPathMap,pathIndexToModuleIndexOrder,pathNames,moduleIndexToNames);
349  }
constexpr auto kInvalidIndex
void throwIfImproperDependencies(EdgeToPathMap const &, std::vector< std::vector< unsigned int >> const &iPathIndexToModuleIndexOrder, std::vector< std::string > const &iPathNames, std::unordered_map< unsigned int, std::string > const &iModuleIndexToNames)
std::map< SimpleEdge, std::vector< unsigned int >> EdgeToPathMap
constexpr auto kDataDependencyIndex
void edm::checkForWrongProduct ( ProductID const &  keyID,
ProductID const &  refID 
)

Definition at line 6 of file CommonExceptions.cc.

References Exception, and edm::errors::InvalidReference.

Referenced by edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::operator[]().

6  {
7  if (keyID != refID) {
9  "AssociationVector: trying to use [] operator passing a reference\n" <<
10  " with the wrong product id (i.e.: pointing to the wrong collection)\n" <<
11  " keyRef.id = " << keyID << ", ref.id = " << refID << "\n";
12 
13  }
14  }
static void edm::cleanup ( const Factory::MakerMap::value_type &  v)
static
void edm::clearLoggedErrorsSummary ( unsigned int  iStreamID)

Definition at line 193 of file MessageSender.cc.

References errorSummaryMaps.

Referenced by edm::service::MessageLogger::postEvent().

193  {
194  assert(iStreamID<errorSummaryMaps.size());
195  errorSummaryMaps[iStreamID].clear();
196  }
static std::vector< tbb::concurrent_unordered_map< ErrorSummaryMapKey, AtomicUnsignedInt, ErrorSummaryMapKey::key_hash > > errorSummaryMaps
void edm::clearMessageLog ( )

Definition at line 100 of file MessageLogger.cc.

References edm::MessageDrop::clear(), and edm::MessageDrop::instance().

Referenced by edm::Suppress_LogDebug_::log().

100  { // 11/30/10 mf
101  MessageDrop::instance()->clear();
102 }
static PFTauRenderPlugin instance
bool edm::combinable ( BranchDescription const &  a,
BranchDescription const &  b 
)

Definition at line 310 of file BranchDescription.cc.

References edm::BranchDescription::branchID(), edm::BranchDescription::branchType(), edm::BranchDescription::friendlyClassName(), edm::BranchDescription::fullClassName(), edm::BranchDescription::moduleLabel(), edm::BranchDescription::processName(), and edm::BranchDescription::productInstanceName().

Referenced by edm::ProductRegistry::copyProduct(), operator<<(), and operator==().

310  {
311  return
312  (a.branchType() == b.branchType()) &&
313  (a.processName() == b.processName()) &&
314  (a.fullClassName() == b.fullClassName()) &&
315  (a.friendlyClassName() == b.friendlyClassName()) &&
316  (a.productInstanceName() == b.productInstanceName()) &&
317  (a.moduleLabel() == b.moduleLabel()) &&
318  (a.branchID() == b.branchID());
319  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::contains ( LuminosityBlockRange const &  lh,
LuminosityBlockID const &  rh 
)

Definition at line 52 of file LuminosityBlockRange.cc.

References edm::LuminosityBlockRange::endLumiID(), and edm::LuminosityBlockRange::startLumiID().

52  {
53  if (rh >= lh.startLumiID() && rh <= lh.endLumiID()) {
54  return true;
55  }
56  return false;
57  }
bool int lh
Definition: SIMDVec.h:21
bool edm::contains ( EventRange const &  lh,
EventID const &  rh 
)

Definition at line 38 of file EventRange.cc.

References contains_(), edm::EventID::event(), edm::EventID::run(), edm::EventRange::startLumi(), and mitigatedMETSequence_cff::U.

Referenced by Vispa.Gui.PortConnection.PointToPointConnection::belongsToRoute(), HGCalTriggerClusterIdentificationBDT::category(), contains(), Vispa.Views.LineDecayView.DecayNode::containsPoint(), Vispa.Views.LineDecayView.DecayLine::containsPoint(), CaloTowersCreationAlgo::convert(), MultipleScatteringGeometry::detLayers(), CTPPSDiamondDQMSource::dqmBeginRun(), Vispa.Gui.ConnectableWidget.ConnectableWidget::dropAreaPort(), pat::PATElectronProducer::fillElectron2(), pat::PATMuonProducer::fillMuon(), HeavyFlavorValidation::getFilterLevel(), CaloVNoiseSignalGenerator::getNoiseSignals(), Vispa.Main.StartupScreen.StartupScreen::mouseMoveEvent(), Vispa.Gui.MenuWidget.MenuWidget::mouseMoveEvent(), Vispa.Gui.MenuWidget.MenuWidget::mousePressEvent(), Vispa.Gui.PortWidget.PortWidget::mouseReleaseEvent(), Vispa.Gui.ConnectableWidgetOwner.ConnectableWidgetOwner::propagateEventUnderConnectionWidget(), CaloTowersCreationAlgo::rescaleTowers(), TotemDAQMappingESSourceXML::setIntervalFor(), and PhysicsTools::Calibration::MVAComputerContainer::~MVAComputerContainer().

38  {
39  if (lh.startLumi() == 0) {
40  return (contains_(lh, EventID(rh.run(), 0U, rh.event())));
41  }
42  return (contains_(lh, rh));
43  }
bool int lh
Definition: SIMDVec.h:21
bool contains_(EventRange const &lh, EventID const &rh)
Definition: EventRange.cc:45
bool edm::contains ( LuminosityBlockRange const &  lh,
LuminosityBlockRange const &  rh 
)

Definition at line 59 of file LuminosityBlockRange.cc.

References contains(), edm::LuminosityBlockRange::endLumiID(), and edm::LuminosityBlockRange::startLumiID().

59  {
60  if (contains(lh,rh.startLumiID()) && contains(lh,rh.endLumiID())) {
61  return true;
62  }
63  return false;
64  }
bool contains(EventRange const &lh, EventID const &rh)
Definition: EventRange.cc:38
bool int lh
Definition: SIMDVec.h:21
bool edm::contains ( EventRange const &  lh,
EventRange const &  rh 
)

Definition at line 49 of file EventRange.cc.

References contains(), edm::EventRange::endEventID(), edm::EventRange::startEventID(), and edm::EventRange::startLumi().

49  {
50  assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
51  return (contains(lh, rh.startEventID()) && contains(lh, rh.endEventID()));
52  }
bool contains(EventRange const &lh, EventID const &rh)
Definition: EventRange.cc:38
bool int lh
Definition: SIMDVec.h:21
bool edm::contains_ ( EventRange const &  lh,
EventID const &  rh 
)

Definition at line 45 of file EventRange.cc.

References edm::EventRange::endEventID(), and edm::EventRange::startEventID().

Referenced by contains().

45  {
46  return (rh >= lh.startEventID() && rh <= lh.endEventID());
47  }
bool int lh
Definition: SIMDVec.h:21
template<class FwdIter >
FwdIter edm::contextual_find ( FwdIter  b,
FwdIter  e,
char  first,
char  sep,
char  last 
)

Definition at line 48 of file split.h.

References b, MillePedeFileConverter_cfg::e, and CommonUtil::nested.

Referenced by split().

50 {
51  for(int nested = 0; b != e; ++b) {
52  if(*b == first)
53  ++nested;
54  else if(*b == last)
55  --nested;
56  else if(*b == sep && nested == 0)
57  return b;
58  }
59 
60  return e;
61 
62 } // contextual_find()
double b
Definition: hdecay.h:120
template<class FwdIter >
FwdIter edm::contextual_find_not ( FwdIter  b,
FwdIter  e,
char  first,
char  sep,
char  last 
)

Definition at line 70 of file split.h.

References b, and MillePedeFileConverter_cfg::e.

Referenced by split().

72 {
73  for(; b != e; ++b) {
74  if(*b != sep)
75  return b;
76  }
77 
78  return e;
79 
80 } // contextual_find_not()
double b
Definition: hdecay.h:120
void edm::conversion ( LuminosityBlockAux const &  from,
LuminosityBlockAuxiliary to 
)

Definition at line 11 of file LuminosityBlockAux.cc.

References edm::LuminosityBlockAuxiliary::beginTime_, edm::LuminosityBlockAuxiliary::endTime_, edm::LuminosityBlockAux::id_, edm::LuminosityBlockAuxiliary::id_, edm::Timestamp::invalidTimestamp(), edm::LuminosityBlockAux::processHistoryID_, edm::LuminosityBlockAuxiliary::processHistoryID_, and edm::LuminosityBlockAux::runID_.

11  {
12  to.processHistoryID_ = from.processHistoryID_;
13  to.id_ = LuminosityBlockID(from.runID_, from.id_);
14  to.beginTime_ = to.endTime_ = Timestamp::invalidTimestamp();
15  }
void edm::conversion ( RunAux const &  from,
RunAuxiliary to 
)

Definition at line 11 of file RunAux.cc.

References edm::RunAuxiliary::beginTime_, edm::RunAuxiliary::endTime_, edm::RunAux::id_, edm::RunAuxiliary::id_, edm::Timestamp::invalidTimestamp(), edm::RunAux::processHistoryID_, and edm::RunAuxiliary::processHistoryID_.

11  {
12  to.processHistoryID_ = from.processHistoryID_;
13  to.id_ = RunID(from.id_);
14  to.beginTime_ = to.endTime_ = Timestamp::invalidTimestamp();
15  }
void edm::conversion ( EventAux const &  from,
EventAuxiliary to 
)
template<typename T >
void edm::convert_handle ( BasicHandle &&  bh,
Handle< T > &  result 
)

Definition at line 20 of file ConvertHandle.h.

References h, eostools::move(), edm::handleimpl::throwConvertTypeError(), edm::handleimpl::throwInvalidReference(), and wrapper.

Referenced by edm::EventBase::get(), edm::Event::get(), PileUpEventPrincipal::getByLabel(), edm::EventBase::getByLabel(), edm::RunBase::getByLabel(), edm::LuminosityBlockBase::getByLabel(), edm::LuminosityBlock::getByLabel(), edm::Run::getByLabel(), edm::Event::getByLabel(), edm::OccurrenceForOutput::getByToken(), edm::LuminosityBlock::getByToken(), edm::Run::getByToken(), edm::Event::getByToken(), and edm::PrincipalGetAdapter::getManyByType().

21  {
22  if(bh.failedToGet()) {
23  Handle<T> h(std::move(bh.whyFailedFactory()));
24  result = std::move(h);
25  return;
26  }
27  void const* basicWrapper = bh.wrapper();
28  if(basicWrapper == nullptr) {
30  }
31  if(!(bh.wrapper()->dynamicTypeInfo() == typeid(T))) {
32  handleimpl::throwConvertTypeError(typeid(T), bh.wrapper()->dynamicTypeInfo());
33  }
34  Wrapper<T> const* wrapper = static_cast<Wrapper<T> const*>(basicWrapper);
35 
36  Handle<T> h(wrapper->product(), bh.provenance());
37  h.swap(result);
38  }
FWCore Framework interface EventSetupRecordImplementation h
Helper function to determine trigger accepts.
void throwConvertTypeError(std::type_info const &expected, std::type_info const &actual)
void throwInvalidReference()
Definition: ConvertHandle.cc:6
long double T
def move(src, dest)
Definition: eostools.py:510
static HepMC::HEPEVT_Wrapper wrapper
void edm::convert_handle ( BasicHandle const &  orig,
Handle< FWGenericObject > &  result 
)

specialize this function forFWGenericHandle

Definition at line 20 of file FWGenericHandle.cc.

References MessageLogger_cfi::cerr, Exception, edm::BasicHandle::failedToGet(), edm::ObjectWithDict::get(), h, edm::BasicHandle::id(), edm::errors::InvalidReference, edm::errors::LogicError, edm::TypeWithDict::name(), edm::BasicHandle::provenance(), edm::Handle< FWGenericObject >::setWhyFailed(), edm::Handle< FWGenericObject >::type(), edm::BasicHandle::whyFailed(), edm::convertException::wrap(), edm::WrapperBase::wrappedTypeInfo(), and edm::BasicHandle::wrapper().

22 {
23  if(orig.failedToGet()) {
24  result.setWhyFailed(orig.whyFailed());
25  return;
26  }
27 
28  WrapperBase const* originalWrap = orig.wrapper();
29  if(originalWrap == nullptr) {
31  << "edm::BasicHandle has null pointer to Wrapper";
32  }
33 
34  edm::ObjectWithDict wrap(edm::TypeWithDict(originalWrap->wrappedTypeInfo()), const_cast<void*>(static_cast<void const*>(originalWrap)));
35  assert(bool(wrap));
36 
37  edm::ObjectWithDict product(wrap.get("obj"));
38 
39  if(!product){
40  throw edm::Exception(edm::errors::LogicError)<<"FWGenericObject could not find 'obj' member";
41  }
42  if(product.typeOf()!=result.type()){
43  std::cerr << "FWGenericObject asked for "<<result.type().name()
44  <<" but was given a " << product.typeOf().name();
45  throw edm::Exception(edm::errors::LogicError)<<"FWGenericObject asked for "<<result.type().name()
46  <<" but was given a "<<product.typeOf().name();
47  }
48 
49  Handle<FWGenericObject> h(product, orig.provenance(), orig.id());
50  h.swap(result);
51 }
FWCore Framework interface EventSetupRecordImplementation h
Helper function to determine trigger accepts.
auto wrap(F iFunc) -> decltype(iFunc())
void edm::convert_handle ( BasicHandle &&  orig,
Handle< GenericObject > &  result 
)

specialize this function for GenericHandle

Definition at line 19 of file GenericHandle.cc.

References Exception, edm::ObjectWithDict::get(), h, edm::errors::InvalidReference, edm::errors::LogicError, edm::TypeWithDict::name(), edm::Handle< GenericObject >::setWhyFailedFactory(), edm::Handle< GenericObject >::type(), edm::convertException::wrap(), and edm::WrapperBase::wrappedTypeInfo().

21 {
22  if(orig.failedToGet()) {
23  result.setWhyFailedFactory(orig.whyFailedFactory());
24  return;
25  }
26  WrapperBase const* originalWrap = orig.wrapper();
27  if(originalWrap == nullptr) {
28  throw Exception(errors::InvalidReference,"NullPointer")
29  << "edm::BasicHandle has null pointer to Wrapper";
30  }
31 
32  ObjectWithDict wrap(originalWrap->wrappedTypeInfo(), const_cast<WrapperBase*>(originalWrap));
33  assert(bool(wrap));
34 
35  ObjectWithDict product(wrap.get("obj"));
36  if(!product){
37  throw Exception(errors::LogicError)<<"GenericObject could not find 'obj' member";
38  }
39  if(product.typeOf() != result.type()) {
40  throw Exception(errors::LogicError) << "GenericObject asked for " << result.type().name()
41  << " but was given a " << product.typeOf().name();
42  }
43 
44  Handle<GenericObject> h(product, orig.provenance(), orig.id());
45  h.swap(result);
46 }
FWCore Framework interface EventSetupRecordImplementation h
Helper function to determine trigger accepts.
auto wrap(F iFunc) -> decltype(iFunc())
constexpr BranchType edm::convertToBranchType ( Transition  iValue)

Definition at line 21 of file Transition.h.

References constexpr, InEvent, InLumi, and InRun.

Referenced by edm::ProductRegistryHelper::addToRegistry(), and edm::ProducerBase::resolvePutIndicies().

21  {
22  constexpr BranchType branches[]={InEvent,InLumi,InLumi,InRun,InRun};
23  return branches[static_cast<std::underlying_type<Transition>::type>(iValue)];
24  }
type
Definition: HCALResponse.h:21
#define constexpr
BranchType
Definition: BranchType.h:11
constexpr Transition edm::convertToTransition ( BranchType  iValue)

Definition at line 26 of file Transition.h.

References BeginLuminosityBlock, BeginRun, constexpr, and Event.

Referenced by edm::ProductRegistryHelper::produces().

26  {
27  constexpr Transition trans[]={Transition::Event,Transition::BeginLuminosityBlock,Transition::BeginRun};
28  return trans[iValue];
29  }
#define constexpr
Transition
Definition: Transition.h:12
template<typename ForwardSequence , typename Func >
Func edm::copy_all ( ForwardSequence &  s,
Func  f 
)
inline
template<typename T1 , typename T2 , typename T3 , typename ToT >
void edm::copyFromTo ( ESProducts< T1, T2, T3 > &  iFrom,
ToT &  iTo 
)

Definition at line 202 of file ESProducts.h.

References edm::eventsetup::produce::ProductHolder< T1, T2, T3 >::assignTo().

203  {
204  iFrom.assignTo(iTo);
205  }
std::string edm::createGlobalIdentifier ( )

Definition at line 6 of file GlobalIdentifier.cc.

References edm::Guid::toString().

Referenced by NanoAODOutputModule::openFile(), DQMRootOutputModule::openFile(), edm::RootOutputFile::RootOutputFile(), and edm::RootFile::validateFile().

6  {
7  Guid guid;
8  return guid.toString();
9  }
bool edm::decode ( bool &  to,
std::string const &  from 
)
bool edm::decode ( std::vector< bool > &  to,
std::string const &  from 
)

Definition at line 82 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

82  {
83  std::vector<std::string> temp;
84  if(!split(std::back_inserter(temp), from, '{', ',', '}')) {
85  return false;
86  }
87 
88  to.clear();
89  for(std::vector<std::string>::const_iterator b = temp.begin()
90  , e = temp.end()
91  ; b != e; ++b) {
92  bool val = false;
93  if(!decode(val, *b)) {
94  return false;
95  }
96  to.push_back(val);
97  }
98  return true;
99  } // decode to vector<bool>
bool decode(bool &, std::string const &)
Definition: types.cc:62
double b
Definition: hdecay.h:120
double split
Definition: MVATrainer.cc:139
bool edm::decode ( int &  to,
std::string const &  from 
)

Definition at line 129 of file types.cc.

References b, MillePedeFileConverter_cfg::e, and Validation_hcalonly_cfi::sign.

129  {
130  std::string::const_iterator b = from.begin()
131  , e = from.end();
132 
133  if(*b != '+' && *b != '-') {
134  return false;
135  }
136  int sign = (*b == '+') ? +1 : -1;
137 
138  to = 0;
139  while(++b != e) {
140  if(!std::isdigit(*b)) {
141  return false;
142  }
143  to = 10 * to + (*b - '0');
144  }
145  to *= sign;
146 
147  return true;
148  } // decode to int
double b
Definition: hdecay.h:120
bool edm::decode ( std::vector< int > &  to,
std::string const &  from 
)

Definition at line 218 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

218  {
219  std::vector<std::string> temp;
220  if(!split(std::back_inserter(temp), from, '{', ',', '}')) {
221  return false;
222  }
223 
224  to.clear();
225  for(std::vector<std::string>::const_iterator b = temp.begin()
226  , e = temp.end()
227  ; b != e; ++b) {
228  int val = 0;
229  if(!decode(val, *b)) {
230  return false;
231  }
232  to.push_back(val);
233  }
234 
235  return true;
236  } // decode to vector<int>
bool decode(bool &, std::string const &)
Definition: types.cc:62
double b
Definition: hdecay.h:120
double split
Definition: MVATrainer.cc:139
bool edm::decode ( unsigned int &  to,
std::string const &  from 
)

Definition at line 314 of file types.cc.

References b, and MillePedeFileConverter_cfg::e.

314  {
315  std::string::const_iterator b = from.begin()
316  , e = from.end();
317 
318  to = 0u;
319  for(; b != e; ++b) {
320  if(*b == 'u' || *b == 'U') {
321  return true;
322  }
323  if(!std::isdigit(*b)) {
324  return false;
325  }
326  to = 10u * to + (*b - '0');
327  }
328  return true;
329  } // decode to unsigned
double b
Definition: hdecay.h:120
bool edm::decode ( std::vector< unsigned int > &  to,
std::string const &  from 
)

Definition at line 383 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

383  {
384  std::vector<std::string> temp;
385  if(!split(std::back_inserter(temp), from, '{', ',', '}')) {
386  return false;
387  }
388  to.clear();
389  for(std::vector<std::string>::const_iterator b = temp.begin()
390  , e = temp.end()
391  ; b != e; ++b) {
392  unsigned int val = 0;
393  if(!decode(val, *b)) {
394  return false;
395  }
396  to.push_back(val);
397  }
398 
399  return true;
400  } // decode to vector<unsigned int>
bool decode(bool &, std::string const &)
Definition: types.cc:62
double b
Definition: hdecay.h:120
double split
Definition: MVATrainer.cc:139
bool edm::decode ( long long &  to,
std::string const &  from 
)

Definition at line 173 of file types.cc.

References b, MillePedeFileConverter_cfg::e, and Validation_hcalonly_cfi::sign.

173  {
174  std::string::const_iterator b = from.begin()
175  , e = from.end();
176 
177  if(*b != '+' && *b != '-') {
178  return false;
179  }
180  int sign = (*b == '+') ? +1 : -1;
181 
182  to = 0;
183  while(++b != e) {
184  if(!std::isdigit(*b)) {
185  return false;
186  }
187  to = 10 * to + (*b - '0');
188  }
189  to *= sign;
190 
191  return true;
192  } // decode to int
double b
Definition: hdecay.h:120
bool edm::decode ( std::vector< long long > &  to,
std::string const &  from 
)

Definition at line 267 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

267  {
268  std::vector<std::string> temp;
269  if(!split(std::back_inserter(temp), from, '{', ',', '}')) {
270  return false;
271  }
272 
273  to.clear();
274  for(std::vector<std::string>::const_iterator b = temp.begin()
275  , e = temp.end()
276  ; b != e; ++b) {
277  long long val = 0LL;
278  if(!decode(val, *b)) {
279  return false;
280  }
281  to.push_back(val);
282  }
283 
284  return true;
285  } // decode to vector<int>
bool decode(bool &, std::string const &)
Definition: types.cc:62
double b
Definition: hdecay.h:120
double split
Definition: MVATrainer.cc:139
bool edm::decode ( unsigned long long &  to,
std::string const &  from 
)

Definition at line 349 of file types.cc.

References b, and MillePedeFileConverter_cfg::e.

349  {
350  std::string::const_iterator b = from.begin()
351  , e = from.end();
352  to = 0u;
353  for(; b != e; ++b) {
354  if(*b == 'u' || *b == 'U') {
355  return true;
356  }
357  if(!std::isdigit(*b)) {
358  return false;
359  }
360  to = 10u * to + (*b - '0');
361  }
362  return true;
363  } // decode to unsigned
double b
Definition: hdecay.h:120
bool edm::decode ( std::vector< unsigned long long > &  to,
std::string const &  from 
)

Definition at line 430 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

430  {
431  std::vector<std::string> temp;
432  if(!split(std::back_inserter(temp), from, '{', ',', '}')) {
433  return false;
434  }
435  to.clear();
436  for(std::vector<std::string>::const_iterator b = temp.begin()
437  , e = temp.end()
438  ; b != e; ++b) {
439  unsigned long long val = 0ULL;
440  if(!decode(val, *b)) {
441  return false;
442  }
443  to.push_back(val);
444  }
445 
446  return true;
447  } // decode to vector<unsigned int>
bool decode(bool &, std::string const &)
Definition: types.cc:62
double b
Definition: hdecay.h:120
double split
Definition: MVATrainer.cc:139
bool edm::decode ( double &  to,
std::string const &  from 
)

Definition at line 479 of file types.cc.

References infinity, and SiStripPI::max.

479  {
480  if(from == "NaN") {
481  to = std::numeric_limits<double>::quiet_NaN();
482  } else if(from == "+inf" || from == "inf") {
483  to = std::numeric_limits<double>::has_infinity
485  : std::numeric_limits<double>::max();
486  } else if(from == "-inf") {
487  to = std::numeric_limits<double>::has_infinity
489  : -std::numeric_limits<double>::max();
490  }
491 
492  else {
493  try {
494  // std::cerr << "from:" << from << std::endl;
495  to = boost::lexical_cast<double>(from);
496  // std::cerr << "to:" << to << std::endl;
497  }
498  catch(boost::bad_lexical_cast&) {
499  return false;
500  }
501  }
502  return true;
503  }
const double infinity
bool edm::decode ( std::vector< double > &  to,
std::string const &  from 
)

Definition at line 523 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

523  {
524  std::vector<std::string> temp;
525  if(!split(std::back_inserter(temp), from, '{', ',', '}'))
526  return false;
527 
528  to.clear();
529  for(std::vector<std::string>::const_iterator b = temp.begin()
530  , e = temp.end()
531  ; b != e; ++b) {
532  double val;
533  if(!decode(val, *b))
534  return false;
535  to.push_back(val);
536  }
537 
538  return true;
539  } // decode to vector<double>
bool decode(bool &, std::string const &)
Definition: types.cc:62
double b
Definition: hdecay.h:120
double split
Definition: MVATrainer.cc:139
bool edm::decode ( std::string &  to,
std::string const &  from 
)

Definition at line 569 of file types.cc.

References b, EnergyCorrector::c, MillePedeFileConverter_cfg::e, and from_hex().

569  {
570  /*std::cerr << "Decoding: " << from << '\n'; //DEBUG*/
571  std::string::const_iterator b = from.begin()
572  , e = from.end();
573 
574  to = "";
575  to.reserve((e-b)/2);
576  char c = '\0';
577  for(bool even_pos = true
578  ; b != e; ++b, even_pos = !even_pos) {
579  if(even_pos) {
580  /*std::cerr << "Even: |"
581  << *b
582  << "| giving "
583  << from_hex(*b)
584  << "\n"; //DEBUG*/
585  c = static_cast<char>(from_hex(*b));
586  }
587  else {
588  /*std::cerr << "Odd: |"
589  << *b
590  << "| giving "
591  << from_hex(*b)
592  << "\n"; //DEBUG*/
593  c = static_cast<char>(c * 16 + from_hex(*b));
594  // if(std::isalnum(c)) {
595  /*std::cerr << "Ans: |" << c << "|\n"; //DEBUG*/
596  to += c;
597  //}
598  //else { // keep all special chars encoded
599  //to += "\\x";
600  //to += to_hex_rep(c);
601  //}
602  }
603  }
604  /*std::cerr << "Decoded: " << to << '\n'; //DEBUG*/
605  return true;
606  } // decode to String
static unsigned int from_hex(char c)
Definition: types.cc:36
double b
Definition: hdecay.h:120
bool edm::decode ( std::vector< std::string > &  to,
std::string const &  from 
)

Definition at line 1092 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), AlCaHLTBitMon_QueryRunRegistry::string, groupFilesInBlocks::temp, and heppy_batch::val.

1092  {
1093  std::vector<std::string> temp;
1094  if(!split(std::back_inserter(temp), from, '{', ',', '}'))
1095  return false;
1096 
1097  to.clear();
1098  for(std::vector<std::string>::const_iterator b = temp.begin()
1099  , e = temp.end()
1100  ; b != e; ++b) {
1101  std::string val;
1102  // treat blank string specially
1103  if(*b == "XXX") {
1104  val = "";
1105  } else if(!decode(val, *b)) {
1106  return false;
1107  }
1108  to.push_back(val);
1109  }
1110 
1111  return true;
1112  } // decode to vector<string>
bool decode(bool &, std::string const &)
Definition: types.cc:62
double b
Definition: hdecay.h:120
double split
Definition: MVATrainer.cc:139
bool edm::decode ( edm::FileInPath to,
std::string const &  from 
)

Definition at line 614 of file types.cc.

References edm::FileInPath::readFromParameterSetBlob(), and groupFilesInBlocks::temp.

614  {
615  std::istringstream is(from);
617  temp.readFromParameterSetBlob(is);
618  if (!is) return false;
619  to = temp;
620  return true;
621  } // decode to FileInPath
void readFromParameterSetBlob(std::istream &is)
Definition: FileInPath.cc:345
bool edm::decode ( edm::InputTag to,
std::string const &  from 
)

Definition at line 640 of file types.cc.

640  {
641  to = InputTag(from);
642  return true;
643  } // decode to InputTag
bool edm::decode ( std::vector< edm::InputTag > &  to,
std::string const &  from 
)

Definition at line 659 of file types.cc.

References decode(), and nano_cff::strings.

659  {
660  std::vector<std::string> strings;
661  decode(strings, from);
662 
663  for(std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
664  stringItr != stringItrEnd; ++stringItr) {
665  to.push_back(InputTag(*stringItr));
666  }
667  return true;
668  } // decode to VInputTag
bool decode(bool &, std::string const &)
Definition: types.cc:62
bool edm::decode ( edm::ESInputTag to,
std::string const &  from 
)

Definition at line 690 of file types.cc.

690  {
691  to = ESInputTag(from);
692  return true;
693  } // decode to InputTag
bool edm::decode ( std::vector< edm::ESInputTag > &  to,
std::string const &  from 
)

Definition at line 709 of file types.cc.

References decode(), and nano_cff::strings.

709  {
710  std::vector<std::string> strings;
711  decode(strings, from);
712 
713  for(std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
714  stringItr != stringItrEnd; ++stringItr) {
715  to.push_back(ESInputTag(*stringItr));
716  }
717  return true;
718  } // decode to VInputTag
bool decode(bool &, std::string const &)
Definition: types.cc:62
bool edm::decode ( edm::EventID to,
std::string const &  from 
)

Definition at line 739 of file types.cc.

References findQualityFiles::run, and tokenize().

739  {
740  std::vector<std::string> tokens = edm::tokenize(from, ":");
741  assert(tokens.size() == 2 || tokens.size() == 3);
742  unsigned int run = strtoul(tokens[0].c_str(), nullptr, 0);
743  unsigned int lumi = (tokens.size() == 2 ? 0 : strtoul(tokens[1].c_str(), nullptr, 0));
744  unsigned long long event = strtoull(tokens[tokens.size() - 1].c_str(), nullptr, 0);
745  to = edm::EventID(run, lumi, event);
746 
747  return true;
748  } // decode to EventID
Definition: event.py:1
std::vector< std::string > tokenize(std::string const &input, std::string const &separator)
breaks the input string into tokens, delimited by the separator
bool edm::decode ( std::vector< edm::EventID > &  to,
std::string const &  from 
)

Definition at line 770 of file types.cc.

References decode(), and nano_cff::strings.

770  {
771  std::vector<std::string> strings;
772  decode(strings, from);
773 
774  for(std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
775  stringItr != stringItrEnd; ++stringItr) {
776  edm::EventID eventID;
777  decode(eventID, *stringItr);
778  to.push_back(eventID);
779  }
780  return true;
781  } // decode to VInputTag
bool decode(bool &, std::string const &)
Definition: types.cc:62
bool edm::decode ( edm::LuminosityBlockID to,
std::string const &  from 
)

Definition at line 803 of file types.cc.

References findQualityFiles::run, and tokenize().

803  {
804  std::vector<std::string> tokens = edm::tokenize(from, ":");
805  assert(tokens.size() == 2);
806  unsigned int run = strtoul(tokens[0].c_str(), nullptr, 0);
807  unsigned int lumi = strtoul(tokens[1].c_str(), nullptr, 0);
808  to = edm::LuminosityBlockID(run, lumi);
809  return true;
810  } // decode to LuminosityBlockID
std::vector< std::string > tokenize(std::string const &input, std::string const &separator)
breaks the input string into tokens, delimited by the separator
bool edm::decode ( std::vector< edm::LuminosityBlockID > &  to,
std::string const &  from 
)

Definition at line 828 of file types.cc.

References decode(), and nano_cff::strings.

828  {
829  std::vector<std::string> strings;
830  decode(strings, from);
831 
832  for(std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
833  stringItr != stringItrEnd; ++stringItr) {
834  edm::LuminosityBlockID lumiID;
835  decode(lumiID, *stringItr);
836  to.push_back(lumiID);
837  }
838  return true;
839  } // decode to VInputTag
bool decode(bool &, std::string const &)
Definition: types.cc:62
bool edm::decode ( edm::LuminosityBlockRange to,
std::string const &  from 
)

Definition at line 862 of file types.cc.

References begin, decode(), end, edm::LuminosityBlockID::luminosityBlock(), edm::LuminosityBlockID::run(), and tokenize().

862  {
863  std::vector<std::string> tokens = edm::tokenize(from, "-");
864  assert(tokens.size() == 2);
867  edm::decode(begin,tokens[0]);
868  edm::decode(end,tokens[1]);
869  to = edm::LuminosityBlockRange(begin.run(), begin.luminosityBlock(),
870  end.run(), end.luminosityBlock());
871  return true;
872  } // decode to LuminosityBlockRange
RunNumber_t run() const
bool decode(bool &, std::string const &)
Definition: types.cc:62
#define end
Definition: vmac.h:39
LuminosityBlockNumber_t luminosityBlock() const
#define begin
Definition: vmac.h:32
std::vector< std::string > tokenize(std::string const &input, std::string const &separator)
breaks the input string into tokens, delimited by the separator
bool edm::decode ( std::vector< edm::LuminosityBlockRange > &  to,
std::string const &  from 
)

Definition at line 888 of file types.cc.

References decode(), and nano_cff::strings.

888  {
889  std::vector<std::string> strings;
890  decode(strings, from);
891 
892  for(std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
893  stringItr != stringItrEnd; ++stringItr) {
894  edm::LuminosityBlockRange lumiRange;
895  decode(lumiRange, *stringItr);
896  to.push_back(lumiRange);
897  }
898  return true;
899  } // decode to VInputTag
bool decode(bool &, std::string const &)
Definition: types.cc:62
bool edm::decode ( edm::EventRange to,
std::string const &  from 
)

Definition at line 919 of file types.cc.

References begin, decode(), end, edm::EventID::event(), edm::EventID::luminosityBlock(), edm::EventID::run(), and tokenize().

919  {
920  std::vector<std::string> tokens = edm::tokenize(from, "-");
921  assert(tokens.size() == 2);
924  edm::decode(begin,tokens[0]);
925  edm::decode(end,tokens[1]);
926  assert((begin.luminosityBlock() == 0) == (end.luminosityBlock() == 0));
927  to = edm::EventRange(begin.run(), begin.luminosityBlock(), begin.event(),
928  end.run(), end.luminosityBlock(), end.event());
929  return true;
930  } // decode to EventRange
RunNumber_t run() const
Definition: EventID.h:39
EventNumber_t event() const
Definition: EventID.h:41
LuminosityBlockNumber_t luminosityBlock() const
Definition: EventID.h:40
bool decode(bool &, std::string const &)
Definition: types.cc:62
#define end
Definition: vmac.h:39
#define begin
Definition: vmac.h:32
std::vector< std::string > tokenize(std::string const &input, std::string const &separator)
breaks the input string into tokens, delimited by the separator
bool edm::decode ( std::vector< edm::EventRange > &  to,
std::string const &  from 
)

Definition at line 953 of file types.cc.

References decode(), and nano_cff::strings.

953  {
954  std::vector<std::string> strings;
955  decode(strings, from);
956 
957  for(std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
958  stringItr != stringItrEnd; ++stringItr) {
959  edm::EventRange eventRange;
960  decode(eventRange, *stringItr);
961  to.push_back(eventRange);
962  }
963  return true;
964  }
bool decode(bool &, std::string const &)
Definition: types.cc:62
bool edm::decode ( ParameterSet to,
std::string const &  from 
)

Definition at line 1146 of file types.cc.

1146  {
1147  to = ParameterSet(from);
1148  return true;
1149  } // decode to ParameterSet
bool edm::decode ( std::vector< ParameterSet > &  to,
std::string const &  from 
)

Definition at line 1165 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

1165  {
1166  std::vector<std::string> temp;
1167  if(!split(std::back_inserter(temp), from, '{', ',', '}'))
1168  return false;
1169 
1170  to.clear();
1171  for(std::vector<std::string>::const_iterator b = temp.begin()
1172  , e = temp.end()
1173  ; b != e; ++b) {
1174  ParameterSet val;
1175  if(!decode(val, *b)) {
1176  return false;
1177  }
1178  to.push_back(val);
1179  }
1180 
1181  return true;
1182  } // decode to vector<ParameterSet>
bool decode(bool &, std::string const &)
Definition: types.cc:62
double b
Definition: hdecay.h:120
double split
Definition: MVATrainer.cc:139
std::vector< std::string > edm::defaultCmsRunServices ( )

Definition at line 19 of file defaultCmsRunServices.cc.

19  {
20  std::vector<std::string> returnValue = {"MessageLogger",
21  "InitRootHandlers",
22  "UnixSignalService",
23  "AdaptorConfig",
24  "SiteLocalConfigService",
25  "StatisticsSenderService",
26  "CondorStatusService",
27  "XrdAdaptor::XrdStatisticsService"};
28 
29  return returnValue;
30  }
std::string edm::defaultModuleLabel ( std::string  label)

Definition at line 8 of file defaultModuleLabel.h.

References EnergyCorrector::c, mps_fire::i, diffTwoXMLs::label, and MatrixUtil::remove().

Referenced by edm::ConfigurationDescriptions::addWithDefaultLabel().

8  { // take by value because we'll copy it anyway
9  // remove all colons (module type may contain namespace)
10  label.erase(std::remove(label.begin(), label.end(), ':'), label.end());
11 
12  // the following code originates from HLTrigger/HLTcore/interface/defaultModuleLabel.h
13  // if the label is all uppercase, change it to all lowercase
14  // if the label starts with more than one uppercase letter, change n-1 to lowercase
15  // otherwise, change the first letter to lowercase
16  unsigned int ups = 0;
17  for (char c: label)
18  if (std::isupper(c))
19  ++ups;
20  else
21  break;
22  if (ups > 1 and ups != label.size())
23  --ups;
24  for (unsigned int i = 0; i < ups; ++i)
25  label[i] = std::tolower(label[i]);
26 
27  return label;
28  }
def remove(d, key, TELL=False)
Definition: MatrixUtil.py:211
void edm::disableAllSigs ( sigset_t *  oldset)

Definition at line 36 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

Referenced by installCustomHandler().

37  {
38  sigset_t myset;
39  // all blocked for now
40  MUST_BE_ZERO(sigfillset(&myset));
41  MUST_BE_ZERO(pthread_sigmask(SIG_SETMASK,&myset,oldset));
42  }
#define MUST_BE_ZERO(fun)
bool edm::DisableLoggedErrorsSummary ( )

Definition at line 166 of file MessageSender.cc.

References errorSummaryIsBeingKept.

Referenced by edm::LogErrorHarvester::endJob(), and HLTLogMonitorFilter::endJob().

166  {
167  bool ret = errorSummaryIsBeingKept.exchange(false,std::memory_order_acq_rel);
168  return ret;
169  }
static std::atomic< bool > errorSummaryIsBeingKept
void edm::disableRTSigs ( )

Definition at line 46 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO, and pileupDistInMC::num.

Referenced by installCustomHandler().

47  {
48 #if defined(__linux__)
49  // ignore all the RT signals
50  sigset_t myset;
51  MUST_BE_ZERO(sigemptyset(&myset));
52 
53  struct sigaction tmpact;
54  memset(&tmpact,0,sizeof(tmpact));
55  tmpact.sa_handler = SIG_IGN;
56 
57  for(int num = SIGRTMIN; num <= SIGRTMAX; ++num) {
58  // signal 38 is used by Intel Amplifier
59  if( num == 38) continue;
60 
61 
62  MUST_BE_ZERO(sigaddset(&myset,num));
63  MUST_BE_ZERO(sigaction(num,&tmpact,nullptr));
64  }
65 
66  MUST_BE_ZERO(pthread_sigmask(SIG_BLOCK,&myset,nullptr));
67 #endif
68  }
#define MUST_BE_ZERO(fun)
void edm::disableSignal ( sigset_t *  newset,
int  signum 
)

Definition at line 89 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

90  {
91  // disable the specified signal
92  MUST_BE_ZERO(sigdelset(newset, signum));
93  }
#define MUST_BE_ZERO(fun)
bool edm::distinct ( LuminosityBlockRange const &  lh,
LuminosityBlockRange const &  rh 
)

Definition at line 74 of file LuminosityBlockRange.cc.

References lessThan().

74  {
75  return lessThan(lh, rh) || lessThan(rh, lh);
76  }
bool int lh
Definition: SIMDVec.h:21
bool lessThan(EventRange const &lh, EventRange const &rh)
Definition: EventRange.cc:67
bool edm::distinct ( EventRange const &  lh,
EventRange const &  rh 
)

Definition at line 72 of file EventRange.cc.

References begin, end, edm::EventRange::endEventID(), edm::EventRange::EventRange(), lessThan(), mathSSE::lh, max(), min(), overlaps(), edm::EventRange::startEventID(), and edm::EventRange::startLumi().

Referenced by overlaps(), and cond::persistency::Query< Types... >::Query().

72  {
73  assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
74  return lessThan(lh, rh) || lessThan(rh, lh);
75  }
bool int lh
Definition: SIMDVec.h:21
bool lessThan(EventRange const &lh, EventRange const &rh)
Definition: EventRange.cc:67
void edm::doBuildRealData ( std::string const &  name)

Definition at line 22 of file ClassFiller.cc.

References edm::errors::Configuration, Exception, and FDEBUG.

22  {
23  FDEBUG(3) << "doing BuildRealData for " << name << "\n";
24  TClass* ttest = TClass::GetClass(name.c_str());
25  if (ttest != nullptr) {
26  ttest->BuildRealData();
27  } else {
29  << "Could not find TClass for " << name << "\n";
30  }
31  }
#define FDEBUG(lev)
Definition: DebugMacros.h:20
void edm::doBuildRealData ( const std::string &  name)
const char * edm::edmModuleType ( edm::ModuleDescription const &  module)

Definition at line 35 of file EDMModuleType.cc.

References edmModuleTypeEnum(), and module_type_desc.

36 {
37  return module_type_desc[static_cast<std::underlying_type_t<EDMModuleType>>(edmModuleTypeEnum(module))];
38 }
constexpr const char * module_type_desc[]
Definition: EDMModuleType.h:20
EDMModuleType edmModuleTypeEnum(edm::ModuleDescription const &module)
Definition: vlib.h:208
EDMModuleType edm::edmModuleTypeEnum ( edm::ModuleDescription const &  module)

Definition at line 10 of file EDMModuleType.cc.

References edm::pset::Registry::instance(), kEDAnalyzer, kEDFilter, kEDProducer, kESProducer, kESSource, kOutputModule, kSource, kUnknown, module_type_desc, edm::ModuleDescription::parameterSetID(), muonDTDigis_cfi::pset, PhysicsTools::registry, AlCaHLTBitMon_QueryRunRegistry::string, lumiQTWidget::t, and findQualityFiles::v.

Referenced by edmModuleType(), DependencyGraph::edmModuleType(), and ProcessCallGraph::preBeginJob().

11 {
12  auto const & registry = * edm::pset::Registry::instance();
13  auto const & pset = * registry.getMapped(module.parameterSetID());
14 
15  if (not pset.existsAs<std::string>("@module_edm_type"))
17 
18  std::string const & t = pset.getParameter<std::string>("@module_edm_type");
19  for (EDMModuleType v: {
21  EDMModuleType::kESSource,
22  EDMModuleType::kESProducer,
23  EDMModuleType::kEDAnalyzer,
24  EDMModuleType::kEDProducer,
25  EDMModuleType::kEDFilter,
26  EDMModuleType::kOutputModule
27  }) {
28  if (t == module_type_desc[static_cast<std::underlying_type_t<EDMModuleType>>(v)])
29  return v;
30  }
32 }
EDMModuleType
Definition: EDMModuleType.h:8
constexpr const char * module_type_desc[]
Definition: EDMModuleType.h:20
static const char *const kSource
static Interceptor::Registry registry("Interceptor")
Definition: vlib.h:208
static Registry * instance()
Definition: Registry.cc:13
void edm::edmodule_mightGet_config ( ConfigurationDescriptions iDesc)

Definition at line 37 of file edmodule_mightGet_config.cc.

References edm::ParameterSetDescription::addOptionalUntracked(), edm::ConfigurationDescriptions::defaultDescription(), edm::ParameterSetDescription::isLabelUnused(), kComment, kMightGet(), and findQualityFiles::v.

Referenced by edm::EDAnalyzer::prevalidate(), edm::EDProducer::prevalidate(), edm::EDFilter::prevalidate(), edm::stream::EDAnalyzerBase::prevalidate(), edm::stream::EDProducerBase::prevalidate(), edm::stream::EDFilterBase::prevalidate(), edm::global::EDAnalyzerBase::prevalidate(), edm::limited::EDAnalyzerBase::prevalidate(), edm::one::EDProducerBase::prevalidate(), edm::one::EDFilterBase::prevalidate(), edm::one::EDAnalyzerBase::prevalidate(), edm::global::EDFilterBase::prevalidate(), edm::limited::EDFilterBase::prevalidate(), edm::global::EDProducerBase::prevalidate(), and edm::limited::EDProducerBase::prevalidate().

37  {
38  //NOTE: by not giving a default, we are intentionally not having 'mightGet' added
39  // to any cfi files. This was done intentionally to avoid problems with HLT. If requested,
40  // the appropriate default would be an empty vector.
41  if(iDesc.defaultDescription()) {
42  if (iDesc.defaultDescription()->isLabelUnused(kMightGet)) {
43  iDesc.defaultDescription()->addOptionalUntracked<std::vector<std::string> >(kMightGet)
44  ->setComment(kComment);
45  }
46  }
47  for(auto& v: iDesc) {
48  if (v.second.isLabelUnused(kMightGet)) {
49  v.second.addOptionalUntracked<std::vector<std::string> >(kMightGet)->setComment(kComment);
50  }
51  }
52 
53  }
static const char *const kComment
static const std::string kMightGet("mightGet")
ELseverityLevel const edm::ELdebugGen ( )

Definition at line 251 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_success.

251  {
252  static ELseverityLevel const e( ELseverityLevel::ELsev_success );
253  return e;
254 }
ELseverityLevel const edm::ELerrorGen ( )

Definition at line 269 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_error.

269  {
270  static ELseverityLevel const e( ELseverityLevel::ELsev_error );
271  return e;
272 }
ELseverityLevel const edm::ELhighestSeverityGen ( )

Definition at line 287 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_highestSeverity.

287  {
288  static ELseverityLevel const e( ELseverityLevel::ELsev_highestSeverity );
289  return e;
290 }
ELseverityLevel const edm::ELinfoGen ( )

Definition at line 257 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_info.

257  {
258  static ELseverityLevel const e( ELseverityLevel::ELsev_info );
259  return e;
260 }
ELseverityLevel const edm::ELsevereGen ( )

Definition at line 281 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_severe.

281  {
282  static ELseverityLevel const e( ELseverityLevel::ELsev_severe );
283  return e;
284 }
ELseverityLevel const edm::ELunspecifiedGen ( )

Definition at line 275 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_unspecified.

275  {
276  static ELseverityLevel const e( ELseverityLevel::ELsev_unspecified );
277  return e;
278 }
ELseverityLevel const edm::ELwarningGen ( )

Definition at line 263 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_warning.

263  {
264  static ELseverityLevel const e( ELseverityLevel::ELsev_warning );
265  return e;
266 }
ELseverityLevel const edm::ELzeroSeverityGen ( )

Definition at line 245 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_zeroSeverity.

245  {
246  static ELseverityLevel const e( ELseverityLevel::ELsev_zeroSeverity );
247  return e;
248 }
bool edm::EnableLoggedErrorsSummary ( )

Definition at line 161 of file MessageSender.cc.

References errorSummaryIsBeingKept.

Referenced by edm::LogErrorHarvester::beginJob(), and HLTLogMonitorFilter::beginJob().

161  {
162  bool ret = errorSummaryIsBeingKept.exchange(true,std::memory_order_acq_rel);
163  return ret;
164  }
static std::atomic< bool > errorSummaryIsBeingKept
void edm::enableSignal ( sigset_t *  newset,
int  signum 
)

Definition at line 80 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

81  {
82  // enable the specified signal
83  MUST_BE_ZERO(sigaddset(newset, signum));
84  }
#define MUST_BE_ZERO(fun)
bool edm::encode ( std::string &  to,
bool  from 
)

Definition at line 71 of file types.cc.

Referenced by encode(), and edm::Entry::Entry().

71  {
72  to = from ? "true" : "false";
73  return true;
74  } // encode from bool
bool edm::encode ( std::string &  to,
std::vector< bool > const &  from 
)

Definition at line 104 of file types.cc.

References b, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

104  {
105  to = "{";
106 
107  std::string converted;
108  for(std::vector<bool>::const_iterator b = from.begin()
109  , e = from.end()
110  ; b != e; ++b) {
111  if(!encode(converted, *b)) {
112  return false;
113  }
114  if(b != from.begin()) {
115  to += ",";
116  }
117  to += converted;
118  }
119  to += '}';
120  return true;
121  } // encode from vector<bool>
double b
Definition: hdecay.h:120
def encode(args, files)
bool edm::encode ( std::string &  to,
int  from 
)

Definition at line 153 of file types.cc.

153  {
154  bool is_negative = (from < 0);
155  if(is_negative) {
156  from = -from; // TODO: work around this for most negative integer
157  }
158  to.clear();
159  do {
160  to = static_cast<char>(from % 10 + '0') + to;
161  from /= 10;
162  } while(from > 0);
163  to = (is_negative ? '-' : '+') + to;
164 
165  return true;
166  } // encode from int
bool edm::encode ( std::string &  to,
std::vector< int > const &  from 
)

Definition at line 241 of file types.cc.

References b, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

241  {
242  to = "{";
243 
244  std::string converted;
245  for(std::vector<int>::const_iterator b = from.begin()
246  , e = from.end()
247  ; b != e; ++b) {
248  if(!encode(converted, *b)) {
249  return false;
250  }
251 
252  if(b != from.begin()) {
253  to += ",";
254  }
255  to += converted;
256  }
257 
258  to += '}';
259  return true;
260  } // encode from vector<int>
double b
Definition: hdecay.h:120
def encode(args, files)
bool edm::encode ( std::string &  to,
unsigned int  from 
)

Definition at line 334 of file types.cc.

334  {
335  to.clear();
336  do {
337  to = static_cast<char>(from % 10 + '0') + to;
338  from /= 10u;
339  } while(from > 0u);
340 
341  return true;
342  } // encode from unsigned
bool edm::encode ( std::string &  to,
std::vector< unsigned int > const &  from 
)

Definition at line 405 of file types.cc.

References b, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

405  {
406  to = "{";
407 
408  std::string converted;
409  for(std::vector<unsigned int>::const_iterator b = from.begin()
410  , e = from.end()
411  ; b != e; ++b) {
412  if(!encode(converted, *b)) {
413  return false;
414  }
415  if(b != from.begin()) {
416  to += ",";
417  }
418  to += converted;
419  }
420 
421  to += '}';
422  return true;
423  } // encode from vector<unsigned int>
double b
Definition: hdecay.h:120
def encode(args, files)
bool edm::encode ( std::string &  to,
long long  from 
)

Definition at line 197 of file types.cc.

197  {
198  bool is_negative = (from < 0);
199  if(is_negative) {
200  from = -from; // TODO: work around this for most negative integer
201  }
202 
203  to.clear();
204  do {
205  to = static_cast<char>(from % 10 + '0') + to;
206  from /= 10;
207  } while(from > 0);
208  to = (is_negative ? '-' : '+') + to;
209 
210  return true;
211  } // encode from int
bool edm::encode ( std::string &  to,
std::vector< long long > const &  from 
)

Definition at line 290 of file types.cc.

References b, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

290  {
291  to = "{";
292 
293  std::string converted;
294  for(std::vector<long long>::const_iterator b = from.begin()
295  , e = from.end()
296  ; b != e; ++b) {
297  if(!encode(converted, *b)) {
298  return false;
299  }
300  if(b != from.begin()) {
301  to += ",";
302  }
303  to += converted;
304  }
305  to += '}';
306  return true;
307  } // encode from vector<int>
double b
Definition: hdecay.h:120
def encode(args, files)
bool edm::encode ( std::string &  to,
unsigned long long  from 
)

Definition at line 368 of file types.cc.

368  {
369  to.clear();
370  do {
371  to = static_cast<char>(from % 10 + '0') + to;
372  from /= 10u;
373  } while(from > 0u);
374 
375  return true;
376  } // encode from unsigned
bool edm::encode ( std::string &  to,
std::vector< unsigned long long > const &  from 
)

Definition at line 452 of file types.cc.

References b, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

452  {
453  to = "{";
454 
455  std::string converted;
456  for(std::vector<unsigned long long>::const_iterator b = from.begin()
457  , e = from.end()
458  ; b != e; ++b) {
459  if(!encode(converted, *b)) {
460  return false;
461  }
462 
463  if(b != from.begin()) {
464  to += ",";
465  }
466  to += converted;
467  }
468 
469  to += '}';
470  return true;
471  } // encode from vector<unsigned int>
double b
Definition: hdecay.h:120
def encode(args, files)
bool edm::encode ( std::string &  to,
double  from 
)

Definition at line 508 of file types.cc.

508  {
509  std::ostringstream ost;
510  ost.precision(std::numeric_limits<double>::digits10 + 1);
511  ost << from;
512  if(!ost) return false;
513  to = ost.str();
514  return true;
515  }
bool edm::encode ( std::string &  to,
std::vector< double > const &  from 
)

Definition at line 544 of file types.cc.

References b, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

544  {
545  to = "{";
546 
547  std::string converted;
548  for(std::vector<double>::const_iterator b = from.begin()
549  , e = from.end()
550  ; b != e; ++b) {
551  if(!encode(converted, *b))
552  return false;
553 
554  if(b != from.begin())
555  to += ",";
556  to += converted;
557  }
558 
559  to += '}';
560  return true;
561  } // encode from vector<double>
double b
Definition: hdecay.h:120
def encode(args, files)
bool edm::encode ( std::string &  to,
std::string const &  from 
)

Definition at line 982 of file types.cc.

References append_hex_rep(), b, MillePedeFileConverter_cfg::e, from_hex(), and NONE.

982  {
983  std::string::const_iterator b = from.begin()
984  , e = from.end();
985 
986  enum escape_state { NONE
987  , BACKSLASH
988  , HEX, HEX1
989  , OCT1, OCT2
990  };
991 
992  escape_state state = NONE;
993  int code = 0;
994  to = "";
995  for(; b != e; ++b) {
996  /*std::cerr << "State: " << state << "; char = " << *b << '\n'; //DEBUG*/
997  switch(state) {
998  case NONE: {
999  if(*b == '\\') state = BACKSLASH;
1000  else append_hex_rep(to, *b);
1001  /*std::cerr << "To: |" << to << "|\n"; //DEBUG*/
1002  break;
1003  }
1004  case BACKSLASH: {
1005  code = 0;
1006  switch(*b) {
1007  case 'x': case 'X': {
1008  state = HEX;
1009  break;
1010  }
1011  case '0': case '1': case '2': case '3':
1012  case '4': case '5': case '6': case '7': {
1013  code = 8 * code + from_hex(*b);
1014  state = OCT1;
1015  break;
1016  }
1017  case 'n': {
1018  append_hex_rep(to, 10);
1019  state = NONE;
1020  break;
1021  }
1022  case 't': {
1023  append_hex_rep(to, 9);
1024  state = NONE;
1025  break;
1026  }
1027  default: {
1028  append_hex_rep(to, *b);
1029  state = NONE;
1030  break;
1031  }
1032  }
1033  break;
1034  }
1035  case HEX: {
1036  to += *b;
1037  state = HEX1;
1038  break;
1039  }
1040  case HEX1: {
1041  to += *b;
1042  state = NONE;
1043  break;
1044  }
1045  case OCT1: {
1046  switch(*b) {
1047  case '0': case '1': case '2': case '3':
1048  case '4': case '5': case '6': case '7': {
1049  code = 8 * code + from_hex(*b);
1050  state = OCT2;
1051  break;
1052  }
1053  default: {
1054  append_hex_rep(to, code);
1055  state = NONE;
1056  break;
1057  }
1058  }
1059  break;
1060  }
1061  case OCT2: {
1062  switch(*b) {
1063  case '0': case '1': case '2': case '3':
1064  case '4': case '5': case '6': case '7': {
1065  code = 8 * code + from_hex(*b);
1066  break;
1067  }
1068  default: {
1069  append_hex_rep(to, code);
1070  break;
1071  }
1072  }
1073  state = NONE;
1074  break;
1075  }
1076  default: {
1077  throw std::logic_error("can't happen");
1078  break;
1079  }
1080  }
1081  } // for
1082 
1083  return true;
1084  } // encode from String
static unsigned int from_hex(char c)
Definition: types.cc:36
static void append_hex_rep(std::string &s, unsigned int c)
Definition: types.cc:51
double b
Definition: hdecay.h:120
bool edm::encode ( std::string &  to,
std::vector< std::string > const &  from 
)

Definition at line 1117 of file types.cc.

References b, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

1117  {
1118  to = "{";
1119 
1120  std::string converted;
1121  for(std::vector<std::string>::const_iterator b = from.begin()
1122  , e = from.end()
1123  ; b != e; ++b) {
1124  // treat blank string specially
1125  if(*b == "") {
1126  converted = "XXX";
1127  } else if(!encode(converted, *b)) {
1128  return false;
1129  }
1130 
1131  if(b != from.begin())
1132  to += ",";
1133  to += converted;
1134  }
1135 
1136  to += '}';
1137  return true;
1138  } // encode from vector<string>
double b
Definition: hdecay.h:120
def encode(args, files)
bool edm::encode ( std::string &  to,
edm::FileInPath const &  from 
)

Definition at line 626 of file types.cc.

626  {
627  std::ostringstream ost;
628  ost << from;
629  if (!ost) return false;
630  to = ost.str();
631  return true;
632  }
bool edm::encode ( std::string &  to,
edm::InputTag const &  from 
)

Definition at line 648 of file types.cc.

References edm::InputTag::encode().

648  {
649  to = from.encode();
650  return true;
651  }
bool edm::encode ( std::string &  to,
std::vector< edm::InputTag > const &  from 
)

Definition at line 673 of file types.cc.

References encode(), and nano_cff::strings.

673  {
674  std::vector<std::string> strings;
675  for(std::vector<InputTag>::const_iterator tagItr = from.begin(), tagItrEnd = from.end();
676  tagItr != tagItrEnd; ++tagItr) {
677  strings.push_back(tagItr->encode());
678  }
679  encode(to, strings);
680  return true;
681  }
def encode(args, files)
bool edm::encode ( std::string &  to,
edm::ESInputTag const &  from 
)

Definition at line 698 of file types.cc.

References edm::ESInputTag::encode().

698  {
699  to = from.encode();
700  return true;
701  }
bool edm::encode ( std::string &  to,
std::vector< edm::ESInputTag > const &  from 
)

Definition at line 723 of file types.cc.

References encode(), and nano_cff::strings.

723  {
724  std::vector<std::string> strings;
725  for(std::vector<ESInputTag>::const_iterator tagItr = from.begin(), tagItrEnd = from.end();
726  tagItr != tagItrEnd; ++tagItr) {
727  strings.push_back(tagItr->encode());
728  }
729  encode(to, strings);
730  return true;
731  }
def encode(args, files)
bool edm::encode ( std::string &  to,
edm::EventID const &  from 
)

Definition at line 753 of file types.cc.

References edm::EventID::event(), edm::EventID::luminosityBlock(), edm::EventID::run(), and mitigatedMETSequence_cff::U.

753  {
754  std::ostringstream os;
755  if (from.luminosityBlock() == 0U) {
756  os << from.run() << ":" << from.event();
757  } else {
758  os << from.run() << ":" << from.luminosityBlock() << ":" << from.event();
759  }
760  to = os.str();
761  return true;
762  }
bool edm::encode ( std::string &  to,
std::vector< edm::EventID > const &  from 
)

Definition at line 786 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and nano_cff::strings.

786  {
787  std::vector<std::string> strings;
788  for(std::vector<edm::EventID>::const_iterator idItr = from.begin(), idItrEnd = from.end();
789  idItr != idItrEnd; ++idItr) {
790  std::string encodedEventID;
791  encode(encodedEventID, *idItr);
792  strings.push_back(encodedEventID);
793  }
794  encode(to, strings);
795  return true;
796  }
def encode(args, files)
bool edm::encode ( std::string &  to,
edm::LuminosityBlockID const &  from 
)

Definition at line 815 of file types.cc.

References edm::LuminosityBlockID::luminosityBlock(), and edm::LuminosityBlockID::run().

815  {
816  std::ostringstream os;
817  os << from.run() << ":" << from.luminosityBlock();
818  to = os.str();
819  return true;
820  }
bool edm::encode ( std::string &  to,
std::vector< edm::LuminosityBlockID > const &  from 
)

Definition at line 844 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and nano_cff::strings.

844  {
845  std::vector<std::string> strings;
846  for(std::vector<edm::LuminosityBlockID>::const_iterator idItr = from.begin(), idItrEnd = from.end();
847  idItr != idItrEnd; ++idItr) {
848  std::string encodedLuminosityBlockID;
849  encode(encodedLuminosityBlockID, *idItr);
850  strings.push_back(encodedLuminosityBlockID);
851  }
852  encode(to, strings);
853  return true;
854  }
def encode(args, files)
bool edm::encode ( std::string &  to,
edm::LuminosityBlockRange const &  from 
)

Definition at line 875 of file types.cc.

References edm::LuminosityBlockRange::endLumi(), edm::LuminosityBlockRange::endRun(), edm::LuminosityBlockRange::startLumi(), and edm::LuminosityBlockRange::startRun().

875  {
876  std::ostringstream os;
877  os << from.startRun() << ":" << from.startLumi() << "-"
878  << from.endRun() << ":" << from.endLumi();
879  to = os.str();
880  return true;
881  }
bool edm::encode ( std::string &  to,
std::vector< edm::LuminosityBlockRange > const &  from 
)

Definition at line 902 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and nano_cff::strings.

902  {
903  std::vector<std::string> strings;
904  for(std::vector<edm::LuminosityBlockRange>::const_iterator idItr = from.begin(), idItrEnd = from.end();
905  idItr != idItrEnd; ++idItr) {
906  std::string encodedLuminosityBlockRange;
907  encode(encodedLuminosityBlockRange, *idItr);
908  strings.push_back(encodedLuminosityBlockRange);
909  }
910  encode(to, strings);
911  return true;
912  }
def encode(args, files)
bool edm::encode ( std::string &  to,
edm::EventRange const &  from 
)

Definition at line 933 of file types.cc.

References edm::EventRange::endEvent(), edm::EventRange::endLumi(), edm::EventRange::endRun(), edm::EventRange::startEvent(), edm::EventRange::startLumi(), and edm::EventRange::startRun().

933  {
934  std::ostringstream os;
935  if (from.startLumi() == 0) {
936  assert(from.endLumi() == 0);
937  os << from.startRun() << ":" << from.startEvent() << "-"
938  << from.endRun() << ":" << from.endEvent();
939  } else {
940  assert(from.endLumi() != 0);
941  os << from.startRun() << ":" << from.startLumi() << ":" << from.startEvent() << "-"
942  << from.endRun() << ":" << from.endLumi() << ":" << from.endEvent();
943  }
944  to = os.str();
945  return true;
946  }
bool edm::encode ( std::string &  to,
std::vector< edm::EventRange > const &  from 
)

Definition at line 967 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and nano_cff::strings.

967  {
968  std::vector<std::string> strings;
969  for(std::vector<edm::EventRange>::const_iterator idItr = from.begin(), idItrEnd = from.end();
970  idItr != idItrEnd; ++idItr) {
971  std::string encodedEventRange;
972  encode(encodedEventRange, *idItr);
973  strings.push_back(encodedEventRange);
974  }
975  encode(to, strings);
976  return true;
977  }
def encode(args, files)
bool edm::encode ( std::string &  to,
ParameterSet const &  from 
)

Definition at line 1154 of file types.cc.

References edm::ParameterSet::toString().

1154  {
1155  to = from.toString();
1156  return true;
1157  } // encode from ParameterSet
bool edm::encode ( std::string &  to,
std::vector< ParameterSet > const &  from 
)

Definition at line 1187 of file types.cc.

References b, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

1187  {
1188  to = "{";
1189 
1190  std::string converted;
1191  for(std::vector<ParameterSet>::const_iterator b = from.begin()
1192  , e = from.end()
1193  ; b != e; ++b) {
1194  if(!encode(converted, *b)) {
1195  return false;
1196  }
1197  if(b != from.begin()) {
1198  to += ",";
1199  }
1200  to += converted;
1201  }
1202  to += '}';
1203  return true;
1204  } // encode from vector<ParameterSet>
double b
Definition: hdecay.h:120
def encode(args, files)
template<typename Traits , typename P , typename SC >
void edm::endGlobalTransitionAsync ( WaitingTaskHolder  iWait,
Schedule iSchedule,
P iPrincipal,
IOVSyncValue const &  iTS,
EventSetup const &  iES,
ServiceToken const &  token,
SC &  iSubProcesses,
bool  cleaningUpAfterException 
)

Definition at line 88 of file globalTransitionAsync.h.

References edm::WaitingTaskHolder::doneWaiting(), h, make_waiting_task(), eostools::move(), edm::Schedule::processOneGlobalAsync(), and subProcessDoGlobalEndTransitionAsync().

96  {
97  //When we are done processing the global for this process,
98  // we need to run the global for all SubProcesses
99  auto subs = make_waiting_task(tbb::task::allocate_root(), [&iSubProcesses, iWait,&iPrincipal,iTS,cleaningUpAfterException](std::exception_ptr const* iPtr) mutable {
100  if(iPtr) {
101  auto excpt = *iPtr;
102  auto delayError = make_waiting_task(tbb::task::allocate_root(), [iWait,excpt](std::exception_ptr const* ) mutable {
103  iWait.doneWaiting(excpt);
104  });
105  WaitingTaskHolder h(delayError);
106  for(auto& subProcess: iSubProcesses){
107  subProcessDoGlobalEndTransitionAsync(h,subProcess,iPrincipal, iTS,cleaningUpAfterException);
108  }
109  } else {
110  for(auto& subProcess: iSubProcesses){
111  subProcessDoGlobalEndTransitionAsync(iWait,subProcess,iPrincipal, iTS,cleaningUpAfterException);
112  }
113  }
114  });
115 
116  WaitingTaskHolder h(subs);
117  iSchedule.processOneGlobalAsync<Traits>(std::move(h),iPrincipal, iES,token,cleaningUpAfterException);
118  }
FWCore Framework interface EventSetupRecordImplementation h
Helper function to determine trigger accepts.
FunctorWaitingTask< F > * make_waiting_task(ALLOC &&iAlloc, F f)
Definition: WaitingTask.h:92
void subProcessDoGlobalEndTransitionAsync(WaitingTaskHolder iHolder, SubProcess &iSubProcess, RunPrincipal &iPrincipal, IOVSyncValue const &iTS, bool cleaningUpAfterException)
def move(src, dest)
Definition: eostools.py:510
template<typename Traits , typename P , typename SC >
void edm::endStreamsTransitionAsync ( WaitingTaskHolder  iWait,
Schedule iSchedule,
unsigned int  iNStreams,
P iPrincipal,
IOVSyncValue const &  iTS,
EventSetup const &  iES,
ServiceToken const &  iToken,
SC &  iSubProcesses,
bool  cleaningUpAfterException 
)

Definition at line 142 of file streamTransitionAsync.h.

References mps_fire::i.

151  {
152  for(unsigned int i=0; i<iNStreams;++i) {
153  endStreamTransitionAsync<Traits>(iWait,
154  iSchedule,i,
155  iPrincipal,iTS,iES, iToken,
156  iSubProcesses,cleaningUpAfterException);
157  }
158  }
template<typename Traits , typename P , typename SC >
void edm::endStreamTransitionAsync ( WaitingTaskHolder  iWait,
Schedule iSchedule,
unsigned int  iStreamIndex,
P iPrincipal,
IOVSyncValue const &  iTS,
EventSetup const &  iES,
ServiceToken const &  token,
SC &  iSubProcesses,
bool  cleaningUpAfterException 
)

Definition at line 107 of file streamTransitionAsync.h.

References edm::WaitingTaskHolder::doneWaiting(), h, make_waiting_task(), edm::Schedule::processOneStreamAsync(), and subProcessDoStreamEndTransitionAsync().

116  {
117  //When we are done processing the stream for this process,
118  // we need to run the stream for all SubProcesses
119  //NOTE: The subprocesses set their own service tokens
120 
121  auto subs = make_waiting_task(tbb::task::allocate_root(), [&iSubProcesses, iWait,iStreamIndex,&iPrincipal,iTS,cleaningUpAfterException](std::exception_ptr const* iPtr) mutable {
122  if(iPtr) {
123  auto excpt = *iPtr;
124  auto delayError = make_waiting_task(tbb::task::allocate_root(), [iWait,excpt](std::exception_ptr const* ) mutable {
125  iWait.doneWaiting(excpt);
126  });
127  WaitingTaskHolder h(delayError);
128  for(auto& subProcess: iSubProcesses) {
129  subProcessDoStreamEndTransitionAsync(h,subProcess,iStreamIndex,iPrincipal, iTS,cleaningUpAfterException);
130  }
131  } else {
132  for(auto& subProcess: iSubProcesses) {
133  subProcessDoStreamEndTransitionAsync(iWait,subProcess,iStreamIndex,iPrincipal, iTS,cleaningUpAfterException);
134  }
135  }
136  });
137 
138  iSchedule.processOneStreamAsync<Traits>(WaitingTaskHolder(subs), iStreamIndex,iPrincipal, iES, token, cleaningUpAfterException);
139  }
FWCore Framework interface EventSetupRecordImplementation h
Helper function to determine trigger accepts.
void subProcessDoStreamEndTransitionAsync(WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, RunPrincipal &iPrincipal, IOVSyncValue const &iTS, bool cleaningUpAfterException)
FunctorWaitingTask< F > * make_waiting_task(ALLOC &&iAlloc, F f)
Definition: WaitingTask.h:92
void edm::ep_sigusr2 ( int  ,
siginfo_t *  ,
void *   
)

Definition at line 25 of file UnixSignalHandlers.cc.

References FDEBUG, and shutdown_flag.

Referenced by edm::service::UnixSignalService::UnixSignalService().

26  {
27  FDEBUG(1) << "in sigusr2 handler\n";
28  shutdown_flag.store(true);
29  }
volatile std::atomic< bool > shutdown_flag
#define FDEBUG(lev)
Definition: DebugMacros.h:20
bool edm::eq ( const ELstring s1,
const ELstring  s2 
)

Definition at line 42 of file ELstring.cc.

References indexGen::s2.

42  {
43 
44  return s1 == s2;
45 
46 } // eq()
bool edm::eq_nocase ( const ELstring s1,
const char  s2[] 
)

Definition at line 24 of file ELstring.cc.

References p1, p2, and indexGen::s2.

Referenced by edm::ErrorObj::emitToken().

24  {
25  using std::toupper;
26 
27  if (s1.length() != strlen(s2) ) return false;
28 
29  ELstring::const_iterator p1;
30  const char * p2;
31 
32  for ( p1 = s1.begin(), p2 = s2; *p2 != '\0'; ++p1, ++p2 ) {
33  if ( toupper(*p1) != toupper(*p2) ) {
34  return false;
35  }
36  }
37  return true;
38 
39 } // eq_nocase()
double p2[4]
Definition: TauolaWrapper.h:90
double p1[4]
Definition: TauolaWrapper.h:89
template<class FP >
bool edm::equal_isnan ( FP  x)
inline

Definition at line 61 of file math.h.

Referenced by isnan().

62  {
63  return x !=x;
64  }
void edm::exceptionContext ( std::ostream &  os,
GlobalContext const &  gc 
)

Definition at line 61 of file GlobalContext.cc.

References edm::GlobalContext::kBeginJob, edm::GlobalContext::kBeginLuminosityBlock, edm::GlobalContext::kBeginRun, edm::GlobalContext::kEndJob, edm::GlobalContext::kEndLuminosityBlock, edm::GlobalContext::kEndRun, edm::GlobalContext::kWriteLuminosityBlock, edm::GlobalContext::kWriteRun, edm::GlobalContext::luminosityBlockID(), edm::LuminosityBlockID::run(), and edm::GlobalContext::transition().

Referenced by edm::Worker::activityRegistry(), edm::Worker::exceptionContext(), and edm::Worker::runModule().

61  {
62  os << "Processing ";
63  switch (gc.transition()) {
64  case GlobalContext::Transition::kBeginJob:
65  os << "begin Job";
66  break;
67  case GlobalContext::Transition::kBeginRun:
68  os << "global begin Run " <<RunID(gc.luminosityBlockID().run());
69  break;
70  case GlobalContext::Transition::kBeginLuminosityBlock:
71  os << "global begin LuminosityBlock "<<gc.luminosityBlockID();
72  break;
73  case GlobalContext::Transition::kEndLuminosityBlock:
74  os << "global end LuminosityBlock "<<gc.luminosityBlockID();
75  break;
76  case GlobalContext::Transition::kEndRun:
77  os << "global end Run "<<RunID(gc.luminosityBlockID().run());
78  break;
79  case GlobalContext::Transition::kEndJob:
80  os << "endJob";
81  break;
82  case GlobalContext::Transition::kWriteRun:
83  os << "write Run "<<RunID(gc.luminosityBlockID().run());
84  break;
85  case GlobalContext::Transition::kWriteLuminosityBlock:
86  os << "write LuminosityBlock "<<gc.luminosityBlockID();
87  break;
88  }
89  }
void edm::exceptionContext ( std::ostream &  os,
StreamContext const &  sc 
)

Definition at line 76 of file StreamContext.cc.

References edm::StreamContext::eventID(), edm::StreamContext::kBeginLuminosityBlock, edm::StreamContext::kBeginRun, edm::StreamContext::kBeginStream, edm::StreamContext::kEndLuminosityBlock, edm::StreamContext::kEndRun, edm::StreamContext::kEndStream, edm::StreamContext::kEvent, edm::StreamContext::kInvalid, findQualityFiles::run, edm::StreamContext::streamID(), and edm::StreamContext::transition().

76  {
77  os << "Processing " ;
78  auto id = sc.eventID();
79  switch (sc.transition()) {
81  os << "begin Stream";
82  break;
83  case StreamContext::Transition::kBeginRun:
84  os << "stream begin Run " <<RunID(id.run());
85  break;
86  case StreamContext::Transition::kBeginLuminosityBlock:
87  os << "stream begin LuminosityBlock "<<LuminosityBlockID(id.run(), id.luminosityBlock());
88  break;
89  case StreamContext::Transition::kEvent:
90  os << "Event "<<sc.eventID();
91  break;
92  case StreamContext::Transition::kEndLuminosityBlock:
93  os << "stream end LuminosityBlock "<<LuminosityBlockID(id.run(), id.luminosityBlock());
94  break;
95  case StreamContext::Transition::kEndRun:
96  os << "stream end Run "<<RunID(id.run());
97  break;
99  os << "end Stream";
100  break;
101  case StreamContext::Transition::kInvalid:
102  os << "Invalid";
103  break;
104  }
105  os <<" stream: "<<sc.streamID();
106  }
void edm::fillDescriptionFromPSet ( ParameterSet const &  pset,
ParameterSetDescription desc 
)

Definition at line 88 of file FillDescriptionFromPSet.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addUntracked(), mps_splice::entry, edm::ParameterSet::getParameterSet(), edm::ParameterSet::getParameterSetVector(), edm::ParameterSet::getUntrackedParameterSet(), edm::ParameterSet::getUntrackedParameterSetVector(), eostools::move(), edm::ParameterSet::psetTable(), edm::ParameterSet::tbl(), and edm::ParameterSet::vpsetTable().

Referenced by edm::ParameterDescription< std::vector< ParameterSet > >::printNestedContent_(), and edm::ParameterDescription< std::vector< ParameterSet > >::writeOneElementToCfi().

89  {
90  ParameterSet::table const& entries = pset.tbl();
91  for (ParameterSet::table::const_iterator entry = entries.begin(),
92  endEntries = entries.end();
93  entry != endEntries;
94  ++entry) {
95  std::map<edm::ParameterTypes, FillDescriptionFromParameter>::iterator iter =
96  findTheRightFunction().find(static_cast<edm::ParameterTypes>(entry->second.typeCode()));
97  if (iter != findTheRightFunction().end()) {
98  iter->second(pset, entry->first, entry->second.isTracked(), desc);
99  }
100  }
101 
102  ParameterSet::psettable const& pset_entries = pset.psetTable();
103  for (ParameterSet::psettable::const_iterator pset_entry = pset_entries.begin(),
104  endEntries = pset_entries.end();
105  pset_entry != endEntries;
106  ++pset_entry) {
107  edm::ParameterSet nestedPset;
108  if (pset_entry->second.isTracked()) {
109  nestedPset = pset.getParameterSet(pset_entry->first);
110  }
111  else {
112  nestedPset = pset.getUntrackedParameterSet(pset_entry->first);
113  }
114  ParameterSetDescription nestedDescription;
115  fillDescriptionFromPSet(nestedPset, nestedDescription);
116  if (pset_entry->second.isTracked()) {
117  desc.add<edm::ParameterSetDescription>(pset_entry->first, nestedDescription);
118  }
119  else {
120  desc.addUntracked<edm::ParameterSetDescription>(pset_entry->first, nestedDescription);
121  }
122  }
123 
124  ParameterSet::vpsettable const& vpset_entries = pset.vpsetTable();
125  for (ParameterSet::vpsettable::const_iterator vpset_entry = vpset_entries.begin(),
126  endEntries = vpset_entries.end();
127  vpset_entry != endEntries;
128  ++vpset_entry) {
129  std::vector<edm::ParameterSet> nestedVPset;
130  if (vpset_entry->second.isTracked()) {
131  nestedVPset = pset.getParameterSetVector(vpset_entry->first);
132  }
133  else {
134  nestedVPset = pset.getUntrackedParameterSetVector(vpset_entry->first);
135  }
136  ParameterSetDescription emptyDescription;
137 
138  auto pd = std::make_unique<ParameterDescription<std::vector<ParameterSet>>>(vpset_entry->first, emptyDescription, vpset_entry->second.isTracked(), nestedVPset);
139 
140  pd->setPartOfDefaultOfVPSet(true);
141  std::unique_ptr<ParameterDescriptionNode> node(std::move(pd));
142  desc.addNode(std::move(node));
143  }
144  }
void fillDescriptionFromPSet(ParameterSet const &pset, ParameterSetDescription &desc)
def move(src, dest)
Definition: eostools.py:510
std::shared_ptr<EDLooperBase> edm::fillLooper ( eventsetup::EventSetupsController esController,
eventsetup::EventSetupProvider cp,
ParameterSet params 
)

Definition at line 191 of file EventProcessor.cc.

References reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), and edm::ParameterSet::registerIt().

Referenced by edm::EventProcessor::init().

193  {
194  std::shared_ptr<EDLooperBase> vLooper;
195 
196  std::vector<std::string> loopers = params.getParameter<std::vector<std::string> >("@all_loopers");
197 
198  if(loopers.empty()) {
199  return vLooper;
200  }
201 
202  assert(1 == loopers.size());
203 
204  for(std::vector<std::string>::iterator itName = loopers.begin(), itNameEnd = loopers.end();
205  itName != itNameEnd;
206  ++itName) {
207 
208  ParameterSet* providerPSet = params.getPSetForUpdate(*itName);
209  providerPSet->registerIt();
210  vLooper = eventsetup::LooperFactory::get()->addTo(esController,
211  cp,
212  *providerPSet);
213  }
214  return vLooper;
215  }
T get(const Candidate &c)
Definition: component.h:55
void edm::fillMaxEventsDescription ( ParameterSetDescription description)

Definition at line 57 of file validateTopLevelParameterSets.cc.

References edm::ParameterSetDescription::addOptionalNode(), edm::ParameterSetDescription::addUntracked(), and edm::ParameterSetDescription::addWildcardUntracked().

Referenced by validateTopLevelParameterSets().

57  {
58  description.addUntracked<int>("input", -1)->
59  setComment("Default of -1 implies no limit.");
60 
61  ParameterSetDescription nestedDescription;
62  nestedDescription.addWildcardUntracked<int>("*");
63  description.addOptionalNode(ParameterDescription<int>("output", false) xor
64  ParameterDescription<ParameterSetDescription>("output", nestedDescription, false), false);
65 }
void edm::fillMaxLuminosityBlocksDescription ( ParameterSetDescription description)

Definition at line 67 of file validateTopLevelParameterSets.cc.

References edm::ParameterSetDescription::addUntracked().

Referenced by validateTopLevelParameterSets().

67  {
68  description.addUntracked<int>("input", -1)->
69  setComment("Default of -1 implies no limit.");
70 }
void edm::fillMaxSecondsUntilRampdownDescription ( ParameterSetDescription description)

Definition at line 72 of file validateTopLevelParameterSets.cc.

References edm::ParameterSetDescription::addUntracked().

Referenced by validateTopLevelParameterSets().

72  {
73  description.addUntracked<int>("input", -1)->
74  setComment("Default of -1 implies no limit.");
75 }
static void edm::fillModuleInPathSummary ( Path const &  path,
size_t  which,
ModuleInPathSummary sum 
)
static

Definition at line 834 of file StreamSchedule.cc.

References edm::Worker::description(), edm::Path::getWorker(), edm::ModuleInPathSummary::moduleLabel, edm::ModuleDescription::moduleLabel(), edm::ModuleInPathSummary::timesExcept, edm::Path::timesExcept(), edm::ModuleInPathSummary::timesFailed, edm::Path::timesFailed(), edm::ModuleInPathSummary::timesPassed, edm::Path::timesPassed(), edm::ModuleInPathSummary::timesVisited, and edm::Path::timesVisited().

Referenced by fillPathSummary().

836  {
837  sum.timesVisited += path.timesVisited(which);
838  sum.timesPassed += path.timesPassed(which);
839  sum.timesFailed += path.timesFailed(which);
840  sum.timesExcept += path.timesExcept(which);
841  sum.moduleLabel = path.getWorker(which)->description().moduleLabel();
842  }
def which(cmd)
Definition: eostools.py:335
void edm::fillOptionsDescription ( ParameterSetDescription description)

Definition at line 14 of file validateTopLevelParameterSets.cc.

References edm::ParameterSetDescription::addOptionalUntracked(), edm::ParameterSetDescription::addUntracked(), s_defaultNumberOfThreads, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by validateTopLevelParameterSets().

14  {
15 
16  description.addUntracked<unsigned int>("numberOfThreads", s_defaultNumberOfThreads)->
17  setComment("If zero, let TBB use its default which is normally the number of CPUs on the machine");
18  description.addUntracked<unsigned int>("numberOfStreams", 0)->
19  setComment("If zero, then set the number of streams to be the same as the number of threads");
20  description.addUntracked<unsigned int>("numberOfConcurrentRuns", 1);
21  description.addUntracked<unsigned int>("numberOfConcurrentLuminosityBlocks", 1)->
22  setComment("If zero, then set the same as the number of runs");
23  description.addUntracked<bool>("wantSummary", false)->
24  setComment("Set true to print a report on the trigger decisions and timing of modules");
25  description.addUntracked<std::string>("fileMode", "FULLMERGE")->
26  setComment("Legal values are 'NOMERGE' and 'FULLMERGE'");
27  description.addUntracked<bool>("forceEventSetupCacheClearOnNewRun", false);
28  description.addUntracked<bool>("throwIfIllegalParameter", true)->
29  setComment("Set false to disable exception throws when configuration validation detects illegal parameters");
30  description.addUntracked<bool>("printDependencies", false)->
31  setComment("Print data dependencies between modules");
32 
33 
34  // No default for this one because the parameter value is
35  // actually used in the main function in cmsRun.cpp before
36  // the parameter set is validated here.
37  description.addOptionalUntracked<unsigned int>("sizeOfStackForThreadsInKB");
38 
39  std::vector<std::string> emptyVector;
40 
41  description.addUntracked<std::vector<std::string>>("Rethrow", emptyVector);
42  description.addUntracked<std::vector<std::string>>("SkipEvent", emptyVector);
43  description.addUntracked<std::vector<std::string>>("FailPath", emptyVector);
44  description.addUntracked<std::vector<std::string>>("IgnoreCompletely", emptyVector);
45 
46  description.addUntracked<std::vector<std::string>>("canDeleteEarly", emptyVector)->
47  setComment("Branch names of products that the Framework can try to delete before the end of the Event");
48 
49  description.addOptionalUntracked<bool>("allowUnscheduled")->
50  setComment("Obsolete. Has no effect. Allowed only for backward compatibility for old Python configuration files.");
51  description.addOptionalUntracked<std::string>("emptyRunLumiMode")->
52  setComment("Obsolete. Has no effect. Allowed only for backward compatibility for old Python configuration files.");
53  description.addOptionalUntracked<bool>("makeTriggerResults")->
54  setComment("Obsolete. Has no effect. Allowed only for backward compatibility for old Python configuration files.");
55 }
constexpr unsigned int s_defaultNumberOfThreads
void edm::fillParameterSetBranch ( TTree *  parameterSetsTree,
int  basketSize 
)

Definition at line 18 of file CommonProvenanceFiller.cc.

References b, edm::poolNames::idToParameterSetBlobsBranchName(), edm::pset::Registry::instance(), and muonDTDigis_cfi::pset.

Referenced by NanoAODOutputModule::reallyCloseFile(), and edm::RootOutputFile::writeParameterSetRegistry().

18  {
19 
20  std::pair<ParameterSetID, ParameterSetBlob> idToBlob;
21  std::pair<ParameterSetID, ParameterSetBlob>* pIdToBlob = &idToBlob;
22  TBranch* b = parameterSetsTree->Branch(poolNames::idToParameterSetBlobsBranchName().c_str(), &pIdToBlob, basketSize, 0);
23 
24  for (auto const& pset : *pset::Registry::instance()) {
25  idToBlob.first = pset.first;
26  idToBlob.second.pset() = pset.second.toString();
27 
28  b->Fill();
29  }
30  }
std::string const & idToParameterSetBlobsBranchName()
Definition: BranchType.cc:255
static PFTauRenderPlugin instance
double b
Definition: hdecay.h:120
static void edm::fillPathSummary ( Path const &  path,
PathSummary sum 
)
static

Definition at line 845 of file StreamSchedule.cc.

References edm::PathSummary::bitPosition, edm::Path::bitPosition(), fillModuleInPathSummary(), mps_fire::i, edm::PathSummary::moduleInPathSummaries, edm::PathSummary::name, edm::Path::name(), edm::Path::size(), groupFilesInBlocks::temp, edm::PathSummary::timesExcept, edm::Path::timesExcept(), edm::PathSummary::timesFailed, edm::Path::timesFailed(), edm::PathSummary::timesPassed, edm::Path::timesPassed(), edm::PathSummary::timesRun, and edm::Path::timesRun().

Referenced by edm::SystemTimeKeeper::fillTriggerTimingReport(), and edm::StreamSchedule::getTriggerReport().

845  {
846  sum.name = path.name();
847  sum.bitPosition = path.bitPosition();
848  sum.timesRun += path.timesRun();
849  sum.timesPassed += path.timesPassed();
850  sum.timesFailed += path.timesFailed();
851  sum.timesExcept += path.timesExcept();
852 
853  Path::size_type sz = path.size();
854  if(sum.moduleInPathSummaries.empty()) {
855  std::vector<ModuleInPathSummary> temp(sz);
856  for (size_t i = 0; i != sz; ++i) {
858  }
859  sum.moduleInPathSummaries.swap(temp);
860  } else {
861  assert(sz == sum.moduleInPathSummaries.size());
862  for (size_t i = 0; i != sz; ++i) {
863  fillModuleInPathSummary(path, i, sum.moduleInPathSummaries[i]);
864  }
865  }
866  }
static void fillModuleInPathSummary(Path const &path, size_t which, ModuleInPathSummary &sum)
uint16_t size_type
void edm::fillProcessHistoryBranch ( TTree *  metaDataTree,
int  basketSize,
ProcessHistoryRegistry const &  processHistoryRegistry 
)

Definition at line 32 of file CommonProvenanceFiller.cc.

References b, AlCaHLTBitMon_ParallelJobs::p, and edm::poolNames::processHistoryBranchName().

Referenced by NanoAODOutputModule::reallyCloseFile(), and edm::RootOutputFile::writeProcessHistoryRegistry().

32  {
33  ProcessHistoryVector procHistoryVector;
34  for(auto const& ph : processHistoryRegistry) {
35  procHistoryVector.push_back(ph.second);
36  }
37  ProcessHistoryVector* p = &procHistoryVector;
38  TBranch* b = metaDataTree->Branch(poolNames::processHistoryBranchName().c_str(), &p, basketSize, 0);
39  assert(b);
40  b->Fill();
41  }
std::vector< ProcessHistory > ProcessHistoryVector
std::string const & processHistoryBranchName()
Definition: BranchType.cc:198
double b
Definition: hdecay.h:120
template<typename T , typename A >
void edm::fillPtrVector ( std::vector< T, A > const &  obj,
std::type_info const &  iToType,
std::vector< unsigned long > const &  iIndicies,
std::vector< void const * > &  oPtr 
)

Definition at line 85 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

Referenced by edm::WrapperBase::isPresent(), and edm::SortedCollection< FTLDataFrameT< ETLDetId, ETLSample > >::pop_back().

88  {
89  detail::reallyfillPtrVector(obj, iToType, iIndicies, oPtr);
90  }
void reallyfillPtrVector(COLLECTION const &coll, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const * > &oPtr)
Definition: fillPtrVector.h:38
template<typename T , typename A >
void edm::fillPtrVector ( std::list< T, A > const &  obj,
std::type_info const &  iToType,
std::vector< unsigned long > const &  iIndicies,
std::vector< void const * > &  oPtr 
)

Definition at line 94 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

97  {
98  detail::reallyfillPtrVector(obj, iToType, iIndicies, oPtr);
99  }
void reallyfillPtrVector(COLLECTION const &coll, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const * > &oPtr)
Definition: fillPtrVector.h:38
template<typename T , typename A >
void edm::fillPtrVector ( std::deque< T, A > const &  obj,
std::type_info const &  iToType,
std::vector< unsigned long > const &  iIndicies,
std::vector< void const * > &  oPtr 
)

Definition at line 103 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

106  {
107  detail::reallyfillPtrVector(obj, iToType, iIndicies, oPtr);
108  }
void reallyfillPtrVector(COLLECTION const &coll, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const * > &oPtr)
Definition: fillPtrVector.h:38
template<typename T , typename A , typename Comp >
void edm::fillPtrVector ( std::set< T, A, Comp > const &  obj,
std::type_info const &  iToType,
std::vector< unsigned long > const &  iIndicies,
std::vector< void const * > &  oPtr 
)

Definition at line 112 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

115  {
116  detail::reallyfillPtrVector(obj, iToType, iIndicies, oPtr);
117  }
void reallyfillPtrVector(COLLECTION const &coll, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const * > &oPtr)
Definition: fillPtrVector.h:38
template<typename T , typename SORT >
void edm::fillPtrVector ( SortedCollection< T, SORT > const &  obj,
std::type_info const &  toType,
std::vector< unsigned long > const &  indices,
std::vector< void const * > &  ptrs 
)
inline

Definition at line 473 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::fillPtrVector().

476  {
477  obj.fillPtrVector(toType, indices, ptrs);
478  }
template<typename T , unsigned int M, typename P >
void edm::fillPtrVector ( OwnArray< T, M, P > const &  obj,
std::type_info const &  toType,
std::vector< unsigned long > const &  indices,
std::vector< void const * > &  ptrs 
)
inline

Definition at line 489 of file OwnArray.h.

References edm::OwnArray< T, MAX_SIZE, P >::fillPtrVector().

492  {
493  obj.fillPtrVector(toType, indices, ptrs);
494  }
template<typename T , typename P >
void edm::fillPtrVector ( OwnVector< T, P > const &  obj,
std::type_info const &  toType,
std::vector< unsigned long > const &  indices,
std::vector< void const * > &  ptrs 
)
inline

Definition at line 564 of file OwnVector.h.

References edm::OwnVector< T, P >::fillPtrVector().

567  {
568  obj.fillPtrVector(toType, indices, ptrs);
569  }
template<class T , class A >
void edm::fillView ( std::vector< T, A > const &  obj,
ProductID const &  id,
std::vector< void const * > &  ptrs,
FillViewHelperVector helpers 
)

Definition at line 49 of file FillView.h.

References edm::detail::reallyFillView().

53  {
55  }
void reallyFillView(COLLECTION const &coll, ProductID const &id, std::vector< void const * > &ptrs, FillViewHelperVector &helpers)
Definition: FillView.h:27
template<class T , class A >
void edm::fillView ( std::list< T, A > const &  obj,
ProductID const &  id,
std::vector< void const * > &  ptrs,
FillViewHelperVector helpers 
)

Definition at line 59 of file FillView.h.

References edm::detail::reallyFillView().

63  {
65  }
void reallyFillView(COLLECTION const &coll, ProductID const &id, std::vector< void const * > &ptrs, FillViewHelperVector &helpers)
Definition: FillView.h:27
template<class T , class A >
void edm::fillView ( std::deque< T, A > const &  obj,
ProductID const &  id,
std::vector< void const * > &  ptrs,
FillViewHelperVector helpers 
)

Definition at line 69 of file FillView.h.

References edm::detail::reallyFillView().

73  {
75  }
void reallyFillView(COLLECTION const &coll, ProductID const &id, std::vector< void const * > &ptrs, FillViewHelperVector &helpers)
Definition: FillView.h:27
template<class T , class A , class Comp >
void edm::fillView ( std::set< T, A, Comp > const &  obj,
ProductID const &  id,
std::vector< void const * > &  ptrs,
FillViewHelperVector helpers 
)

Definition at line 79 of file FillView.h.

References edm::detail::reallyFillView().

83  {
85  }
void reallyFillView(COLLECTION const &coll, ProductID const &id, std::vector< void const * > &ptrs, FillViewHelperVector &helpers)
Definition: FillView.h:27
template<typename T >
void edm::fillView ( PtrVector< T > const &  obj,
ProductID const &  ,
std::vector< void const * > &  pointers,
FillViewHelperVector helpers 
)
inline

Definition at line 197 of file PtrVector.h.

References edm::PtrVector< T >::fillView().

200  {
201  obj.fillView(pointers,helpers);
202  }
template<typename C , typename T , typename F >
void edm::fillView ( RefVector< C, T, F > const &  obj,
ProductID const &  id,
std::vector< void const * > &  pointers,
FillViewHelperVector helpers 
)
inline

Definition at line 210 of file RefVector.h.

213  {
214  obj.fillView(id, pointers, helpers);
215  }
template<typename T >
void edm::fillView ( RefToBaseVector< T > const &  obj,
ProductID const &  ,
std::vector< void const * > &  pointers,
FillViewHelperVector helpers 
)
inline

Definition at line 251 of file RefToBaseVector.h.

References edm::RefToBaseVector< T >::fillView().

254  {
255  obj.fillView(pointers,helpers);
256  }
template<typename KeyRefProd , typename CVal , typename KeyRef , typename SizeType , typename KeyReferenceHelper >
void edm::fillView ( AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > const &  obj,
ProductID const &  id,
std::vector< void const * > &  pointers,
FillViewHelperVector helpers 
)
inline
template<typename T >
void edm::fillView ( std::vector< edm::Ptr< T > > const &  obj,
ProductID const &  id,
std::vector< void const * > &  pointers,
FillViewHelperVector helpers 
)
inline

Definition at line 296 of file Ptr.h.

References GetRecoTauVFromDQM_MC_cff::obj, and AlCaHLTBitMon_ParallelJobs::p.

299  {
300  pointers.reserve(obj.size());
301  helpers.reserve(obj.size());
302  for (auto const& p: obj) {
303  if(p.isAvailable()) {
304  pointers.push_back(p.get());
305  }else {
306  pointers.push_back(nullptr);
307  }
308  helpers.emplace_back(p.id(),p.key());
309  }
310  }
template<class T >
void edm::fillView ( DetSetVector< T > const &  obj,
ProductID const &  id,
std::vector< void const * > &  pointers,
FillViewHelperVector helpers 
)
inline

Definition at line 422 of file DetSetVector.h.

References edm::DetSetVector< T >::fillView().

426  {
427  obj.fillView(id, pointers, helpers);
428  }
template<typename T , unsigned int M, typename P >
void edm::fillView ( OwnArray< T, M, P > const &  obj,
ProductID const &  id,
std::vector< void const * > &  pointers,
FillViewHelperVector helpers 
)
inline

Definition at line 441 of file OwnArray.h.

References edm::OwnArray< T, MAX_SIZE, P >::fillView().

444  {
445  obj.fillView(id, pointers, helpers);
446  }
template<typename T , typename SORT >
void edm::fillView ( SortedCollection< T, SORT > const &  obj,
ProductID const &  id,
std::vector< void const * > &  pointers,
FillViewHelperVector helpers 
)
inline

Definition at line 452 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::fillView().

455  {
456  obj.fillView(id, pointers, helpers);
457  }
template<typename T , typename P >
void edm::fillView ( OwnVector< T, P > const &  obj,
ProductID const &  id,
std::vector< void const * > &  pointers,
FillViewHelperVector helpers 
)
inline

Definition at line 516 of file OwnVector.h.

References edm::OwnVector< T, P >::fillView().

519  {
520  obj.fillView(id, pointers, helpers);
521  }
static void edm::fillWorkerSummary ( Worker const *  pw,
WorkerSummary sum 
)
static

Definition at line 879 of file StreamSchedule.cc.

References fillWorkerSummaryAux().

Referenced by edm::StreamSchedule::getTriggerReport().

879  {
880  fillWorkerSummaryAux(*pw, sum);
881  }
static void fillWorkerSummaryAux(Worker const &w, WorkerSummary &sum)
static void edm::fillWorkerSummaryAux ( Worker const &  w,
WorkerSummary sum 
)
static

Definition at line 869 of file StreamSchedule.cc.

References edm::Worker::description(), edm::ModuleDescription::moduleLabel(), edm::WorkerSummary::moduleLabel, edm::WorkerSummary::timesExcept, edm::Worker::timesExcept(), edm::WorkerSummary::timesFailed, edm::Worker::timesFailed(), edm::WorkerSummary::timesPassed, edm::Worker::timesPassed(), edm::WorkerSummary::timesRun, edm::Worker::timesRun(), edm::WorkerSummary::timesVisited, and edm::Worker::timesVisited().

Referenced by fillWorkerSummary().

869  {
870  sum.timesVisited += w.timesVisited();
871  sum.timesRun += w.timesRun();
872  sum.timesPassed += w.timesPassed();
873  sum.timesFailed += w.timesFailed();
874  sum.timesExcept += w.timesExcept();
875  sum.moduleLabel = w.description().moduleLabel();
876  }
const double w
Definition: UKUtility.cc:23
template<typename ForwardSequence , typename Predicate >
ForwardSequence::const_iterator edm::find_if_in_all ( ForwardSequence const &  s,
Predicate const &  p 
)
inline

wrappers for std::find

Definition at line 54 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p.

54  {
55  return std::find_if(s.begin(), s.end(), p);
56  }
template<typename ForwardSequence , typename Predicate >
ForwardSequence::iterator edm::find_if_in_all ( ForwardSequence &  s,
Predicate const &  p 
)
inline

Definition at line 61 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p.

61  {
62  return std::find_if(s.begin(), s.end(), p);
63  }
template<typename ForwardSequence , typename Datum >
ForwardSequence::const_iterator edm::find_in_all ( ForwardSequence const &  s,
Datum const &  d 
)
inline

wrappers for std::find

Definition at line 32 of file Algorithms.h.

References edmIntegrityCheck::d, and spr::find().

Referenced by edm::RootFile::fillIndexIntoFile(), edm::ProvenanceAdaptor::fixProcessHistory(), edm::ParameterSet::fromString(), and edm::BranchIDListHelper::updateFromInput().

32  {
33  return std::find(s.begin(), s.end(), d);
34  }
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:20
template<typename ForwardSequence , typename Datum >
ForwardSequence::iterator edm::find_in_all ( ForwardSequence &  s,
Datum const &  d 
)
inline

Definition at line 39 of file Algorithms.h.

References edmIntegrityCheck::d, and spr::find().

39  {
40  return std::find(s.begin(), s.end(), d);
41  }
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:20
template<typename Key , typename Value >
Value const& edm::findOrAssert ( std::map< Key, Value > const &  m,
Key const &  k 
)
inline

Definition at line 58 of file Map.h.

58  {
59  typename std::map<Key, Value>::const_iterator it = m.find(k);
60  if (it == m.end()) assert("findOrAssert" && 0);
61  return it->second;
62  }
int k[5][pyjets_maxn]
template<typename Key , typename Value >
Value& edm::findOrAssert ( std::map< Key, Value > &  m,
Key const &  k 
)
inline

Definition at line 67 of file Map.h.

67  {
68  typename std::map<Key, Value>::const_iterator it = m.find(k);
69  if (it == m.end()) assert("findOrAssert" && 0);
70  return it->second;
71  }
int k[5][pyjets_maxn]
template<typename Key , typename Value >
Value const& edm::findOrDefault ( std::map< Key, Value > const &  m,
Key const &  k,
Value const &  defaultValue 
)
inline

Definition at line 28 of file Map.h.

Referenced by edm::JobReport::dumpFiles(), and edm::JobReport::JobReportImpl::writeOutputFile().

28  {
29  typename std::map<Key, Value>::const_iterator it = m.find(k);
30  return (it == m.end() ? defaultValue : it->second);
31  }
int k[5][pyjets_maxn]
template<typename Key , typename Value >
Value& edm::findOrDefault ( std::map< Key, Value > &  m,
Key const &  k,
Value &  defaultValue 
)
inline

Definition at line 36 of file Map.h.

36  {
37  typename std::map<Key, Value>::const_iterator it = m.find(k);
38  return (it == m.end() ? defaultValue : it->second);
39  }
int k[5][pyjets_maxn]
template<typename Key , typename Value >
Value edm::findOrDefault ( std::map< Key, Value > const &  m,
Key const &  k 
)
inline

Definition at line 47 of file Map.h.

47  {
48  typename std::map<Key, Value>::const_iterator it = m.find(k);
49  return (it == m.end() ? Value() : it->second);
50  }
U second(std::pair< T, U > const &p)
reco::JetExtendedAssociation::JetExtendedData Value
int k[5][pyjets_maxn]
template<typename Key , typename Value >
Value& edm::findOrInsert ( std::map< Key, Value > &  m,
Key const &  k 
)
inline

Definition at line 18 of file Map.h.

References gen::k.

18  {
19  return m[k];
20  }
int k[5][pyjets_maxn]
template<typename T , typename U >
T edm::first ( std::pair< T, U > const &  p)
void edm::FlushMessageLog ( )
template<typename ForwardSequence , typename Func >
Func edm::for_all ( ForwardSequence &  s,
Func  f 
)
inline

wrapper for std::for_each

Function templates that provide wrappers for standard algorithms, avoiding some duplication and assuring that incommensurate iterators are not used.

Definition at line 16 of file Algorithms.h.

References f.

Referenced by edm::WorkerManager::beginJob(), edm::EventProcessor::beginJob(), edm::SubProcess::beginJob(), edm::ParameterSwitch< T >::checkAndGetLabelsAndTypes_(), edm::Path::clearCounters(), edm::SubProcess::clearCounters(), edm::StreamSchedule::clearCounters(), edm::SubProcess::closeOutputFiles(), edm::Schedule::closeOutputFiles(), edm::EventProcessor::closeOutputFiles(), edm::SubProcess::deleteRunFromCache(), edm::EventProcessor::deleteRunFromCache(), edm::SubProcess::doBeginStream(), edm::SubProcess::doEndStream(), edm::SubProcess::enableEndPaths(), edm::RootOutputTree::fillTTree(), edm::SubProcess::fixBranchIDListsForEDAliases(), main(), edm::SubProcess::openOutputFiles(), edm::Schedule::openOutputFiles(), edm::EventProcessor::openOutputFiles(), edm::service::StallMonitor::postEndJob(), edm::EDLooperBase::prepareForNextLoop(), edm::ParameterSetDescription::print(), edm::ParameterSwitch< T >::printNestedContent_(), edm::WorkerManager::resetAll(), edm::eventsetup::EventSetupRecordProvider::resetProxies(), edm::eventsetup::EventSetupRecordProvider::resetRecordToProxyPointers(), edm::eventsetup::EventSetupRecordProvider::resetTransients(), edm::SubProcess::respondToCloseInputFile(), edm::Schedule::respondToCloseInputFile(), edm::EventProcessor::respondToCloseInputFile(), edm::SubProcess::respondToOpenInputFile(), edm::Schedule::respondToOpenInputFile(), edm::EventProcessor::respondToOpenInputFile(), edm::eventsetup::EventSetupRecordProvider::setDependentProviders(), edm::SubProcess::updateBranchIDListHelper(), edm::eventsetup::EventSetupRecordProvider::usePreferred(), edm::ConfigurationDescriptions::validate(), edm::ParameterSetDescription::validate(), edm::AllowedLabelsDescriptionBase::validate_(), edm::ParameterWildcard< ParameterSetDescription >::validate_(), edm::ParameterWildcard< std::vector< ParameterSet > >::validate_(), edm::ParameterSetDescription::writeCfi(), edm::ParameterDescription< std::vector< ParameterSet > >::writeCfi_(), edm::ConfigurationDescriptions::writeCfis(), edm::writeParameterValue::writeVector(), and edm::Factory::~Factory().

16  {
17  return std::for_each(s.begin(), s.end(), f);
18  }
double f[11][100]
template<typename S , typename T >
S& edm::formatFile ( T const &  f,
S os 
)

Definition at line 39 of file JobReport.cc.

References MicroEventContent_cff::branch.

Referenced by print().

39  {
40 
41  if(f.fileHasBeenClosed) {
42  os << "\n<State Value=\"closed\"/>";
43  } else {
44  os << "\n<State Value=\"open\"/>";
45  }
46 
47  os << "\n<LFN>" << TiXmlText(f.logicalFileName) << "</LFN>";
48  os << "\n<PFN>" << TiXmlText(f.physicalFileName) << "</PFN>";
49  os << "\n<Catalog>" << TiXmlText(f.catalog) << "</Catalog>";
50  os << "\n<ModuleLabel>" << TiXmlText(f.moduleLabel) << "</ModuleLabel>";
51  os << "\n<GUID>" << f.guid << "</GUID>";
52  os << "\n<Branches>";
53  for(auto const& branch : f.branchNames) {
54  os << "\n <Branch>" << TiXmlText(branch) << "</Branch>";
55  }
56  os << "\n</Branches>";
57  return os;
58  }
double f[11][100]
bool edm::FreshErrorsExist ( unsigned int  iStreamID)

Definition at line 171 of file MessageSender.cc.

References errorSummaryMaps.

Referenced by HLTLogMonitorFilter::filter(), and edm::LogErrorHarvester::produce().

171  {
172  assert(iStreamID<errorSummaryMaps.size());
173  return !errorSummaryMaps[iStreamID].empty();
174  }
static std::vector< tbb::concurrent_unordered_map< ErrorSummaryMapKey, AtomicUnsignedInt, ErrorSummaryMapKey::key_hash > > errorSummaryMaps
template<typename T , typename R = typename eventsetup::data_default_record_trait<typename T::value_type>::type>
T const& edm::get ( EventSetup const &  setup)

Definition at line 175 of file EventSetup.h.

References cmsBatch::handle, dttmaxenums::L, edm::ESHandle< T >::product(), dttmaxenums::R, and GeneralSetup::setup().

175  {
177  // throw if the record is not available
178  setup.get<R>().get(handle);
179  // throw if the handle is not valid
180  return * handle.product();
181  }
def setup(process, global_tag, zero_tesla=False)
Definition: GeneralSetup.py:1
template<typename T , typename R = typename eventsetup::data_default_record_trait<typename T::value_type>::type, typename L >
T const& edm::get ( EventSetup const &  setup,
L &&  label 
)

Definition at line 184 of file EventSetup.h.

References cmsBatch::handle, diffTwoXMLs::label, edm::ESHandle< T >::product(), and dttmaxenums::R.

184  {
186  // throw if the record is not available
187  setup.get<R>().get(std::forward(label), handle);
188  // throw if the handle is not valid
189  return * handle.product();
190  }
def setup(process, global_tag, zero_tesla=False)
Definition: GeneralSetup.py:1
template<typename T >
T const& edm::get ( LuminosityBlock const &  event,
InputTag const &  tag 
)

Definition at line 372 of file LuminosityBlock.h.

References cmsBatch::handle, edm::Handle< T >::product(), and GlobalPosition_Frontier_DevDB_cff::tag.

372  {
374  event.getByLabel(tag, handle);
375  // throw if the handle is not valid
376  return * handle.product();
377  }
template<typename T >
T const& edm::get ( LuminosityBlock const &  event,
EDGetToken const &  token 
)

Definition at line 380 of file LuminosityBlock.h.

References cmsBatch::handle, and edm::Handle< T >::product().

380  {
382  event.getByToken(token, handle);
383  // throw if the handle is not valid
384  return * handle.product();
385  }
template<typename T >
T const& edm::get ( Run const &  event,
InputTag const &  tag 
)

Definition at line 383 of file Run.h.

References cmsBatch::handle, edm::Handle< T >::product(), and GlobalPosition_Frontier_DevDB_cff::tag.

383  {
385  event.getByLabel(tag, handle);
386  // throw if the handle is not valid
387  return * handle.product();
388  }
template<typename T >
T const& edm::get ( LuminosityBlock const &  event,
EDGetTokenT< T > const &  token 
)

Definition at line 388 of file LuminosityBlock.h.

References cmsBatch::handle, and edm::Handle< T >::product().

388  {
390  event.getByToken(token, handle);
391  // throw if the handle is not valid
392  return * handle.product();
393  }
template<typename T >
T const& edm::get ( Run const &  event,
EDGetToken const &  token 
)

Definition at line 391 of file Run.h.

References cmsBatch::handle, and edm::Handle< T >::product().

391  {
393  event.getByToken(token, handle);
394  // throw if the handle is not valid
395  return * handle.product();
396  }
template<typename T >
T const& edm::get ( Run const &  event,
EDGetTokenT< T > const &  token 
)

Definition at line 399 of file Run.h.

References cmsBatch::handle, and edm::Handle< T >::product().

399  {
401  event.getByToken(token, handle);
402  // throw if the handle is not valid
403  return * handle.product();
404  }
template<typename T >
T const& edm::get ( Event const &  event,
InputTag const &  tag 
)

Definition at line 690 of file Event.h.

References cmsBatch::handle, edm::Handle< T >::product(), and GlobalPosition_Frontier_DevDB_cff::tag.

Referenced by TriggerBxMonitor::dqmAnalyze(), TriggerRatesMonitor::dqmAnalyze(), and triggerExpression::Data::setEvent().

690  {
692  event.getByLabel(tag, handle);
693  // throw if the handle is not valid
694  return * handle.product();
695  }
template<typename T >
T const& edm::get ( Event const &  event,
EDGetToken const &  token 
)

Definition at line 698 of file Event.h.

References cmsBatch::handle, and edm::Handle< T >::product().

698  {
700  event.getByToken(token, handle);
701  // throw if the handle is not valid
702  return * handle.product();
703  }
template<typename T >
T const& edm::get ( Event const &  event,
EDGetTokenT< T > const &  token 
)

Definition at line 706 of file Event.h.

References cmsBatch::handle, and edm::Handle< T >::product().

706  {
708  event.getByToken(token, handle);
709  // throw if the handle is not valid
710  return * handle.product();
711  }
template<typename T >
T & edm::get_underlying ( propagate_const< T > &  iP)
template<typename T >
T const & edm::get_underlying ( propagate_const< T > const &  iP)

Definition at line 88 of file propagate_const.h.

References edm::propagate_const< T >::m_value.

88 {return iP.m_value;}
template<typename T >
std::shared_ptr<T>& edm::get_underlying_safe ( propagate_const< std::shared_ptr< T >> &  iP)

Definition at line 39 of file get_underlying_safe.h.

References get_underlying().

Referenced by edm::eventsetup::EventSetupRecordProvider::addProxiesToRecordHelper(), edm::RootFile::branchChildren(), edm::ScheduleItems::branchIDListHelper(), edm::root::TFWLiteSelectorMembers::branchIDListHelper(), edm::InputSource::branchIDListHelper(), edm::RootFile::branchIDListHelper(), edm::SubProcess::branchIDListHelper(), edm::EventProcessor::branchIDListHelper(), SerializeDataBuffer::bufferPointer(), edm::LuminosityBlock::commit_(), edm::Run::commit_(), edm::Event::commit_aux(), XrdAdaptor::XrdStatisticsService::condorUpdate(), edm::RootPrimaryFileSequence::duplicateChecker(), edm::service::RandomNumberGeneratorService::LabelAndEngine::engine(), edm::ProductRegistry::Transients::eventProductLookup(), edm::RootFile::eventProductProvenanceRetriever(), edm::StreamerFileReader::eventSkipperByID(), edm::RootPrimaryFileSequence::eventSkipperByID(), XrdAdaptor::Source::fh(), edm::RootOutputFile::filePtr(), edm::eventsetup::EventSetupRecordProvider::finder(), XrdAdaptor::ClientRequest::getCurrentSource(), edm::ModuleRegistry::getModule(), edm::ProcessDesc::getProcessPSet(), XrdAdaptor::XrdSiteStatisticsInformation::getStatisticsForSite(), edm::RootFile::indexIntoFileSharedPtr(), HepMCFileReader::input(), edm::service::RandomNumberGeneratorService::ModuleIDToEngine::labelAndEngine(), edm::EventProcessor::looper(), edm::ProductRegistry::Transients::lumiProductLookup(), edm::Schedule::moduleRegistry(), edm::value_ptr< edm::service::MessageLoggerDefaults >::operator->(), edm::JobReport::JobReportImpl::ost(), edm::RootOutputFile::pEventEntryInfoVector(), edm::ScheduleItems::preg(), edm::EventProcessor::preg(), edm::ScheduleItems::processConfiguration(), edm::VectorInputSource::productRegistry(), edm::InputSource::productRegistry(), edm::EventPrincipal::provRetrieverPtr(), edm::eventsetup::EventSetupRecordProvider::proxyProvider(), edm::service::MessageServicePresence::queue(), edm::RandomEngineSentry< T >::randomEngine(), edm::Principal::recombine(), edm::root::TFWLiteSelectorMembers::reg(), StorageAccountProxy::releaseStorage(), TStorageFactoryFile::releaseStorage(), edm::StreamSchedule::results(), edm::Schedule::resultsInserter(), edm::RootInputFileSequence::rootFile(), edm::ProductRegistry::Transients::runProductLookup(), edm::RootFile::savedRunAuxiliary(), XrdAdaptor::ClientRequest::self_reference(), edm::service::SimpleMemoryCheck::smapsLineBuffer(), XrdAdaptor::Source::stats(), edm::ScheduleItems::subProcessParentageHelper(), edm::root::TFWLiteSelectorMembers::TFWLiteSelectorMembers(), edm::ScheduleItems::thinnedAssociationsHelper(), edm::root::TFWLiteSelectorMembers::thinnedAssociationsHelper(), edm::InputSource::thinnedAssociationsHelper(), edm::SubProcess::thinnedAssociationsHelper(), edm::EventProcessor::thinnedAssociationsHelper(), and edm::root::TFWLiteSelectorMembers::tree().

39 {return get_underlying(iP);}
T & get_underlying(propagate_const< T > &)
template<typename T >
std::shared_ptr<T const> edm::get_underlying_safe ( propagate_const< std::shared_ptr< T >> const &  iP)

Definition at line 40 of file get_underlying_safe.h.

References popcon2dropbox::copy(), and get_underlying().

40 {std::shared_ptr<T const> copy = get_underlying(iP); return copy;}
def copy(args, dbName)
T & get_underlying(propagate_const< T > &)
template<typename T >
T*& edm::get_underlying_safe ( propagate_const< T * > &  iP)

Definition at line 43 of file get_underlying_safe.h.

References get_underlying().

43 {return get_underlying(iP);}
T & get_underlying(propagate_const< T > &)
template<typename T >
T const* edm::get_underlying_safe ( propagate_const< T * > const &  iP)

Definition at line 44 of file get_underlying_safe.h.

References popcon2dropbox::copy(), and get_underlying().

44 {T const* copy = get_underlying(iP); return copy;}
def copy(args, dbName)
T & get_underlying(propagate_const< T > &)
long double T
template<typename T >
std::unique_ptr<T>& edm::get_underlying_safe ( propagate_const< std::unique_ptr< T >> &  iP)

Definition at line 47 of file get_underlying_safe.h.

References get_underlying().

47 {return get_underlying(iP);}
T & get_underlying(propagate_const< T > &)
template<typename T >
std::unique_ptr<T const> edm::get_underlying_safe ( propagate_const< std::unique_ptr< T >> const &  iP)

Definition at line 49 of file get_underlying_safe.h.

References popcon2dropbox::copy(), and get_underlying().

49 {std::unique_ptr<T const> copy = get_underlying(iP); return copy;}
def copy(args, dbName)
T & get_underlying(propagate_const< T > &)
std::vector< std::string > const & edm::getAllTriggerNames ( )
template<typename T >
std::unique_ptr<T> edm::getAnyPtr ( void *  p,
int  offset 
)
inline

Definition at line 10 of file getAnyPtr.h.

References eostools::move(), PFRecoTauDiscriminationByIsolation_cfi::offset, and AlCaHLTBitMon_ParallelJobs::p.

10  {
11  // A union is used to avoid possible copies during the triple cast that would otherwise be needed.
12  // std::unique_ptr<T> edp(static_cast<T*>(static_cast<void *>(static_cast<unsigned char *>(p) + offset)));
13  union {
14  void* vp;
15  unsigned char* ucp;
16  T* tp;
17  } pointerUnion;
18  assert(p != nullptr);
19  pointerUnion.vp = p;
20  pointerUnion.ucp += offset;
21  std::unique_ptr<T> tp(pointerUnion.tp);
22  return(std::move(tp));
23  }
long double T
def move(src, dest)
Definition: eostools.py:510
std::string edm::getEnvironmentVariable ( std::string const &  name,
std::string const &  defaultValue = std::string() 
)
inline
int edm::getFileFormatVersion ( )

Definition at line 4 of file GetFileFormatVersion.cc.

Referenced by edm::RootOutputFile::writeFileFormatVersion().

4 { return 20; }
template<class T , std::size_t N>
std::array<T, N> edm::getFixedSizeArray ( ParameterSet const &  pset,
std::string const &  name 
)

Definition at line 17 of file getFixedSizeArray.h.

References a, edm::errors::Configuration, Exception, edm::ParameterSet::getParameter(), N, and dataset::name.

17  {
18  std::vector<T> vec = pset.getParameter<std::vector<T>>(name);
19  if (vec.size() != N) {
21  << "The parameter '" << name
22  << "' should have " << N << " elements, but has " << vec.size()
23  << " elements in the configuration.\n";
24  }
25  std::array<T, N> a {};
26  std::copy_n(vec.begin(), N, a.begin());
27  return a;
28  }
#define N
Definition: blowfish.cc:9
double a
Definition: hdecay.h:121
MallocOptionSetter & edm::getGlobalOptionSetter ( )

Definition at line 221 of file MallocOpts.cc.

References global_malloc_options.

Referenced by edm::service::SimpleMemoryCheck::SimpleMemoryCheck().

222  {
223  return global_malloc_options;
224  }
MallocOptionSetter global_malloc_options
Definition: MallocOpts.cc:219
ParameterSet const & edm::getParameterSet ( ParameterSetID const &  id)
std::string edm::getPassID ( )
inline

Definition at line 8 of file GetPassID.h.

References AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::DaqProvenanceHelper::daqInit(), edm::ScheduleItems::initMisc(), and edm::LHEProvenanceHelper::lheInit().

8  {
9  static std::string const passID;
10  // return empty string for now.
11  return passID;
12  }
ParameterSet const & edm::getProcessParameterSetContainingModule ( ModuleDescription const &  moduleDescription)
ParameterSet const * edm::getProducerParameterSet ( Provenance const &  provenance)

Definition at line 17 of file getProducerParameterSet.cc.

References edm::Provenance::constBranchDescriptionPtr(), Exception, edm::pset::Registry::getMapped(), edm::ParameterSet::getParameterSet(), edm::pset::Registry::instance(), diffTwoXMLs::label, LaserDQM_cfg::process, edm::Provenance::processHistoryPtr(), and AlCaHLTBitMon_QueryRunRegistry::string.

17  {
18 
19  const std::shared_ptr<BranchDescription const>& branchDescription =
20  provenance.constBranchDescriptionPtr();
21 
22  if (branchDescription) {
23  std::string const& process = branchDescription->processName();
24  std::string const& label = branchDescription->moduleLabel();
25  ProcessHistory const* processHistory = provenance.processHistoryPtr();
26 
27  if (processHistory) {
28  for (ProcessConfiguration const& pc : *processHistory) {
29  if (pc.processName() == process) {
30  ParameterSetID const& psetID = pc.parameterSetID();
31  pset::Registry const* psetRegistry = pset::Registry::instance();
32  ParameterSet const* processPset = psetRegistry->getMapped(psetID);
33  if (processPset) {
34  return &processPset->getParameterSet(label);
35  }
36  }
37  }
38  }
39  }
40  // This should never happen
41  throw cms::Exception("LogicError")
42  << "getProducerParameterSet failed";
43  return nullptr;
44  }
static PFTauRenderPlugin instance
Hash< ParameterSetType > ParameterSetID
template<typename T >
T const* edm::getProduct ( RefCore const &  ref)
inline

Definition at line 41 of file RefCoreGet.h.

References edm::RefCore::isTransient(), edm::RefCore::nullPointerForTransientException(), AlCaHLTBitMon_ParallelJobs::p, edm::refcoreimpl::productGetter(), edm::RefCore::productGetter(), and edm::RefCore::productPtr().

41  {
42  T const* p = static_cast<T const*>(ref.productPtr());
43  if (p != nullptr) return p;
44  if (ref.isTransient()) {
45  ref.nullPointerForTransientException(typeid(T));
46  }
47  auto productGetter = ref.productGetter();
48  if(nullptr == productGetter) {
49  p =static_cast<T const*>(ref.productPtr());
50  if(p != nullptr) {
51  //another thread updated the value since we checked
52  return p;
53  }
54  }
55  return refcore::getProduct_<T>(ref, productGetter);
56  }
EDProductGetter const * productGetter(std::atomic< void const * > const &iCache)
long double T
template<typename PROD >
std::shared_ptr<Wrapper<PROD> const> edm::getProductByTag ( Principal const &  ep,
InputTag const &  tag,
ModuleCallingContext const *  mcc 
)
inline

Definition at line 290 of file Principal.h.

References edm::WrapperBase::dynamicTypeInfo(), edm::Principal::findProductByTag(), PROD, mps_fire::result, edm::ProductData::sharedConstWrapper(), edm::handleimpl::throwConvertTypeError(), and edm::ProductData::wrapper().

290  {
291  TypeID tid = TypeID(typeid(PROD));
292  ProductData const* result = ep.findProductByTag(tid, tag, mcc);
293  if(result == nullptr) {
294  return std::shared_ptr<Wrapper<PROD> const>();
295  }
296 
297  if(!(result->wrapper()->dynamicTypeInfo() == typeid(PROD))) {
298  handleimpl::throwConvertTypeError(typeid(PROD), result->wrapper()->dynamicTypeInfo());
299  }
300  return std::static_pointer_cast<Wrapper<PROD> const>(result->sharedConstWrapper());
301  }
void throwConvertTypeError(std::type_info const &expected, std::type_info const &actual)
#define PROD(A, B)
template<typename T >
T const* edm::getProductWithCoreFromRef ( RefCore const &  ref,
EDProductGetter const *  prodGetter 
)
inline

Definition at line 78 of file RefCoreGet.h.

References edm::RefCore::isTransient(), and edm::RefCore::nullPointerForTransientException().

78  {
79  if (ref.isTransient()) {
80  ref.nullPointerForTransientException(typeid(T));
81  }
82  return refcore::getProductWithCoreFromRef_<T>(ref, prodGetter);
83  }
long double T
template<typename C >
helper::MatcherGetRef<C>::ref_type edm::getRef ( const Handle< C > &  c,
size_t  k 
)
template<typename C , typename T , typename F , typename KEY >
T const* edm::getRefPtr ( RefCore const &  product,
KEY const &  iKey 
)
inline

Definition at line 86 of file RefItemGet.h.

References edm::refitem::GetRefPtrImpl< C, T, F, KEY >::getRefPtr_().

86  {
87  return refitem::GetRefPtrImpl<C, T, F, KEY>::getRefPtr_(product, iKey);
88  }
std::string edm::getReleaseVersion ( )
TClass* edm::getTClass ( const std::type_info &  ti)
TClass* edm::getTClass ( std::type_info const &  ti)

Definition at line 66 of file ClassFiller.cc.

References edm::TypeID::className().

66  {
67  TypeID const type(ti);
68  return getRootClass(type.className());
69  }
type
Definition: HCALResponse.h:21
template<typename T >
T const* edm::getThinnedProduct ( RefCore const &  ref,
unsigned int &  thinnedKey,
EDProductGetter const *  prodGetter 
)
inline

Definition at line 129 of file RefCoreGet.h.

References edm::RefCore::isTransient(), and edm::RefCore::nullPointerForTransientException().

Referenced by edm::Principal::applyToResolvers(), fwlite::ChainEvent::event(), fwlite::Event::getTFile(), and fwlite::MultiChainEvent::secondary().

129  {
130  // The pointer to a thinned collection will never be cached
131  // T const* p = static_cast<T const*>(ref.productPtr());
132  // if (p != 0) return p;
133 
134  if (ref.isTransient()) {
135  ref.nullPointerForTransientException(typeid(T));
136  }
137  return refcore::getThinnedProduct_<T>(ref, thinnedKey, prodGetter);
138  }
long double T
std::string edm::getUuid ( TTree *  uuidTree)

Definition at line 98 of file CollUtil.cc.

References edm::FileID::fid(), and edm::poolNames::fileIdentifierBranchName().

98  {
99  FileID fid;
100  FileID *fidPtr = &fid;
101  uuidTree->SetBranchAddress(poolNames::fileIdentifierBranchName().c_str(), &fidPtr);
102  uuidTree->GetEntry(0);
103  return fid.fid();
104  }
std::string const & fileIdentifierBranchName()
Definition: BranchType.cc:223
std::unique_ptr<WrapperBase> edm::getWrapperBasePtr ( void *  p,
int  offset 
)
inline
std::string edm::glob2reg ( std::string const &  pattern)
void edm::GroupLogStatistics ( std::string const &  category)

Definition at line 112 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqGRP(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::Suppress_LogDebug_::log().

112  {
113  std::string * cat_p = new std::string(category);
114  edm::MessageLoggerQ::MLqGRP (cat_p); // Indicate a group summary category
115  // Note that the scribe will be responsible for deleting cat_p
116 }
static void MLqGRP(std::string *cat_p)
void edm::HaltMessageLogging ( )

Definition at line 90 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqSHT().

Referenced by edm::Suppress_LogDebug_::log().

90  {
91  edm::MessageLoggerQ::MLqSHT ( ); // Shut the logger up
92 }
static void MLqSHT()
bool edm::hasDictionary ( std::type_info const &  ti)

Definition at line 923 of file TypeWithDict.cc.

Referenced by checkClassDictionaries(), pat::UserData::checkDictionaries(), checkDictionary(), fwlite::Record::get(), edm::service::InitRootHandlers::InitRootHandlers(), and edm::TypeWithDict::unvalidatedTypeInfo().

923  {
924  if (ti.name()[1] == '\0') {
925  // returns true for built in types (single character mangled names)
926  return true;
927  }
928  return (TClassTable::GetDict(ti) != nullptr);
929  }
HRTimeType edm::hrRealTime ( )
inline

Definition at line 101 of file HRRealTime.h.

101  {
102  return details::rdtsc();
103  }
void edm::installCustomHandler ( int  signum,
CFUNC  func 
)

Definition at line 97 of file UnixSignalHandlers.cc.

References disableAllSigs(), disableRTSigs(), installSig(), and reenableSigs().

Referenced by edm::service::InitRootHandlers::InitRootHandlers(), and edm::service::UnixSignalService::UnixSignalService().

98  {
99  sigset_t oldset;
100  edm::disableAllSigs(&oldset);
101 #if defined(__linux__)
103 #endif
104  edm::installSig(signum,func);
105  edm::reenableSigs(&oldset);
106  }
void installSig(int signum, CFUNC func)
void disableAllSigs(sigset_t *oldset)
void reenableSigs(sigset_t *oldset)
void disableRTSigs()
void edm::installSig ( int  signum,
CFUNC  func 
)

Definition at line 110 of file UnixSignalHandlers.cc.

References patCandidates_cff::func, and MUST_BE_ZERO.

Referenced by installCustomHandler().

111  {
112  // set up my RT signal now
113  struct sigaction act;
114  memset(&act,0,sizeof(act));
115  act.sa_sigaction = func;
116  act.sa_flags = SA_RESTART;
117 
118  // get my signal number
119  int mysig = signum;
120  if( mysig == SIGKILL ) {
121  perror("Cannot install handler for KILL signal");
122  return;
123  } else if( mysig == SIGSTOP ) {
124  perror("Cannot install handler for STOP signal");
125  return;
126  }
127 
128  if(sigaction(mysig,&act,nullptr) != 0) {
129  perror("sigaction failed");
130  abort();
131  }
132 
133  sigset_t newset;
134  MUST_BE_ZERO(sigemptyset(&newset));
135  MUST_BE_ZERO(sigaddset(&newset,mysig));
136  MUST_BE_ZERO(pthread_sigmask(SIG_UNBLOCK,&newset,nullptr));
137  }
#define MUST_BE_ZERO(fun)
bool edm::is_glob ( std::string const &  pattern)
bool edm::isAncestor ( ProcessHistory const &  a,
ProcessHistory const &  b 
)

Definition at line 61 of file ProcessHistory.cc.

References edm::ProcessHistory::data(), and edm::ProcessHistory::size().

Referenced by isDescendant(), and operator!=().

61  {
62  if (a.size() >= b.size()) return false;
63  typedef ProcessHistory::collection_type::const_iterator const_iterator;
64  for (const_iterator itA = a.data().begin(), itB = b.data().begin(),
65  itAEnd = a.data().end(); itA != itAEnd; ++itA, ++itB) {
66  if (*itA != *itB) return false;
67  }
68  return true;
69  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::isDebugEnabled ( )

Definition at line 71 of file MessageLogger.cc.

References edm::MessageDrop::debugAlwaysSuppressed, and edm::MessageDrop::instance().

Referenced by SiStripQualityHotStripIdentifier::algoAnalyze(), FedChannelConnection::apvPairNumber(), L1GtTriggerMenuLiteProducer::beginRunProduce(), CommissioningHistosUsingDb::buildDetInfo(), JetPlusTrackCorrector::calculateCorr(), SiStripEventSummary::commissioningInfo(), sistrip::RawToDigiUnpacker::createDigis(), sistrip::SpyUnpacker::createDigis(), sistrip::DigiToRaw::createFedBuffers_(), sistrip::DigiToRaw::DigiToRaw(), sistrip::DigiToRawModule::DigiToRawModule(), SiStripBadAPVAlgorithmFromClusterOccupancy::extractBadAPVs(), SiStripBadAPVandHotStripAlgorithmFromClusterOccupancy::extractBadAPVSandStrips(), SiStripHotStripAlgorithmFromClusterOccupancy::extractBadStrips(), sistrip::SpyUtilities::extractFrameInfo(), BSCTrigger::getBSCNum(), sistrip::RawToDigiUnpacker::handleException(), HLTMuonTrackMassFilter::hltFilter(), HLTMuonL1RegionalFilter::hltFilter(), HLTMuonL1TFilter::hltFilter(), HLTMuonL1TRegionalFilter::hltFilter(), HLTMuonL2FromL1TPreFilter::hltFilter(), HLTMuonL2PreFilter::hltFilter(), HLTMuonL1Filter::hltFilter(), HLTMuonL1Filter::HLTMuonL1Filter(), HLTMuonL1RegionalFilter::HLTMuonL1RegionalFilter(), HLTMuonL1TFilter::HLTMuonL1TFilter(), HLTMuonL1TRegionalFilter::HLTMuonL1TRegionalFilter(), HLTMuonL2FromL1TPreFilter::HLTMuonL2FromL1TPreFilter(), HLTMuonL2PreFilter::HLTMuonL2PreFilter(), FedChannelConnection::i2cAddr(), SiStripFedZeroSuppression::isAValidDigi(), SiStripBadAPVandHotStripAlgorithmFromClusterOccupancy::iterativeSearch(), SiStripHotStripAlgorithmFromClusterOccupancy::iterativeSearch(), JetPlusTrackCorrector::jtaUsingEventData(), L1GtRsObjectKeysOnlineProd::keyL1GtPrescaleFactorsAlgoTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtPrescaleFactorsTechTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtTriggerMaskAlgoTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtTriggerMaskTechTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtTriggerMaskVetoTechTrig(), L1GetHistLimits::l1HistLimits(), FedChannelConnection::lldChannel(), sistrip::RawToDigiUnpacker::locateStartOfFedBuffer(), edm::Suppress_LogDebug_::log(), jpt::Map::Map(), JetPlusTrackCorrector::matchTracks(), L1GtParametersConfigOnlineProd::newObject(), L1GtPrescaleFactorsAlgoTrigConfigOnlineProd::newObject(), L1GtTriggerMaskAlgoTrigConfigOnlineProd::newObject(), L1GtTriggerMaskTechTrigConfigOnlineProd::newObject(), L1GtTriggerMaskVetoTechTrigConfigOnlineProd::newObject(), L1GtPrescaleFactorsTechTrigConfigOnlineProd::newObject(), L1GtPsbSetupConfigOnlineProd::newObject(), L1GtTriggerMenuConfigOnlineProd::newObject(), l1t::TriggerMenuParser::parseAlgorithm(), l1t::TriggerMenuParser::parseCalo(), L1GtTriggerMenuXmlParser::parseCalo(), l1t::TriggerMenuParser::parseCaloCorr(), L1GtTriggerMenuXmlParser::parseCastor(), l1t::TriggerMenuParser::parseCorrelation(), L1GtTriggerMenuXmlParser::parseCorrelation(), l1t::TriggerMenuParser::parseCorrelationWithOverlapRemoval(), l1t::TriggerMenuParser::parseEnergySum(), L1GtTriggerMenuXmlParser::parseEnergySum(), l1t::TriggerMenuParser::parseEnergySumCorr(), L1GtTriggerMenuXmlParser::parseHfBitCounts(), L1GtTriggerMenuXmlParser::parseHfRingEtSums(), L1GtTriggerMenuXmlParser::parseJetCounts(), l1t::TriggerMenuParser::parseMuon(), L1GtTriggerMenuXmlParser::parseMuon(), l1t::TriggerMenuParser::parseMuonCorr(), jpt::Efficiency::print(), QuarkoniaTrackSelector::produce(), sistrip::DigiToRawModule::produce(), L1GlobalTriggerRecordProducer::produce(), BSCTrigger::produce(), TriggerSummaryProducerAOD::produce(), sistrip::RawToDigiModule::RawToDigiModule(), sistrip::RawToDigiUnpacker::RawToDigiUnpacker(), SiStripClusterizerFromRaw::run(), SiStripHotStripAlgorithmFromClusterOccupancy::setNumberOfEvents(), sistrip::SpyDigiConverterModule::SpyDigiConverterModule(), sistrip::SpyUnpacker::SpyUnpacker(), sistrip::SpyUnpackerModule::SpyUnpackerModule(), SiStripFedZeroSuppression::suppress(), sistrip::RawToDigiUnpacker::triggerFed(), L1GtfeExtWord::unpack(), L1GtfeWord::unpack(), L1TcsWord::unpack(), L1GtFdlWord::unpack(), L1GlobalTriggerEvmRawToDigi::unpackHeader(), PedestalsHistosUsingDb::update(), ApvTimingHistosUsingDb::update(), DaqScopeModeHistosUsingDb::update(), PedsFullNoiseHistosUsingDb::update(), sistrip::RawToDigiModule::updateCabling(), sistrip::RawToDigiUnpacker::updateEventSummary(), L1GtTriggerMenuXmlParser::workAlgorithm(), L1GtTriggerMenuXmlParser::workTechTrigger(), L1GtPatternWriter::writePatterns(), sistrip::DigiToRaw::~DigiToRaw(), sistrip::DigiToRawModule::~DigiToRawModule(), sistrip::RawToDigiModule::~RawToDigiModule(), sistrip::RawToDigiUnpacker::~RawToDigiUnpacker(), sistrip::SpyDigiConverterModule::~SpyDigiConverterModule(), sistrip::SpyUnpacker::~SpyUnpacker(), and sistrip::SpyUnpackerModule::~SpyUnpackerModule().

71  {
72  return ((!edm::MessageDrop::debugAlwaysSuppressed) // 9/27/10 mf
73  && edm::MessageDrop::instance()->debugEnabled );
74 }
static MessageDrop * instance()
Definition: MessageDrop.cc:60
static bool debugAlwaysSuppressed
Definition: MessageDrop.h:112
bool edm::isDescendant ( ProcessHistory const &  a,
ProcessHistory const &  b 
)
inline

Definition at line 117 of file ProcessHistory.h.

References isAncestor(), and operator<<().

117  {
118  return isAncestor(b, a);
119  }
bool isAncestor(ProcessHistory const &a, ProcessHistory const &b)
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
constexpr bool edm::isEndTransition ( Transition  iValue)

Definition at line 31 of file Transition.h.

References EndLuminosityBlock, EndRun, and or.

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::LuminosityBlock::commit_(), and edm::Run::commit_().

31  {
32  return iValue==Transition::EndLuminosityBlock or iValue==Transition::EndRun;
33  }
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
bool edm::isErrorEnabled ( )

Definition at line 86 of file MessageLogger.cc.

References edm::MessageDrop::errorEnabled, and edm::MessageDrop::instance().

86  {
87  return edm::MessageDrop::instance()->errorEnabled; // 7/6/11 fwyzard
88 }
static MessageDrop * instance()
Definition: MessageDrop.cc:60
template<typename T >
bool edm::isFinite ( T  x)
template<>
bool edm::isFinite ( float  x)
inline

Definition at line 16 of file isFinite.h.

References edmIntegrityCheck::d, checklumidiff::l, RecoTauDiscriminantConfiguration::mask, and findQualityFiles::v.

16  {
17  const unsigned int mask = 0x7f800000;
18  union { unsigned int l; float d;} v;
19  v.d =x;
20  return (v.l&mask)!=mask;
21  }
template<>
bool edm::isFinite ( double  x)
inline

Definition at line 25 of file isFinite.h.

References edmIntegrityCheck::d, checklumidiff::l, RecoTauDiscriminantConfiguration::mask, and findQualityFiles::v.

25  {
26  const unsigned long long mask = 0x7FF0000000000000LL;
27  union { unsigned long long l; double d;} v;
28  v.d =x;
29  return (v.l&mask)!=mask;
30  }
template<>
bool edm::isFinite ( long double  x)
inline

Definition at line 34 of file isFinite.h.

References isFinite(), and geometryCSVtoXML::xx.

34  {
35  double xx=x;
36  return isFinite(xx);
37  }
bool isFinite(long double x)
Definition: isFinite.h:34
bool edm::isInfoEnabled ( )

Definition at line 76 of file MessageLogger.cc.

References edm::MessageDrop::infoAlwaysSuppressed, and edm::MessageDrop::instance().

Referenced by edm::InputSource::issueReports(), and edm::Suppress_LogDebug_::log().

76  {
77  return ((!edm::MessageDrop::infoAlwaysSuppressed) // 9/27/10 mf
78  && edm::MessageDrop::instance()->infoEnabled );
79 }
static MessageDrop * instance()
Definition: MessageDrop.cc:60
static bool infoAlwaysSuppressed
Definition: MessageDrop.h:113
bool edm::isMessageProcessingSetUp ( )

Definition at line 104 of file MessageLogger.cc.

References edm::MessageDrop::instance(), and MLSCRIBE_RUNNING_INDICATOR.

Referenced by edm::Suppress_LogDebug_::log().

104  { // 6/20/08 mf
105 // std::cerr << "isMessageProcessingSetUp: \n";
106 // std::cerr << "messageLoggerScribeIsRunning = "
107 // << (int)MessageDrop::instance()->messageLoggerScribeIsRunning << "\n";
108  return (MessageDrop::instance()->messageLoggerScribeIsRunning ==
110 }
static PFTauRenderPlugin instance
static const unsigned char MLSCRIBE_RUNNING_INDICATOR
Definition: MessageDrop.h:122
bool edm::isnan ( float  f)
inline

Definition at line 69 of file math.h.

References edm::detail::isnan().

69 { return detail::isnan(f); }
bool isnan(long double q)
Definition: math.h:73
double f[11][100]
bool edm::isnan ( double  d)
inline

Definition at line 71 of file math.h.

References equal_isnan().

71 { return equal_isnan(d); }
bool equal_isnan(FP x)
Definition: math.h:61
bool edm::isnan ( long double  q)
inline

Definition at line 73 of file math.h.

References edm::detail::isnan().

73 { return detail::isnan(q); }
bool isnan(long double q)
Definition: math.h:73
template<typename T >
bool edm::isNotFinite ( T  x)
inline

Definition at line 10 of file isFinite.h.

References isFinite().

Referenced by EBHitResponse::add(), HcalSiPMHitResponse::add(), CaloHitResponse::add(), EcalHitResponse::add(), EcalTimeMapDigitizer::add(), ElectronCalibration::analyze(), Vx3DHLTAnalyzer::analyze(), ElectronCalibrationUniv::analyze(), JetTagPlotter::analyzeTag(), TrackDetectorAssociator::associate(), EGammaMvaEleEstimatorCSA14::bindVariables(), EGammaMvaEleEstimator::bindVariables(), TransientTrackBuilder::build(), DetIdAssociator::buildMap(), BoostedDoubleSVProducer::calcNsubjettiness(), TwoTrackMinimumDistanceHelixHelix::calculate(), GsfVertexWeightCalculator::calculate(), Cluster3DPCACalculator::calculateAndSetPositionActual(), Basic2DGenericPFlowPositionCalc::calculateAndSetPositionActual(), GsfElectronAlgo::calculateShowerShape(), GsfElectronFull5x5Filler::calculateShowerShape_full5x5(), GsfElectronAlgo::calculateShowerShape_full5x5(), PhotonEnergyCalibrator::calibrate(), ElectronEnergyCalibrator::calibrate(), PrimaryVertexAssignment::chargedHadronVertex(), DeepTauId::checkInputs(), TwoBodyDecayEstimator::checkValues(), Qjets::d_ij(), HLTScalersClient::endLuminosityBlock(), FitterFuncs::PulseShapeFunctor::EvalPulse(), MagGeometry::fieldInTesla(), EcalRegressionData::fill(), DAClusterizerInZ_vect::fill(), DAClusterizerInZT_vect::fill(), AlignmentExtendedCorrelationsStore::fillCovariance(), AlignmentExtendedCorrelationsStore::fillCovarianceT(), MatrixFillMap::fillEBMap(), MatrixFillMap::fillEEMap(), ClusterFillMap::fillMap(), ElectronSeedProducer::filterClusters(), DivisiveVertexFinder::findVertexes(), DivisiveVertexFinder::findVertexesAlt(), BSFitter::Fit(), KFTrajectoryFitter::fitOne(), FitterFuncs::PulseShapeFunctor::funcShape(), SCEnergyCorrectorSemiParm::getCorrections(), SequentialVertexFitter< 5 >::hasNan(), ConversionFastHelix::helixStateAtVertex(), CAHitTripletGenerator::hitNtuplets(), CAHitQuadrupletGenerator::hitNtuplets(), MultiHitGeneratorFromChi2::hitSets(), cms::SubEventGenJetProducer::inputTowers(), VirtualJetProducer::inputTowers(), PhotonConversionTrajectorySeedProducerFromSingleLegAlgo::inspectTrack(), GlobalTrackQualityProducer::kink(), fftjetcms::FFTJetInterface::loadInputCollection(), OptOCOPS::makeMeasurement(), Vx3DHLTAnalyzer::MyFit(), SensitiveDetector::NaNTrap(), reco::InverseCrosstalkMatrix::operator()(), TtHadLRSignalSelObservables::operator()(), TtSemiLRSignalSelObservables::operator()(), EcalUncalibRecHitFixedAlphaBetaAlgo< C >::PerformAnalyticFit(), pat::PATPhotonSlimmer::produce(), ShiftedParticleProducer::produce(), ShiftedParticleProducerT< T >::produce(), PhotonIDValueMapProducer::produce(), cms::CkfTrackCandidateMakerBase::produceBase(), IMACalibBlock::riempiMtr(), IMACalibBlock::riempiVtr(), EBHitResponse::run(), EcalHitResponse::run(), PVFitter::runFitter(), PrimaryVertexSorting::score(), SimpleCosmicBONSeeder::seeds(), HelixArbitraryPlaneCrossing2Order::solutionByDirection(), ConversionFastHelix::straightLineStateAtVertex(), TrackWithVertexSelector::testVertices(), TrackingNtuple::tpHitIndexListLessSort(), KinematicConstrainedVertexUpdator::update(), DAClusterizerInZ_vect::update(), DAClusterizerInZT_vect::update(), PrimaryVertexMonitor::vertexPlots(), DAClusterizerInZ_vect::vertices(), DAClusterizerInZT_vect::vertices(), DeterministicAnnealing::weight(), GeometricAnnealing::weight(), and VirtualJetProducer::writeJets().

10  {
11  return !isFinite(x);
12  }
bool isFinite(long double x)
Definition: isFinite.h:34
bool edm::isSameEvent ( EventAuxiliary const &  a,
EventAuxiliary const &  b 
)

Definition at line 17 of file EventAuxiliary.cc.

References edm::EventAuxiliary::bunchCrossing(), edm::EventAuxiliary::experimentType(), edm::EventAuxiliary::id(), edm::EventAuxiliary::isRealData(), edm::EventAuxiliary::luminosityBlock(), edm::EventAuxiliary::processGUID(), edm::EventAuxiliary::storeNumber(), and edm::EventAuxiliary::time().

Referenced by isSameEvent().

17  {
18  return
19  a.id() == b.id() &&
20  a.processGUID() == b.processGUID() &&
21  a.luminosityBlock() == b.luminosityBlock() &&
22  a.time() == b.time() &&
23  a.isRealData() == b.isRealData() &&
24  a.experimentType() == b.experimentType() &&
25  a.bunchCrossing() == b.bunchCrossing() &&
26  a.storeNumber() == b.storeNumber();
27  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::isSameEvent ( EventPrincipal const &  a,
EventPrincipal const &  b 
)
inline

Definition at line 215 of file EventPrincipal.h.

References edm::EventPrincipal::aux(), and isSameEvent().

215  {
216  return isSameEvent(a.aux(), b.aux());
217  }
bool isSameEvent(EventPrincipal const &a, EventPrincipal const &b)
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename C , typename KEY >
bool edm::isThinnedAvailable ( RefCore const &  product,
KEY const &  iKey 
)
inline

Definition at line 119 of file RefItemGet.h.

References edm::refitem::IsThinnedAvailableImpl< C, KEY >::isThinnedAvailable_().

119  {
120  return refitem::IsThinnedAvailableImpl<C, KEY>::isThinnedAvailable_(product, iKey);
121  }
bool edm::isTransientEqual ( ParameterSet const &  a,
ParameterSet const &  b 
)

Definition at line 868 of file ParameterSet.cc.

References MillePedeFileConverter_cfg::e, f, mps_fire::i, gen::k, Pi, edm::ParameterSet::psetTable(), edm::ParameterSet::tbl(), and edm::ParameterSet::vpsetTable().

Referenced by edm::eventsetup::EventSetupsController::getESProducerAndRegisterProcess(), edm::eventsetup::EventSetupsController::getESSourceAndRegisterProcess(), operator==(), and swap().

868  {
869  if(a.tbl().size() != b.tbl().size()) {
870  return false;
871  }
872  if(a.psetTable().size() != b.psetTable().size()) {
873  return false;
874  }
875  if(a.vpsetTable().size() != b.vpsetTable().size()) {
876  return false;
877  }
878  typedef ParameterSet::table::const_iterator Ti;
879  for (Ti i = a.tbl().begin(), e = a.tbl().end(),
880  j = b.tbl().begin(), f = b.tbl().end();
881  i != e && j != f; ++i, ++j) {
882  if(*i != *j) {
883  return false;
884  }
885  }
886  typedef ParameterSet::psettable::const_iterator Pi;
887  for (Pi i = a.psetTable().begin(), e = a.psetTable().end(),
888  j = b.psetTable().begin(), f = b.psetTable().end();
889  i != e && j != f; ++i, ++j) {
890  if(i->first != j->first) {
891  return false;
892  }
893  if(i->second.isTracked() != j->second.isTracked()) {
894  return false;
895  }
896  if(!isTransientEqual(i->second.pset(), j->second.pset())) {
897  return false;
898  }
899  }
900  typedef ParameterSet::vpsettable::const_iterator PVi;
901  for (PVi i = a.vpsetTable().begin(), e = a.vpsetTable().end(),
902  j = b.vpsetTable().begin(), f = b.vpsetTable().end();
903  i != e && j != f; ++i, ++j) {
904  if(i->first != j->first) {
905  return false;
906  }
907  if(i->second.isTracked() != j->second.isTracked()) {
908  return false;
909  }
910  std::vector<ParameterSet> const& iv = i->second.vpset();
911  std::vector<ParameterSet> const& jv = j->second.vpset();
912  if(iv.size() != jv.size()) {
913  return false;
914  }
915  for (size_t k = 0; k < iv.size(); ++k) {
916  if(!isTransientEqual(iv[k], jv[k])) {
917  return false;
918  }
919  }
920  }
921  return true;
922  }
const double Pi
double f[11][100]
int k[5][pyjets_maxn]
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool isTransientEqual(ParameterSet const &a, ParameterSet const &b)
bool edm::isWarningEnabled ( )
template<typename V , typename T >
bool edm::iterateTrieLeaves ( V &  v,
TrieNode< T > const &  n,
std::string const &  label = "" 
)

visits only leaf nodes

Definition at line 297 of file Trie.h.

References MillePedeFileConverter_cfg::e, diffTwoXMLs::label, AlCaHLTBitMon_ParallelJobs::p, and findQualityFiles::v.

297  {
298  typedef TrieNodeIter<T> node_iterator;
299  node_iterator e;
300  node_iterator p(&n);
301  if (p==e) return true;
302  for (; p!=e; ++p) {
303  if (iterateTrieLeaves(v,*p,label+(char)p.label()) )
304  v((*p).value(),label+(char)p.label());
305  }
306  return false;
307  }
bool iterateTrieLeaves(V &v, TrieNode< T > const &n, std::string const &label="")
visits only leaf nodes
Definition: Trie.h:297
static std::string const edm::kBaseType ( "Source"  )
static
static const std::string edm::kBaseType ( "EDProducer"  )
static
static const std::string edm::kBaseType ( "EDFilter"  )
static
static const std::string edm::kBaseType ( "EDAnalyzer"  )
static
static const std::string edm::kBaseType ( "OutputModule"  )
static
bool edm::lessThan ( LuminosityBlockRange const &  lh,
LuminosityBlockRange const &  rh 
)

Definition at line 70 of file LuminosityBlockRange.cc.

References edm::LuminosityBlockRange::endLumiID(), and edm::LuminosityBlockRange::startLumiID().

70  {
71  return lh.endLumiID() < rh.startLumiID();
72  }
bool int lh
Definition: SIMDVec.h:21
bool edm::lessThan ( EventRange const &  lh,
EventRange const &  rh 
)

Definition at line 67 of file EventRange.cc.

References edm::EventRange::endEventID(), edm::EventRange::startEventID(), and edm::EventRange::startLumi().

Referenced by distinct(), edm::EventSkipperByID::skipIt(), and DQMRootSource::skipIt().

67  {
68  assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
69  return lh.endEventID() < rh.startEventID();
70  }
bool int lh
Definition: SIMDVec.h:21
bool edm::lessThanSpecial ( EventRange const &  lh,
EventRange const &  rh 
)

Definition at line 59 of file EventRange.cc.

References edm::EventRange::endEventID(), edm::EventRange::startEventID(), and edm::EventRange::startLumi().

Referenced by edm::EventSkipperByID::skipIt().

59  {
60  // First, separate the ranges so that those with 0 lumiID go first.
61  if ((lh.startLumi() == 0) != (rh.startLumi() == 0)) {
62  return lh.startLumi() == 0;
63  }
64  return lh.endEventID() < rh.startEventID();
65  }
bool int lh
Definition: SIMDVec.h:21
bool edm::loadCap ( std::string const &  name,
std::vector< std::string > &  missingDictionaries 
)

Definition at line 16 of file ClassFiller.cc.

References edm::TypeWithDict::byName(), checkClassDictionaries(), and FDEBUG.

16  {
17  FDEBUG(1) << "Loading dictionary for " << name << "\n";
18  TypeWithDict typeWithDict = TypeWithDict::byName(name);
19  return checkClassDictionaries(missingDictionaries, name, typeWithDict);
20  }
#define FDEBUG(lev)
Definition: DebugMacros.h:20
bool checkClassDictionaries(std::vector< std::string > &missingDictionaries, TypeID const &typeID)
bool edm::loadCap ( const std::string &  name,
std::vector< std::string > &  missingDictionaries 
)
void edm::loadExtraClasses ( )

Definition at line 34 of file ClassFiller.cc.

References edm::errors::Configuration, Exception, loadCap(), dataset::name, AlCaHLTBitMon_QueryRunRegistry::string, and throwMissingDictionariesException().

Referenced by edm::StreamerInputSource::mergeIntoRegistry().

34  {
35  static bool done = false;
36  if (done == false) {
37  std::vector<std::string> missingDictionaries;
38  loadCap(std::string("edm::StreamedProduct"), missingDictionaries);
39  loadCap(std::string("std::vector<edm::StreamedProduct>"), missingDictionaries);
40  loadCap(std::string("edm::SendEvent"), missingDictionaries);
41  loadCap(std::string("std::vector<edm::BranchDescription>"), missingDictionaries);
42  loadCap(std::string("edm::SendJobHeader"), missingDictionaries);
43  if (!missingDictionaries.empty()) {
44  std::string context("Calling loadExtraClasses, checking dictionaries");
45  throwMissingDictionariesException(missingDictionaries, context);
46  }
47  }
48  done=true;
49  }
void throwMissingDictionariesException(std::vector< std::string > &missingDictionaries, std::string const &context)
bool loadCap(std::string const &name, std::vector< std::string > &missingDictionaries)
Definition: ClassFiller.cc:16
static ELmap const& edm::loadMap ( )
static

Definition at line 62 of file ELseverityLevel.cc.

References ELdebug, ELerror, ELhighestSeverity, ELinfo, edm::ELseverityLevel::ELsev_error, edm::ELseverityLevel::ELsev_highestSeverity, edm::ELseverityLevel::ELsev_info, edm::ELseverityLevel::ELsev_severe, edm::ELseverityLevel::ELsev_success, edm::ELseverityLevel::ELsev_unspecified, edm::ELseverityLevel::ELsev_warning, edm::ELseverityLevel::ELsev_zeroSeverity, ELsevere, ELunspecified, ELwarning, ELzeroSeverity, and funct::m.

Referenced by edm::ELseverityLevel::ELseverityLevel(), and TkHistoMap::loadTkHistoMap().

62  {
63 
64  static const ELmap m = {
65  { ELzeroSeverity.getSymbol(), ELseverityLevel::ELsev_zeroSeverity }
66  , { ELzeroSeverity.getName() , ELseverityLevel::ELsev_zeroSeverity }
67  , { ELzeroSeverity.getInputStr() , ELseverityLevel::ELsev_zeroSeverity }
68  , { ELzeroSeverity.getVarName() , ELseverityLevel::ELsev_zeroSeverity }
69  ,
70  { ELdebug.getSymbol() , ELseverityLevel::ELsev_success }
71  , { ELdebug.getName() , ELseverityLevel::ELsev_success }
72  , { ELdebug.getInputStr() , ELseverityLevel::ELsev_success }
73  , { ELdebug.getVarName() , ELseverityLevel::ELsev_success }
74  ,
75  { ELinfo.getSymbol() , ELseverityLevel::ELsev_info }
76  , { ELinfo.getName() , ELseverityLevel::ELsev_info }
77  , { ELinfo.getInputStr() , ELseverityLevel::ELsev_info }
78  , { ELinfo.getVarName() , ELseverityLevel::ELsev_info }
79  ,
80  { ELwarning.getSymbol() , ELseverityLevel::ELsev_warning }
81  , { ELwarning.getName() , ELseverityLevel::ELsev_warning }
82  , { ELwarning.getInputStr() , ELseverityLevel::ELsev_warning }
83  , { ELwarning.getVarName() , ELseverityLevel::ELsev_warning }
84  ,
85  { ELerror.getSymbol() , ELseverityLevel::ELsev_error }
86  , { ELerror.getName() , ELseverityLevel::ELsev_error }
87  , { ELerror.getInputStr() , ELseverityLevel::ELsev_error }
88  , { ELerror.getVarName() , ELseverityLevel::ELsev_error }
89  ,
90  { ELunspecified.getSymbol() , ELseverityLevel::ELsev_unspecified }
91  , { ELunspecified.getName() , ELseverityLevel::ELsev_unspecified }
92  , { ELunspecified.getInputStr() , ELseverityLevel::ELsev_unspecified }
93  , { ELunspecified.getVarName() , ELseverityLevel::ELsev_unspecified }
94  ,
95  { ELsevere.getSymbol() , ELseverityLevel::ELsev_severe }
96  , { ELsevere.getName() , ELseverityLevel::ELsev_severe }
97  , { ELsevere.getInputStr() , ELseverityLevel::ELsev_severe }
98  , { ELsevere.getVarName() , ELseverityLevel::ELsev_severe }
99  ,
100  { ELhighestSeverity.getSymbol() , ELseverityLevel::ELsev_highestSeverity }
101  , { ELhighestSeverity.getName() , ELseverityLevel::ELsev_highestSeverity }
102  , { ELhighestSeverity.getInputStr() , ELseverityLevel::ELsev_highestSeverity }
103  , { ELhighestSeverity.getVarName() , ELseverityLevel::ELsev_highestSeverity }
104  } ;
105 
106  return m;
107 
108  }
ELslProxy< ELdebugGen > const ELdebug
ELslProxy< ELunspecifiedGen > const ELunspecified
ELslProxy< ELwarningGen > const ELwarning
ELslProxy< ELhighestSeverityGen > const ELhighestSeverity
ELslProxy< ELzeroSeverityGen > const ELzeroSeverity
ELslProxy< ELerrorGen > const ELerror
std::map< ELstring const, ELseverityLevel::ELsev_ > ELmap
ELslProxy< ELinfoGen > const ELinfo
ELslProxy< ELsevereGen > const ELsevere
std::vector< ErrorSummaryEntry > edm::LoggedErrorsOnlySummary ( unsigned int  iStreamID)

Definition at line 203 of file MessageSender.cc.

References MillePedeFileConverter_cfg::e, ELerror, end, errorSummaryMaps, mps_fire::i, crabWrapper::key, and findQualityFiles::v.

203  { // ChangeLog 2
204  std::vector<ErrorSummaryEntry> v;
205  assert(iStreamID < errorSummaryMaps.size());
206  auto const& errorSummaryMap =errorSummaryMaps[iStreamID];
207  auto end = errorSummaryMap.end();
208  for (auto i = errorSummaryMap.begin();
209  i != end; ++i) {
210  auto const& key = i->first;
211  if (key.severity >= edm::ELerror) {
212  ErrorSummaryEntry e{key.category,key.module,key.severity};
213  e.count = i->second.value().load(std::memory_order_acquire);
214  v.push_back(e);
215  }
216  }
217  std::sort(v.begin(),v.end());
218  return v;
219  }
ELslProxy< ELerrorGen > const ELerror
#define end
Definition: vmac.h:39
static std::vector< tbb::concurrent_unordered_map< ErrorSummaryMapKey, AtomicUnsignedInt, ErrorSummaryMapKey::key_hash > > errorSummaryMaps
std::vector< ErrorSummaryEntry > edm::LoggedErrorsSummary ( unsigned int  iStreamID)

Definition at line 176 of file MessageSender.cc.

References MillePedeFileConverter_cfg::e, end, errorSummaryMaps, mps_fire::i, crabWrapper::key, and findQualityFiles::v.

Referenced by HLTLogMonitorFilter::filter(), and edm::LogErrorHarvester::produce().

176  {
177  assert(iStreamID<errorSummaryMaps.size());
178  auto const& errorSummaryMap =errorSummaryMaps[iStreamID];
179  std::vector<ErrorSummaryEntry> v;
180  auto end = errorSummaryMap.end();
181  for (auto i = errorSummaryMap.begin();
182  i != end; ++i) {
183  auto const& key = i->first;
184  ErrorSummaryEntry e{key.category,key.module,key.severity};
185 
186  e.count = i->second.value().load(std::memory_order_acquire);
187  v.push_back(e);
188  }
189  std::sort(v.begin(),v.end());
190  return v;
191  }
#define end
Definition: vmac.h:39
static std::vector< tbb::concurrent_unordered_map< ErrorSummaryMapKey, AtomicUnsignedInt, ErrorSummaryMapKey::key_hash > > errorSummaryMaps
void edm::LogStatistics ( )

Definition at line 67 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqSUM().

67  {
68  edm::MessageLoggerQ::MLqSUM ( ); // trigger summary info
69 }
static void MLqSUM()
void edm::longBranchPrint ( TTree *  tr)

Definition at line 87 of file CollUtil.cc.

References gather_cfg::cout, and mps_fire::i.

87  {
88  if (tr != nullptr) {
89  Long64_t nB = tr->GetListOfBranches()->GetEntries();
90  for (Long64_t i = 0; i < nB; ++i) {
91  tr->GetListOfBranches()->At(i)->Print();
92  }
93  } else {
94  std::cout << "Missing Events tree?\n";
95  }
96  }
template<typename ForwardSequence , typename Datum >
ForwardSequence::const_iterator edm::lower_bound_all ( ForwardSequence const &  s,
Datum const &  d 
)
inline

wrappers for std::lower_bound

Definition at line 91 of file Algorithms.h.

References edmIntegrityCheck::d.

Referenced by edm::RootFile::fillEventHistory(), edm::FileIndex::findEventEntryPosition(), and edm::FileIndex::findPosition().

91  {
92  return std::lower_bound(s.begin(), s.end(), d);
93  }
template<typename ForwardSequence , typename Datum >
ForwardSequence::iterator edm::lower_bound_all ( ForwardSequence &  s,
Datum const &  d 
)
inline

Definition at line 98 of file Algorithms.h.

References edmIntegrityCheck::d.

98  {
99  return std::lower_bound(s.begin(), s.end(), d);
100  }
template<typename ForwardSequence , typename Datum , typename Predicate >
ForwardSequence::const_iterator edm::lower_bound_all ( ForwardSequence const &  s,
Datum const &  d,
Predicate  p 
)
inline

Definition at line 105 of file Algorithms.h.

References edmIntegrityCheck::d, and AlCaHLTBitMon_ParallelJobs::p.

105  {
106  return std::lower_bound(s.begin(), s.end(), d, p);
107  }
template<typename ForwardSequence , typename Datum , typename Predicate >
ForwardSequence::iterator edm::lower_bound_all ( ForwardSequence &  s,
Datum const &  d,
Predicate  p 
)
inline

Definition at line 112 of file Algorithms.h.

References edmIntegrityCheck::d, and AlCaHLTBitMon_ParallelJobs::p.

112  {
113  return std::lower_bound(s.begin(), s.end(), d, p);
114  }
std::unique_ptr<edm::EmptyWaitingTask, waitingtask::TaskDestroyer> edm::make_empty_waiting_task ( )
inline
template<typename ALLOC , typename F >
FunctorTask<F>* edm::make_functor_task ( ALLOC &&  iAlloc,
F  f 
)
template<typename T , typename F >
std::unique_ptr<T, F> edm::make_sentry ( T iObject,
F  iFunc 
)

NOTE: if iObject is null, then iFunc will not be called.

Definition at line 29 of file make_sentry.h.

Referenced by edm::InputProductResolver::resolveProduct_(), edm::UnscheduledProductResolver::resolveProduct_(), edm::OutputModuleCommunicatorT< T >::writeLumiAsync(), and edm::OutputModuleCommunicatorT< T >::writeRunAsync().

29  {
30  return std::unique_ptr<T, F>(iObject, iFunc);
31  }
template<typename ALLOC , typename F >
FunctorWaitingTask<F>* edm::make_waiting_task ( ALLOC &&  iAlloc,
F  f 
)
template<typename T >
std::shared_ptr<ESHandleExceptionFactory> edm::makeESHandleExceptionFactory ( T &&  iFunctor)

Definition at line 43 of file FunctorESHandleExceptionFactory.h.

References eostools::move().

Referenced by edm::eventsetup::EventSetupRecordImpl::getImplementation().

43  {
44  return std::make_shared<FunctorESHandleExceptionFactory<T>>(std::move(iFunctor));
45  }
def move(src, dest)
Definition: eostools.py:510
template<typename T >
std::shared_ptr<HandleExceptionFactory> edm::makeHandleExceptionFactory ( T &&  iFunctor)
std::unique_ptr<InputSource> edm::makeInput ( ParameterSet params,
CommonParams const &  common,
std::shared_ptr< ProductRegistry preg,
std::shared_ptr< BranchIDListHelper branchIDListHelper,
std::shared_ptr< ThinnedAssociationsHelper thinnedAssociationsHelper,
std::shared_ptr< ActivityRegistry areg,
std::shared_ptr< ProcessConfiguration const >  processConfiguration,
PreallocationConfiguration const &  allocations 
)

Definition at line 117 of file EventProcessor.cc.

References cms::Exception::addContext(), edm::errors::Configuration, beamerCreator::create(), Exception, objects.autophobj::filler, reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), edm::ParameterSet::id(), input, edm::CommonParams::maxEventsInput_, edm::CommonParams::maxLumisInput_, edm::CommonParams::maxSecondsUntilRampdown_, edm::ParameterSet::registerIt(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::convertException::wrap().

Referenced by edm::EventProcessor::init().

124  {
125  ParameterSet* main_input = params.getPSetForUpdate("@main_input");
126  if(main_input == nullptr) {
128  << "There must be exactly one source in the configuration.\n"
129  << "It is missing (or there are sufficient syntax errors such that it is not recognized as the source)\n";
130  }
131 
132  std::string modtype(main_input->getParameter<std::string>("@module_type"));
133 
134  std::unique_ptr<ParameterSetDescriptionFillerBase> filler(
136  ConfigurationDescriptions descriptions(filler->baseType(), modtype);
137  filler->fill(descriptions);
138 
139  try {
140  convertException::wrap([&]() {
141  descriptions.validate(*main_input, std::string("source"));
142  });
143  }
144  catch (cms::Exception & iException) {
145  std::ostringstream ost;
146  ost << "Validating configuration of input source of type " << modtype;
147  iException.addContext(ost.str());
148  throw;
149  }
150 
151  main_input->registerIt();
152 
153  // Fill in "ModuleDescription", in case the input source produces
154  // any EDProducts, which would be registered in the ProductRegistry.
155  // Also fill in the process history item for this process.
156  // There is no module label for the unnamed input source, so
157  // just use "source".
158  // Only the tracked parameters belong in the process configuration.
159  ModuleDescription md(main_input->id(),
160  main_input->getParameter<std::string>("@module_type"),
161  "source",
162  processConfiguration.get(),
163  ModuleDescription::getUniqueID());
164 
165  InputSourceDescription isdesc(md, preg, branchIDListHelper, thinnedAssociationsHelper, areg,
166  common.maxEventsInput_, common.maxLumisInput_,
167  common.maxSecondsUntilRampdown_, allocations);
168 
169  areg->preSourceConstructionSignal_(md);
170  std::unique_ptr<InputSource> input;
171  try {
172  //even if we have an exception, send the signal
173  std::shared_ptr<int> sentry(nullptr,[areg,&md](void*){areg->postSourceConstructionSignal_(md);});
174  convertException::wrap([&]() {
175  input = std::unique_ptr<InputSource>(InputSourceFactory::get()->makeInputSource(*main_input, isdesc).release());
176  input->preEventReadFromSourceSignal_.connect(std::cref(areg->preEventReadFromSourceSignal_));
177  input->postEventReadFromSourceSignal_.connect(std::cref(areg->postEventReadFromSourceSignal_));
178  });
179  }
180  catch (cms::Exception& iException) {
181  std::ostringstream ost;
182  ost << "Constructing input source of type " << modtype;
183  iException.addContext(ost.str());
184  throw;
185  }
186  return input;
187  }
def create(alignables, pedeDump, additionalData, outputFile, config)
static std::string const input
Definition: EdmProvDump.cc:44
Definition: common.py:1
void addContext(std::string const &context)
Definition: Exception.cc:227
auto wrap(F iFunc) -> decltype(iFunc())
T get(const Candidate &c)
Definition: component.h:55
static std::shared_ptr<cms::Exception> edm::makeNotFoundException ( char const *  where,
KindOfType  kindOfType,
TypeID const &  productType,
std::string const &  label,
std::string const &  instance,
std::string const &  process 
)
static

Definition at line 57 of file Principal.cc.

References cppFunctionSkipper::exception, PRODUCT_TYPE, and edm::errors::ProductNotFound.

Referenced by edm::Principal::getByLabel().

58  {
59  std::shared_ptr<cms::Exception> exception = std::make_shared<Exception>(errors::ProductNotFound);
60  if (kindOfType == PRODUCT_TYPE) {
61  *exception << "Principal::" << where << ": Found zero products matching all criteria\nLooking for type: " << productType << "\n"
62  << "Looking for module label: " << label << "\n" << "Looking for productInstanceName: " << instance << "\n"
63  << (process.empty() ? "" : "Looking for process: ") << process << "\n";
64  } else {
65  *exception << "Principal::" << where << ": Found zero products matching all criteria\nLooking for a container with elements of type: " << productType << "\n"
66  << "Looking for module label: " << label << "\n" << "Looking for productInstanceName: " << instance << "\n"
67  << (process.empty() ? "" : "Looking for process: ") << process << "\n";
68  }
69  return exception;
70  }
static PFTauRenderPlugin instance
void edm::makeParameterSets ( std::string const &  configtext,
std::shared_ptr< ParameterSet > &  main 
)

essentially the same as the previous method

Definition at line 54 of file MakeParameterSets.cc.

References PythonProcessDesc::parameterSet().

Referenced by edm::ServiceRegistry::createServicesFromConfig().

55  {
56  PythonProcessDesc pythonProcessDesc(configtext);
57  main = pythonProcessDesc.parameterSet();
58  }
Definition: main.py:1
template<class HandleT >
Ref<typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> edm::makeRefTo ( const HandleT &  iHandle,
det_id_type  iDetID,
typename HandleT::element_type::value_type::const_iterator  itIter 
)
inline

Definition at line 473 of file DetSetVector.h.

References edm::errors::InvalidReference, and edm::Exception::throwThis().

Referenced by makeRefToDetSetVector(), and TTClusterBuilder< T >::RetrieveRawHits().

475  {
476  typedef typename HandleT::element_type Vec;
478  typename Vec::const_iterator itFound = iHandle->find(iDetID);
479  if(itFound == iHandle->end()) {
480  Exception::throwThis(errors::InvalidReference,
481  "an edm::Ref to an edm::DetSetVector was given a DetId, ", iDetID, ", that is not in the DetSetVector");
482  }
483  index += (itIter- itFound->data.begin());
484  if(index >= itFound->data.size()) {
485  Exception::throwThis(errors::InvalidReference,
486  "an edm::Ref to a edm::DetSetVector is being made with an interator that is not part of the edm::DetSet itself");
487  }
488  return Ref<typename HandleT::element_type,
490  (iHandle,std::make_pair(iDetID,index));
491  }
uint16_t size_type
template<typename T >
RefToBaseProd<T> edm::makeRefToBaseProdFrom ( RefToBase< T > const &  iRef,
Event const &  iEvent 
)
template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> edm::makeRefToDetSetRefVector ( const HandleT &  iHandle,
det_id_type  iDetID,
typename HandleT::element_type::value_type::const_iterator  itIter 
)

Definition at line 307 of file DetSetRefVector.h.

Referenced by makeRefToDetSetRefVector().

309  {
310  typedef typename HandleT::element_type Vec;
312  typename Vec::const_iterator itFound = iHandle->find(iDetID);
313  index += (itIter- itFound->data.begin());
314  return Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> (iHandle,std::make_pair(iDetID,index));
315  }
uint16_t size_type
template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> edm::makeRefToDetSetRefVector ( const HandleT &  iHandle,
det_id_type  iDetID,
typename HandleT::element_type::value_type::iterator  itIter 
)

Definition at line 319 of file DetSetRefVector.h.

References makeRefToDetSetRefVector().

321  {
322  typedef typename HandleT::element_type Vec;
323  typename Vec::detset::const_iterator itIter2 = itIter;
324  return makeRefToDetSetRefVector(iHandle,iDetID,itIter2);
325  }
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type > makeRefToDetSetRefVector(const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::iterator itIter)
template<class HandleT >
Ref<typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> edm::makeRefToDetSetVector ( const HandleT &  iHandle,
det_id_type  iDetID,
typename HandleT::element_type::value_type::iterator  itIter 
)
inline

Definition at line 496 of file DetSetVector.h.

References makeRefTo().

498  {
499  typedef typename HandleT::element_type Vec;
500  typename Vec::detset::const_iterator itIter2 = itIter;
501  return makeRefTo(iHandle,iDetID,itIter2);
502  }
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type > makeRefTo(const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::const_iterator itIter)
Definition: DetSetVector.h:473
std::unique_ptr< RunHelperBase > edm::makeRunHelper ( ParameterSet const &  pset)

Definition at line 13 of file RunHelper.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getUntrackedParameter(), muonDTDigis_cfi::pset, findQualityFiles::run, gather_cfg::runs, and mitigatedMETSequence_cff::U.

13  {
14  if(pset.exists("setRunNumber")) {
15  RunNumber_t run = pset.getUntrackedParameter<unsigned int>("setRunNumber");
16  if(run != 0U) {
17  return std::make_unique<SetRunHelper>(pset);
18  }
19  }
20  if(pset.exists("setRunNumberForEachLumi")) {
21  std::vector<RunNumber_t> runs = pset.getUntrackedParameter<std::vector<unsigned int> >("setRunNumberForEachLumi");
22  if(!runs.empty()) {
23  return std::make_unique<SetRunForEachLumiHelper>(pset);
24  }
25  }
26  return std::make_unique<DefaultRunHelper>();
27  }
unsigned int RunNumber_t
std::string edm::match ( BranchDescription const &  a,
BranchDescription const &  b,
std::string const &  fileName 
)

Definition at line 329 of file BranchDescription.cc.

References edm::BranchDescription::branchID(), edm::BranchDescription::branchName(), edm::BranchDescription::branchType(), edm::BranchDescription::dropped(), and edm::BranchDescription::fullClassName().

Referenced by edm::RootOutputFile::beginInputFile(), edm::EventSelector::identical(), ConversionTools::matchedConversion(), ConversionTools::matchedPromptElectron(), edm::ProductRegistry::merge(), reco::modules::MCMatchCandRefSelector::newEvent(), edm::InputTagMatch::operator()(), edm::IDVectorMap< ID, C, P >::match_iterator< M >::operator++(), operator<<(), edm::IDVectorMap< ID, C, P >::match_iterator< M >::operator=(), HLTTauRefCombiner::produce(), GlobalCosmicMuonTrajectoryBuilder::propagator(), CosmicMuonLinksProducer::sharedHits(), edm::ThinnedAssociationsHelper::shouldKeepAssociation(), SiStripRecHitConverterAlgorithm::products::shrink_to_fit(), edm::PoolOutputModule::SpecialSplitLevelForBranch::SpecialSplitLevelForBranch(), and edm::detail::TriggerResultsBasedEventSelector::wantEvent().

330  {
331  std::ostringstream differences;
332  if(a.branchName() != b.branchName()) {
333  differences << "Branch name '" << b.branchName() << "' does not match '" << a.branchName() << "'.\n";
334  // Need not compare components of branch name individually.
335  // (a.friendlyClassName() != b.friendlyClassName())
336  // (a.moduleLabel() != b.moduleLabel())
337  // (a.productInstanceName() != b.productInstanceName())
338  // (a.processName() != b.processName())
339  }
340  if(a.branchType() != b.branchType()) {
341  differences << "Branch '" << b.branchName() << "' is a(n) '" << b.branchType() << "' branch\n";
342  differences << " in file '" << fileName << "', but a(n) '" << a.branchType() << "' branch in previous files.\n";
343  }
344  if(a.branchID() != b.branchID()) {
345  differences << "Branch '" << b.branchName() << "' has a branch ID of '" << b.branchID() << "'\n";
346  differences << " in file '" << fileName << "', but '" << a.branchID() << "' in previous files.\n";
347  }
348  if(a.fullClassName() != b.fullClassName()) {
349  differences << "Products on branch '" << b.branchName() << "' have type '" << b.fullClassName() << "'\n";
350  differences << " in file '" << fileName << "', but '" << a.fullClassName() << "' in previous files.\n";
351  }
352  if(!b.dropped() && a.dropped()) {
353  differences << "Branch '" << a.branchName() << "' was dropped in the first input file but is present in '" << fileName << "'.\n";
354  }
355  return differences.str();
356  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
LuminosityBlockID const& edm::max ( LuminosityBlockID const &  lh,
LuminosityBlockID const &  rh 
)
inline

Definition at line 135 of file LuminosityBlockID.h.

135  {
136  return (rh < lh ? lh : rh);
137  }
bool int lh
Definition: SIMDVec.h:21
EventID const& edm::max ( EventID const &  lh,
EventID const &  rh 
)
inline
const unsigned int edm::maxIDlength ( 200  )

Referenced by edm::ErrorObj::setID().

bool edm::merge ( LuminosityBlockRange lh,
LuminosityBlockRange rh 
)

Definition at line 78 of file LuminosityBlockRange.cc.

References begin, end, edm::LuminosityBlockRange::endLumiID(), mathSSE::lh, edm::LuminosityBlockRange::LuminosityBlockRange(), max(), min(), overlaps(), edm::LuminosityBlockRange::startLumi(), and edm::LuminosityBlockRange::startLumiID().

Referenced by sortAndRemoveOverlaps().

78  {
79  if (overlaps(lh, rh)) {
80  LuminosityBlockID begin = min(lh.startLumiID(), rh.startLumiID());
81  LuminosityBlockID end = max(lh.endLumiID(), rh.endLumiID());
82  rh = lh = LuminosityBlockRange(begin, end);
83  return true;
84  }
85  return false;
86  }
#define end
Definition: vmac.h:39
T min(T a, T b)
Definition: MathUtil.h:58
#define begin
Definition: vmac.h:32
LuminosityBlockID const& edm::min ( LuminosityBlockID const &  lh,
LuminosityBlockID const &  rh 
)
inline

Definition at line 130 of file LuminosityBlockID.h.

130  {
131  return (rh < lh ? rh : lh);
132  }
bool int lh
Definition: SIMDVec.h:21
EventID const& edm::min ( EventID const &  lh,
EventID const &  rh 
)
inline
std::string edm::moduleName ( Provenance const &  provenance)

Definition at line 27 of file Provenance.cc.

References edm::ParameterSet::getParameter(), edm::Provenance::moduleLabel(), parameterSet(), AlCaHLTBitMon_QueryRunRegistry::string, triggerResults(), and triggerResultsInserter().

Referenced by algorithm(), HLTObjectsMonitor::analyze(), TopDecaySubset::checkShowerModel(), edm::DaqProvenanceHelper::DaqProvenanceHelper(), HeavyFlavorValidation::dqmBeginRun(), edm::LHEProvenanceHelper::fillCommonProcessParameterSet(), pos::PixelDelay25Calib::getCommands(), egHLT::trigTools::getL1SeedFilterOfPath(), pos::PixelPortcardMap::getName(), HLTObjectMonitor::HLTObjectMonitor(), HLTObjectMonitorProtonLead::HLTObjectMonitorProtonLead(), edm::service::isProcessWideService(), HeavyFlavorValidation::myBook1D(), pos::PixelPortcardMap::numChannels(), AlignableTrackerBuilder::objectIdProvider(), OniaVtxReProducer::OniaVtxReProducer(), PixelToFEDAssociateFromAscii::operator()(), pos::PixelDetectorConfig::PixelDetectorConfig(), HadronAndPartonSelector::produce(), edm::RootFile::reportOpened(), edm::RootOutputFile::RootOutputFile(), and edm::Maker::throwValidationException().

27  {
28  // Trigger results ia a special case
29  if(provenance.moduleLabel() == triggerResults) {
30  return triggerResultsInserter;
31  }
32  return parameterSet(provenance).getParameter<std::string>("@module_type");
33  }
T getParameter(std::string const &) const
static std::string const triggerResultsInserter("TriggerResultsInserter")
static std::string const triggerResults
Definition: EdmProvDump.cc:41
ParameterSet const & parameterSet(Provenance const &provenance)
Definition: Provenance.cc:11
EDProductGetter const * edm::mustBeNonZero ( EDProductGetter const *  prodGetter,
std::string  refType,
ProductID const &  productID 
)

Definition at line 70 of file EDProductGetter.cc.

References Exception, and edm::errors::InvalidReference.

Referenced by edm::EDProductGetter::transitionIndex().

70  {
71  if (prodGetter != nullptr) return prodGetter;
72  throw Exception(errors::InvalidReference, refType)
73  << "Attempt to construct a " << refType << " with ProductID " << productID << "\n"
74  << "but with a null pointer to a product getter.\n"
75  << "The product getter pointer passed to the constructor must refer\n"
76  << "to a real getter, such as an EventPrincipal.\n";
77  }
static Principal::CacheIdentifier_t edm::nextIdentifier ( )
inlinestatic

Definition at line 110 of file Principal.cc.

References s_nextIdentifier.

Referenced by edm::Principal::fillPrincipal().

110  {
111  return s_nextIdentifier.fetch_add(1,std::memory_order_acq_rel);
112  }
static std::atomic< Principal::CacheIdentifier_t > s_nextIdentifier
Definition: Principal.cc:109
Long64_t edm::numEntries ( TFile *  hdl,
const std::string &  trname 
)
Long64_t edm::numEntries ( TFile *  hdl,
std::string const &  trname 
)

Definition at line 50 of file CollUtil.cc.

References MicroEventContent_cff::branch, gather_cfg::cout, mps_fire::i, and findQualityFiles::size.

Referenced by format_vstring(), edm::RootFile::readEntryDescriptionTree(), edm::RootFile::readParentageTree(), ProvenanceDumper::work_(), and RecoTauCleanerImpl< Prod >::~RecoTauCleanerImpl().

50  {
51  TTree *tree = (TTree*)hdl->Get(trname.c_str());
52  if (tree) {
53  return tree->GetEntries();
54  } else {
55  std::cout << "ERR cannot find a TTree named \"" << trname << "\""
56  << std::endl;
57  return -1;
58  }
59  }
Definition: tree.py:1
TFile* edm::openFileHdl ( const std::string &  fname)
TFile* edm::openFileHdl ( std::string const &  fname)

Definition at line 24 of file CollUtil.cc.

References gather_cfg::cout, and cmsRelvalreport::exit.

24  {
25  TFile *hdl = TFile::Open(fname.c_str(), "read");
26 
27  if (nullptr == hdl) {
28  std::cout << "ERR Could not open file " << fname.c_str() << std::endl;
29  exit(1);
30  }
31  return hdl;
32  }
string fname
main script
bool edm::operator!= ( FileID const &  lh,
FileID const &  rh 
)
inline

Definition at line 28 of file FileID.h.

References operator<<().

28 {return !(lh == rh);}
bool int lh
Definition: SIMDVec.h:21
bool edm::operator!= ( RunLumiEntryInfo const &  a,
RunLumiEntryInfo const &  b 
)
inline

Definition at line 47 of file RunLumiEntryInfo.h.

References b.

47 { return !(a==b); }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator!= ( EventEntryInfo const &  a,
EventEntryInfo const &  b 
)
inline

Definition at line 56 of file EventEntryInfo.h.

References b.

56 { return !(a==b); }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator!= ( ProductID const &  lh,
ProductID const &  rh 
)
inline

Definition at line 58 of file ProductID.h.

References mathSSE::lh, operator<(), and operator<<().

58  {
59  return !(lh == rh);
60  }
bool int lh
Definition: SIMDVec.h:21
bool edm::operator!= ( EventEntryDescription const &  a,
EventEntryDescription const &  b 
)
inline

Definition at line 60 of file EventEntryDescription.h.

References b.

60 { return !(a==b); }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator!= ( TypeID const &  a,
TypeID const &  b 
)
inline

Definition at line 61 of file TypeID.h.

References b, and operator<<().

61  {
62  return !(a == b);
63  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator!= ( BranchKey const &  a,
BranchKey const &  b 
)
inline

Definition at line 66 of file BranchKey.h.

References b, and operator<<().

66  {
67  return !(a == b);
68  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator!= ( ProductProvenance const &  a,
ProductProvenance const &  b 
)
inline

Definition at line 66 of file ProductProvenance.h.

References b.

66 { return !(a == b); }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator!= ( const TypeIDBase a,
const TypeIDBase b 
)
inline

Definition at line 74 of file TypeIDBase.h.

References b.

75  { return !(a==b); }
double b
Definition: hdecay.h:120
template<class X , class Y >
bool edm::operator!= ( debugging_allocator< X > const &  ,
debugging_allocator< Y > const &   
)
noexcept
bool edm::operator!= ( Parentage const &  a,
Parentage const &  b 
)
inline

Definition at line 76 of file Parentage.h.

References b.

76 { return !(a == b); }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator!= ( ProcessConfiguration const &  a,
ProcessConfiguration const &  b 
)
inline

Definition at line 80 of file ProcessConfiguration.h.

References b, and operator<<().

80  {
81  return !(a == b);
82  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator!= ( ProcessHistory const &  a,
ProcessHistory const &  b 
)
inline

Definition at line 108 of file ProcessHistory.h.

References a, b, and isAncestor().

108  {
109  return !(a==b);
110  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator!= ( TypeWithDict const &  a,
TypeWithDict const &  b 
)
inline

Definition at line 140 of file TypeWithDict.h.

References b, and edm::TypeWithDict::operator==.

140  {
141  return !(a == b);
142 }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T >
bool edm::operator!= ( FwdPtr< T > const &  lhs,
FwdPtr< T > const &  rhs 
)
inline

Definition at line 145 of file FwdPtr.h.

145  {
146  return !(lhs == rhs);
147  }
bool edm::operator!= ( RefCore const &  lhs,
RefCore const &  rhs 
)
inline

Definition at line 145 of file RefCore.h.

145  {
146  return !(lhs == rhs);
147  }
bool edm::operator!= ( TypeWithDict const &  a,
std::type_info const &  b 
)
inline

Definition at line 146 of file TypeWithDict.h.

References b.

146  {
147  return !(a == b);
148 }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename KEY >
bool edm::operator!= ( RefVectorBase< KEY > const &  lhs,
RefVectorBase< KEY > const &  rhs 
)

Inequality operator.

Definition at line 146 of file RefVectorBase.h.

146  {
147  return !(lhs == rhs);
148  }
template<typename T >
bool edm::operator!= ( View< T > const &  lhs,
View< T > const &  rhs 
)
inline

Definition at line 361 of file View.h.

361  {
362  return !(lhs == rhs);
363  }
bool edm::operator!= ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)
inline

Definition at line 153 of file FileIndex.h.

References mathSSE::lh.

153 {return lh < rh || rh < lh;}
bool int lh
Definition: SIMDVec.h:21
bool edm::operator!= ( std::type_info const &  a,
TypeWithDict const &  b 
)
inline

Definition at line 154 of file TypeWithDict.h.

References a, and operator<<().

154  {
155  return !(b == a);
156 }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T >
bool edm::operator!= ( RefToBaseProd< T > const &  lhs,
RefToBaseProd< T > const &  rhs 
)
inline

Definition at line 179 of file RefToBaseProd.h.

179  {
180  return !(lhs == rhs);
181  }
template<typename T , typename U >
bool edm::operator!= ( atomic_value_ptr< T > const &  lhs,
U const &  rhs 
)
inline

Definition at line 189 of file atomic_value_ptr.h.

References edm::atomic_value_ptr< T >::this_type_does_not_support_comparisons().

189  {
190  lhs.this_type_does_not_support_comparisons();
191  return false;
192  }
bool edm::operator!= ( ProductRegistry const &  a,
ProductRegistry const &  b 
)
inline

Definition at line 195 of file ProductRegistry.h.

References b.

195  {
196  return !(a == b);
197  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T , typename U >
bool edm::operator!= ( U const &  lhs,
atomic_value_ptr< T > const &  rhs 
)
inline

Definition at line 201 of file atomic_value_ptr.h.

References edm::atomic_value_ptr< T >::this_type_does_not_support_comparisons().

201  {
202  rhs.this_type_does_not_support_comparisons();
203  return false;
204  }
template<typename C >
bool edm::operator!= ( RefProd< C > const &  lhs,
RefProd< C > const &  rhs 
)
inline

Definition at line 204 of file RefProd.h.

204  {
205  return !(lhs == rhs);
206  }
bool edm::operator!= ( Entry const &  a,
Entry const &  b 
)
inline

Definition at line 205 of file Entry.h.

References b.

205  {
206  return !(a == b);
207  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator!= ( ELseverityLevel const &  e1,
ELseverityLevel const &  e2 
)
template<typename T , typename U >
bool edm::operator!= ( value_ptr< T > const &  lhs,
U const &  rhs 
)
inline

Definition at line 213 of file value_ptr.h.

References edm::value_ptr< T >::this_type_does_not_support_comparisons().

213  {
214  lhs.this_type_does_not_support_comparisons();
215  return false;
216  }
template<typename T , typename U >
bool edm::operator!= ( U const &  lhs,
value_ptr< T > const &  rhs 
)
inline

Definition at line 225 of file value_ptr.h.

References edm::value_ptr< T >::this_type_does_not_support_comparisons().

225  {
226  rhs.this_type_does_not_support_comparisons();
227  return false;
228  }
template<typename C , typename T , typename F >
bool edm::operator!= ( RefVector< C, T, F > const &  lhs,
RefVector< C, T, F > const &  rhs 
)
inline

Definition at line 232 of file RefVector.h.

232  {
233  return !(lhs == rhs);
234  }
template<typename T >
bool edm::operator!= ( Ptr< T > const &  lhs,
Ptr< T > const &  rhs 
)
inline

Definition at line 273 of file Ptr.h.

273  {
274  return !(lhs == rhs);
275  }
template<typename C , typename T , typename F >
bool edm::operator!= ( FwdRef< C, T, F > const &  lhs,
FwdRef< C, T, F > const &  rhs 
)
inline

Definition at line 277 of file FwdRef.h.

277  {
278  return !(lhs == rhs);
279  }
template<typename C , typename T , typename F >
bool edm::operator!= ( Ref< C, T, F > const &  lhs,
FwdRef< C, T, F > const &  rhs 
)
inline

Definition at line 284 of file FwdRef.h.

284  {
285  return !(lhs == rhs);
286  }
template<typename C , typename T , typename F >
bool edm::operator!= ( FwdRef< C, T, F > const &  lhs,
Ref< C, T, F > const &  rhs 
)
inline

Definition at line 291 of file FwdRef.h.

291  {
292  return !(lhs == rhs);
293  }
bool edm::operator!= ( ParameterSet const &  a,
ParameterSet const &  b 
)
inline

Definition at line 331 of file ParameterSet.h.

References b, getParameterSet(), getProcessParameterSetContainingModule(), dataset::name, operator&&(), AlCaHLTBitMon_QueryRunRegistry::string, and relativeConstraints::value.

331  {
332  return !(a == b);
333  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename C , typename T , typename F >
bool edm::operator!= ( Ref< C, T, F > const &  lhs,
Ref< C, T, F > const &  rhs 
)
inline

Definition at line 632 of file Ref.h.

632  {
633  return !(lhs == rhs);
634  }
std::unique_ptr< ParameterDescriptionNode > edm::operator&& ( ParameterDescriptionNode const &  node_left,
ParameterDescriptionNode const &  node_right 
)

Definition at line 197 of file ParameterDescriptionNode.cc.

Referenced by edm::value_ptr_traits< ParameterDescriptionNode >::destroy().

198  {
199  return std::make_unique<ANDGroupDescription>(node_left, node_right);
200  }
std::unique_ptr< ParameterDescriptionNode > edm::operator&& ( std::unique_ptr< ParameterDescriptionNode node_left,
ParameterDescriptionNode const &  node_right 
)

Definition at line 203 of file ParameterDescriptionNode.cc.

References eostools::move().

204  {
205  return std::make_unique<ANDGroupDescription>(std::move(node_left), node_right);
206  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionNode > edm::operator&& ( ParameterDescriptionNode const &  node_left,
std::unique_ptr< ParameterDescriptionNode node_right 
)

Definition at line 209 of file ParameterDescriptionNode.cc.

References eostools::move().

210  {
211  return std::make_unique<ANDGroupDescription>(node_left, std::move(node_right));
212  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionNode > edm::operator&& ( std::unique_ptr< ParameterDescriptionNode node_left,
std::unique_ptr< ParameterDescriptionNode node_right 
)

Definition at line 215 of file ParameterDescriptionNode.cc.

References eostools::move().

216  {
217  return std::make_unique<ANDGroupDescription>(std::move(node_left), std::move(node_right));
218  }
def move(src, dest)
Definition: eostools.py:510

Definition at line 2438 of file ParameterSet.cc.

References edm::ParameterSet::False, edm::ParameterSet::True, and edm::ParameterSet::Unknown.

Referenced by operator!=().

2438  {
2440  return ParameterSet::False;
2441  } else if(a == ParameterSet::Unknown || b == ParameterSet::Unknown) {
2442  return ParameterSet::Unknown;
2443  }
2444  return ParameterSet::True;
2445  }
#define True
Definition: Types.h:96
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
#define False
Definition: Types.h:97
template<typename C , typename T , typename F >
RefVectorIterator<C, T, F> edm::operator+ ( typename RefVectorIterator< C, T, F >::difference  n,
RefVectorIterator< C, T, F > const &  iter 
)
inline

Definition at line 97 of file RefVectorIterator.h.

References gen::n.

97  {
98  return iter + n;
99  }
template<typename C >
Association<C> edm::operator+ ( const Association< C > &  a1,
const Association< C > &  a2 
)
inline

Definition at line 121 of file Association.h.

References a.

122  {
123  Association<C> a = a1;
124  a += a2;
125  return a;
126  }
double a
Definition: hdecay.h:121
template<typename T >
ValueMap<T> edm::operator+ ( const ValueMap< T > &  a1,
const ValueMap< T > &  a2 
)
inline

Definition at line 253 of file ValueMap.h.

References a.

254  {
255  ValueMap<T> a = a1;
256  a += a2;
257  return a;
258  }
double a
Definition: hdecay.h:121
bool edm::operator< ( EventProcessHistoryID const &  lh,
EventProcessHistoryID const &  rh 
)
inline

Definition at line 22 of file EventProcessHistoryID.h.

References edm::EventProcessHistoryID::eventID().

22  {
23  return lh.eventID() < rh.eventID();
24  }
bool int lh
Definition: SIMDVec.h:21
bool edm::operator< ( RunLumiEntryInfo const &  a,
RunLumiEntryInfo const &  b 
)
inline

Definition at line 34 of file RunLumiEntryInfo.h.

References edm::RunLumiEntryInfo::branchID().

34  {
35  return a.branchID() < b.branchID();
36  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator< ( StoredProductProvenance const &  a,
StoredProductProvenance const &  b 
)
inline

Definition at line 38 of file StoredProductProvenance.h.

References edm::StoredProductProvenance::branchID_.

38  {
39  return a.branchID_ < b.branchID_;
40  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator< ( EventEntryInfo const &  a,
EventEntryInfo const &  b 
)
inline

Definition at line 43 of file EventEntryInfo.h.

References edm::EventEntryInfo::branchID().

43  {
44  return a.branchID() < b.branchID();
45  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator< ( BranchKey const &  a,
BranchKey const &  b 
)
inline

Definition at line 46 of file BranchKey.h.

References edm::BranchKey::friendlyClassName(), edm::BranchKey::moduleLabel(), edm::BranchKey::processName(), and edm::BranchKey::productInstanceName().

46  {
47  return
48  a.friendlyClassName() < b.friendlyClassName() ? true :
49  a.friendlyClassName() > b.friendlyClassName() ? false :
50  a.moduleLabel() < b.moduleLabel() ? true :
51  a.moduleLabel() > b.moduleLabel() ? false :
52  a.productInstanceName() < b.productInstanceName() ? true :
53  a.productInstanceName() > b.productInstanceName() ? false :
54  a.processName() < b.processName() ? true :
55  false;
56  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator< ( ProductProvenance const &  a,
ProductProvenance const &  b 
)
inline

Definition at line 53 of file ProductProvenance.h.

References edm::ProductProvenance::branchID().

53  {
54  return a.branchID() < b.branchID();
55  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator< ( WorkerTimingSummary const &  a,
WorkerTimingSummary const &  b 
)
inline

Definition at line 54 of file TriggerTimingReport.h.

References edm::WorkerTimingSummary::moduleLabel.

54  {
55  return a.moduleLabel < b.moduleLabel;
56  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator< ( WorkerSummary const &  a,
WorkerSummary const &  b 
)
inline

Definition at line 60 of file TriggerReport.h.

References edm::WorkerSummary::moduleLabel.

60  {
61  return a.moduleLabel < b.moduleLabel;
62  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator< ( ProductID const &  lh,
ProductID const &  rh 
)

Definition at line 12 of file ProductID.cc.

References edm::ProductID::processIndex(), and edm::ProductID::productIndex().

12  {
13  return lh.processIndex() < rh.processIndex() ||
14  (lh.processIndex() == rh.processIndex() && lh.productIndex() < rh.productIndex());
15  }
bool int lh
Definition: SIMDVec.h:21
bool edm::operator< ( ProcessConfiguration const &  a,
ProcessConfiguration const &  b 
)

Definition at line 96 of file ProcessConfiguration.cc.

References edm::ProcessConfiguration::parameterSetID(), edm::ProcessConfiguration::passID(), edm::ProcessConfiguration::processName(), and edm::ProcessConfiguration::releaseVersion().

96  {
97  if (a.processName() < b.processName()) return true;
98  if (b.processName() < a.processName()) return false;
99  if (a.parameterSetID() < b.parameterSetID()) return true;
100  if (b.parameterSetID() < a.parameterSetID()) return false;
101  if (a.releaseVersion() < b.releaseVersion()) return true;
102  if (b.releaseVersion() < a.releaseVersion()) return false;
103  if (a.passID() < b.passID()) return true;
104  return false;
105  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<class T >
bool edm::operator< ( DetSet< T > const &  x,
DetSet< T > const &  y 
)
inline

Definition at line 90 of file DetSet.h.

Referenced by sistrip::SpyEventMatcher::EventKey::apvAddress(), operator!=(), operator<<(), and edm::ProductResolverIndexHelper::Item::setIndex().

90  {
91  return x.detId() < y.detId();
92  }
template<class T >
bool edm::operator< ( DetSet< T > const &  x,
det_id_type  y 
)
inline

Definition at line 97 of file DetSet.h.

97  {
98  return x.detId() < y;
99  }
template<class T >
bool edm::operator< ( det_id_type  x,
DetSet< T > const &  y 
)
inline

Definition at line 104 of file DetSet.h.

104  {
105  return x < y.detId();
106  }
bool edm::operator< ( TypeWithDict const &  a,
TypeWithDict const &  b 
)
inline

Definition at line 134 of file TypeWithDict.h.

References a, b, edm::TypeWithDict::name(), and edm::TypeWithDict::operator==.

134  {
135  return a.name() < b.name();
136 }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator< ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)

Definition at line 182 of file FileIndex.cc.

References edm::FileIndex::Element::event_, edm::FileIndex::Element::lumi_, and edm::FileIndex::Element::run_.

182  {
183  if(lh.run_ == rh.run_) {
184  if(lh.lumi_ == rh.lumi_) {
185  return lh.event_ < rh.event_;
186  }
187  return lh.lumi_ < rh.lumi_;
188  }
189  return lh.run_ < rh.run_;
190  }
bool int lh
Definition: SIMDVec.h:21
bool edm::operator< ( RefCore const &  lhs,
RefCore const &  rhs 
)
inline

Definition at line 151 of file RefCore.h.

References edm::RefCore::id(), edm::RefCore::isTransient(), and edm::RefCore::productPtr().

151  {
152  return lhs.isTransient() ? (rhs.isTransient() ? lhs.productPtr() < rhs.productPtr() : false) : (rhs.isTransient() ? true : lhs.id() < rhs.id());
153  }
template<typename T >
bool edm::operator< ( View< T > const &  lhs,
View< T > const &  rhs 
)
inline

Definition at line 368 of file View.h.

368  {
369  return std::lexicographical_compare(lhs.begin(), lhs.end(),
370  rhs.begin(), rhs.end());
371  }
template<typename T >
bool edm::operator< ( FwdPtr< T > const &  lhs,
FwdPtr< T > const &  rhs 
)
inline

The ordering of integer keys guarantees that the ordering of FwdPtrs within a collection will be identical to the ordering of the referenced objects in the collection.

Definition at line 152 of file FwdPtr.h.

152  {
155  return (lhs.ptr() < rhs.ptr());
156  }
template<typename T >
bool edm::operator< ( RefToBaseProd< T > const &  lhs,
RefToBaseProd< T > const &  rhs 
)
inline

Definition at line 186 of file RefToBaseProd.h.

186  {
187  return (lhs.refCore() < rhs.refCore());
188  }
bool edm::operator< ( ELseverityLevel const &  e1,
ELseverityLevel const &  e2 
)
template<typename C >
bool edm::operator< ( RefProd< C > const &  lhs,
RefProd< C > const &  rhs 
)
inline

Definition at line 211 of file RefProd.h.

211  {
212  return(lhs.refCore() < rhs.refCore());
213  }
bool edm::operator< ( BranchDescription const &  a,
BranchDescription const &  b 
)

Definition at line 287 of file BranchDescription.cc.

References edm::BranchDescription::branchAliases(), edm::BranchDescription::branchID(), edm::BranchDescription::branchType(), edm::BranchDescription::friendlyClassName(), edm::BranchDescription::fullClassName(), edm::BranchDescription::moduleLabel(), edm::BranchDescription::present(), edm::BranchDescription::processName(), and edm::BranchDescription::productInstanceName().

287  {
288  if(a.processName() < b.processName()) return true;
289  if(b.processName() < a.processName()) return false;
290  if(a.fullClassName() < b.fullClassName()) return true;
291  if(b.fullClassName() < a.fullClassName()) return false;
292  if(a.friendlyClassName() < b.friendlyClassName()) return true;
293  if(b.friendlyClassName() < a.friendlyClassName()) return false;
294  if(a.productInstanceName() < b.productInstanceName()) return true;
295  if(b.productInstanceName() < a.productInstanceName()) return false;
296  if(a.moduleLabel() < b.moduleLabel()) return true;
297  if(b.moduleLabel() < a.moduleLabel()) return false;
298  if(a.branchType() < b.branchType()) return true;
299  if(b.branchType() < a.branchType()) return false;
300  if(a.branchID() < b.branchID()) return true;
301  if(b.branchID() < a.branchID()) return false;
302  if(a.branchAliases() < b.branchAliases()) return true;
303  if(b.branchAliases() < a.branchAliases()) return false;
304  if(a.present() < b.present()) return true;
305  if(b.present() < a.present()) return false;
306  return false;
307  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T >
bool edm::operator< ( Ptr< T > const &  lhs,
Ptr< T > const &  rhs 
)
inline

The ordering of integer keys guarantees that the ordering of Ptrs within a collection will be identical to the ordering of the referenced objects in the collection.

Definition at line 280 of file Ptr.h.

280  {
283  return (lhs.refCore() == rhs.refCore() ? lhs.key() < rhs.key() : lhs.refCore() < rhs.refCore());
284  }
template<typename C , typename T , typename F >
bool edm::operator< ( FwdRef< C, T, F > const &  lhs,
FwdRef< C, T, F > const &  rhs 
)
inline

for inequality operators, ONLY test the forward ref. the ordering of the backward ref is not relevant.

Definition at line 300 of file FwdRef.h.

300  {
301  return (lhs.ref() < rhs.ref() );
302  }
template<typename C , typename T , typename F >
bool edm::operator< ( Ref< C, T, F > const &  lhs,
FwdRef< C, T, F > const &  rhs 
)
inline

Definition at line 307 of file FwdRef.h.

307  {
308  return (lhs < rhs.ref() );
309  }
template<typename C , typename T , typename F >
bool edm::operator< ( FwdRef< C, T, F > const &  lhs,
Ref< C, T, F > const &  rhs 
)
inline

Definition at line 314 of file FwdRef.h.

314  {
315  return (lhs.ref() < rhs );
316  }
template<typename C , typename T , typename F >
bool edm::operator< ( Ref< C, T, F > const &  lhs,
Ref< C, T, F > const &  rhs 
)
inline

the definition and use of compare_key<> guarantees that the ordering of Refs within

a collection will be identical to the ordering of the referenced objects in the collection.

Definition at line 639 of file Ref.h.

639  {
642  return (lhs.refCore() == rhs.refCore() ? compare_key<C>(lhs.key(), rhs.key()) : lhs.refCore() < rhs.refCore());
643  }
std::ostream & edm::operator<< ( std::ostream &  os,
TimeOfDay const &  tod 
)

Definition at line 27 of file TimeOfDay.cc.

References begin, min(), listBenchmarks::pattern, common_cff::precision, and edm::TimeOfDay::tv_.

27  {
28  std::ios::fmtflags oldflags = os.flags(); // Save stream formats so they can be left unchanged.
29  struct tm timebuf;
30  localtime_r(&tod.tv_.tv_sec, &timebuf);
31  typedef std::ostreambuf_iterator<char, std::char_traits<char> > Iter;
32  std::time_put<char, Iter> const& tp = std::use_facet<std::time_put<char, Iter> >(std::locale());
33  int precision = os.precision();
34  Iter begin(os);
35  if(precision == 0) {
36  char const pattern[] = "%d-%b-%Y %H:%M:%S %Z";
37  tp.put(begin, os, ' ', &timebuf, pattern, pattern + sizeof(pattern) - 1);
38  } else {
39  char const pattern[] = "%d-%b-%Y %H:%M:%S.";
40  tp.put(begin, os, ' ', &timebuf, pattern, pattern + sizeof(pattern) - 1);
41  precision = std::min(precision, 6);
42  os << std::setfill('0') << std::setw(precision) << tod.tv_.tv_usec/power[precision] << ' ';
43  tp.put(begin, os, ' ', &timebuf, 'Z');
44  }
45  os.flags(oldflags);
46  return os;
47  }
T min(T a, T b)
Definition: MathUtil.h:58
#define begin
Definition: vmac.h:32
std::ostream & edm::operator<< ( std::ostream &  os,
ParameterSetBlob const &  blob 
)

Definition at line 6 of file ParameterSetBlob.cc.

References edm::ParameterSetBlob::pset().

6  {
7  os << blob.pset();
8  return os;
9  }
std::ostream & edm::operator<< ( std::ostream &  os,
FileID const &  id 
)

Definition at line 6 of file FileID.cc.

6  {
7  os << id.fid();
8  return os;
9  }
std::ostream & edm::operator<< ( std::ostream &  os,
BranchType const &  branchType 
)
std::ostream & edm::operator<< ( std::ostream &  os,
PlaceInPathContext const &  ppc 
)

Definition at line 13 of file PlaceInPathContext.cc.

References edm::PlaceInPathContext::pathContext(), and edm::PlaceInPathContext::placeInPath().

13  {
14  os << "PlaceInPathContext " << ppc.placeInPath() << "\n";
15  if(ppc.pathContext()) {
16  os << " " << *ppc.pathContext();
17  }
18  return os;
19  }
std::ostream & edm::operator<< ( std::ostream &  os,
BranchID const &  id 
)

Definition at line 14 of file BranchID.cc.

14  {
15  os << id.id();
16  return os;
17  }
std::ostream & edm::operator<< ( std::ostream &  os,
InternalContext const &  ic 
)

Definition at line 14 of file InternalContext.cc.

References edm::InternalContext::eventID(), and edm::InternalContext::moduleCallingContext().

14  {
15  os << "InternalContext " << ic.eventID() << "\n";
16  if(ic.moduleCallingContext()) {
17  os << " " << *ic.moduleCallingContext();
18  }
19  return os;
20  }
std::ostream& edm::operator<< ( std::ostream &  os,
RunLumiEntryInfo const &  p 
)
inline

Definition at line 40 of file RunLumiEntryInfo.h.

References a, b, operator==(), and edm::RunLumiEntryInfo::write().

40  {
41  p.write(os);
42  return os;
43  }
std::ostream & edm::operator<< ( std::ostream &  os,
FileFormatVersion const &  ff 
)

Definition at line 111 of file FileFormatVersion.cc.

References edm::FileFormatVersion::value().

111  {
112  os << ff.value();
113  return os;
114  }
std::ostream& edm::operator<< ( std::ostream &  os,
EventEntryInfo const &  p 
)
inline

Definition at line 49 of file EventEntryInfo.h.

References a, b, operator==(), and edm::EventEntryInfo::write().

49  {
50  p.write(os);
51  return os;
52  }
std::ostream & edm::operator<< ( std::ostream &  os,
ProcessContext const &  pc 
)

Definition at line 33 of file ProcessContext.cc.

References edm::ProcessContext::isSubProcess(), edm::ProcessConfiguration::parameterSetID(), edm::ProcessContext::parentProcessContext(), edm::ProcessContext::processConfiguration(), and edm::ProcessConfiguration::processName().

33  {
34  os << "ProcessContext: ";
35  if(pc.processConfiguration()) {
36  os << pc.processConfiguration()->processName() << " " << pc.processConfiguration()->parameterSetID()<< "\n";
37  } else {
38  os << "invalid\n";
39  return os;
40  }
41  if(pc.isSubProcess()) {
42  os << " parent " << pc.parentProcessContext();
43  }
44  return os;
45  }
std::ostream & edm::operator<< ( std::ostream &  os,
PathContext const &  pc 
)

Definition at line 18 of file PathContext.cc.

References edm::PathContext::kEndPath, edm::PathContext::pathID(), edm::PathContext::pathName(), edm::PathContext::pathType(), and edm::PathContext::streamContext().

18  {
19  os << "PathContext: pathName = " << pc.pathName()
20  << " pathID = " << pc.pathID();
21  if(pc.pathType() == PathContext::PathType::kEndPath) {
22  os << " (EndPath)\n";
23  } else {
24  os << "\n";
25  }
26  if(pc.streamContext()) {
27  os << " " << *pc.streamContext();
28  }
29  return os;
30  }
std::ostream& edm::operator<< ( std::ostream &  os,
EventEntryDescription const &  p 
)
inline

Definition at line 53 of file EventEntryDescription.h.

References a, b, operator==(), and edm::EventEntryDescription::write().

53  {
54  p.write(os);
55  return os;
56  }
std::ostream& edm::operator<< ( std::ostream &  os,
ProductProvenance const &  p 
)
inline

Definition at line 59 of file ProductProvenance.h.

References a, b, operator==(), and edm::ProductProvenance::write().

59  {
60  p.write(os);
61  return os;
62  }
std::ostream & edm::operator<< ( std::ostream &  ost,
const MallocOpts opts 
)

Definition at line 26 of file MallocOpts.cc.

References edm::MallocOpts::mmap_max_, edm::MallocOpts::mmap_thr_, edm::MallocOpts::top_pad_, and edm::MallocOpts::trim_thr_.

27  {
28  ost << "mmap_max=" << opts.mmap_max_
29  << " trim_threshold=" << opts.trim_thr_
30  << " top_padding=" << opts.top_pad_
31  << " mmap_threshold=" << opts.mmap_thr_;
32  return ost;
33  }
std::ostream & edm::operator<< ( std::ostream &  os,
const ProductSelector gs 
)

Definition at line 122 of file ProductSelector.cc.

References edm::ProductSelector::print().

123  {
124  gs.print(os);
125  return os;
126  }
Definition: AbsArchive.cc:53
std::ostream & edm::operator<< ( std::ostream &  os,
ProductID const &  id 
)

Definition at line 7 of file ProductID.cc.

7  {
8  os << id.processIndex() << ":" << id.productIndex();
9  return os;
10  }
std::ostream & edm::operator<< ( std::ostream &  os,
TypeID const &  id 
)

Definition at line 131 of file TypeID.cc.

131  {
132  id.print(os);
133  return os;
134  }
std::ostream & edm::operator<< ( std::ostream &  oStream,
LuminosityBlockRange const &  iID 
)

Definition at line 46 of file LuminosityBlockRange.cc.

References edm::LuminosityBlockRange::endLumi(), edm::LuminosityBlockRange::endRun(), edm::LuminosityBlockRange::startLumi(), and edm::LuminosityBlockRange::startRun().

46  {
47  oStream << "'" << r.startRun() << ":" << r.startLumi() << "-"
48  << r.endRun() << ":" << r.endLumi() << "'" ;
49  return oStream;
50  }
std::ostream & edm::operator<< ( std::ostream &  oStream,
EventRange const &  iID 
)

Definition at line 27 of file EventRange.cc.

References edm::EventRange::endEvent(), edm::EventRange::endLumi(), edm::EventRange::endRun(), edm::EventRange::startEvent(), edm::EventRange::startLumi(), and edm::EventRange::startRun().

27  {
28  if (r.startLumi() == 0) {
29  oStream << "'" << r.startRun() << ":" << r.startEvent() << "-"
30  << r.endRun() << ":" << r.endEvent() << "'";
31  } else {
32  oStream << "'" << r.startRun() << ":" << r.startLumi() << ":" << r.startEvent() << "-"
33  << r.endRun() << ":" << r.endLumi() << ":" << r.endEvent() << "'";
34  }
35  return oStream;
36  }
std::ostream& edm::operator<< ( std::ostream &  os,
const RunAuxiliary p 
)
inline

Definition at line 68 of file RunAuxiliary.h.

References edm::RunAuxiliary::write().

68  {
69  p.write(os);
70  return os;
71  }
std::ostream& edm::operator<< ( std::ostream &  os,
Parentage const &  p 
)
inline

Definition at line 69 of file Parentage.h.

References a, b, operator==(), and edm::Parentage::write().

69  {
70  p.write(os);
71  return os;
72  }
std::ostream & edm::operator<< ( std::ostream &  os,
ParentContext const &  pc 
)

Definition at line 115 of file ParentContext.cc.

References edm::ParentContext::globalContext(), edm::ParentContext::internalContext(), edm::ParentContext::kGlobal, edm::ParentContext::kInternal, edm::ParentContext::kInvalid, edm::ParentContext::kModule, edm::ParentContext::kPlaceInPath, edm::ParentContext::kStream, edm::ParentContext::moduleCallingContext(), edm::ParentContext::placeInPathContext(), edm::ParentContext::streamContext(), and edm::ParentContext::type().

115  {
116  if(pc.type() == ParentContext::Type::kGlobal && pc.globalContext()) {
117  os << *pc.globalContext();
118  } else if (pc.type() == ParentContext::Type::kInternal && pc.internalContext()) {
119  os << *pc.internalContext();
120  } else if (pc.type() == ParentContext::Type::kModule && pc.moduleCallingContext()) {
121  os << *pc.moduleCallingContext();
122  } else if (pc.type() == ParentContext::Type::kPlaceInPath && pc.placeInPathContext()) {
123  os << *pc.placeInPathContext();
124  } else if (pc.type() == ParentContext::Type::kStream && pc.streamContext()) {
125  os << *pc.streamContext();
126  } else if (pc.type() == ParentContext::Type::kInvalid) {
127  os << "ParentContext invalid\n";
128  }
129  return os;
130  }
std::ostream & edm::operator<< ( std::ostream &  os,
BranchKey const &  bk 
)

Definition at line 19 of file BranchKey.cc.

References edm::BranchKey::friendlyClassName(), edm::BranchKey::moduleLabel(), edm::BranchKey::processName(), and edm::BranchKey::productInstanceName().

19  {
20  os << "BranchKey("
21  << bk.friendlyClassName() << ", "
22  << bk.moduleLabel() << ", "
23  << bk.productInstanceName() << ", "
24  << bk.processName() << ')';
25  return os;
26  }
std::ostream & edm::operator<< ( std::ostream &  ost,
InputTag const &  tag 
)

Definition at line 221 of file InputTag.cc.

References edm::InputTag::instance(), edm::InputTag::label(), edm::InputTag::process(), and AlCaHLTBitMon_QueryRunRegistry::string.

221  {
222  static std::string const process(", process = ");
223  ost << "InputTag: label = " << tag.label() << ", instance = " << tag.instance()
224  << (tag.process().empty() ? std::string() : (process + tag.process()));
225  return ost;
226  }
std::ostream & edm::operator<< ( std::ostream &  os,
GlobalContext const &  gc 
)

Definition at line 22 of file GlobalContext.cc.

References edm::GlobalContext::kBeginJob, edm::GlobalContext::kBeginLuminosityBlock, edm::GlobalContext::kBeginRun, edm::GlobalContext::kEndJob, edm::GlobalContext::kEndLuminosityBlock, edm::GlobalContext::kEndRun, edm::GlobalContext::kWriteLuminosityBlock, edm::GlobalContext::kWriteRun, edm::GlobalContext::luminosityBlockID(), edm::GlobalContext::luminosityBlockIndex(), edm::Timestamp::microsecondOffset(), edm::GlobalContext::processContext(), edm::GlobalContext::runIndex(), edm::GlobalContext::timestamp(), edm::GlobalContext::transition(), edm::Timestamp::unixTime(), edm::RunIndex::value(), and edm::LuminosityBlockIndex::value().

22  {
23  os << "GlobalContext: transition = ";
24  switch (gc.transition()) {
25  case GlobalContext::Transition::kBeginJob:
26  os << "BeginJob";
27  break;
28  case GlobalContext::Transition::kBeginRun:
29  os << "BeginRun";
30  break;
31  case GlobalContext::Transition::kBeginLuminosityBlock:
32  os << "BeginLuminosityBlock";
33  break;
34  case GlobalContext::Transition::kEndLuminosityBlock:
35  os << "EndLuminosityBlock";
36  break;
37  case GlobalContext::Transition::kEndRun:
38  os << "EndRun";
39  break;
40  case GlobalContext::Transition::kEndJob:
41  os << "EndJob";
42  break;
43  case GlobalContext::Transition::kWriteRun:
44  os << "WriteRun";
45  break;
46  case GlobalContext::Transition::kWriteLuminosityBlock:
47  os << "WriteLuminosityBlock";
48  break;
49  }
50  os << "\n " << gc.luminosityBlockID()
51  << "\n runIndex = " << gc.runIndex().value()
52  << " luminosityBlockIndex = " << gc.luminosityBlockIndex().value()
53  << " unixTime = " << gc.timestamp().unixTime()
54  << " microsecondOffset = " << gc.timestamp().microsecondOffset() <<"\n";
55  if(gc.processContext()) {
56  os << " " << *gc.processContext();
57  }
58  return os;
59  }
std::ostream& edm::operator<< ( std::ostream &  os,
const LuminosityBlockAuxiliary p 
)
inline

Definition at line 74 of file LuminosityBlockAuxiliary.h.

References edm::LuminosityBlockAuxiliary::write().

74  {
75  p.write(os);
76  return os;
77  }
std::ostream & edm::operator<< ( std::ostream &  t,
OStreamColumn const &  c 
)

Definition at line 17 of file OStreamColumn.cc.

References lumiQTWidget::t, edm::OStreamColumn::title_, and edm::OStreamColumn::width_.

18  {
19  t << std::setw(c.width_) << c.title_;
20  return t;
21  }
std::ostream& edm::operator<< ( std::ostream &  os,
StableProvenance const &  p 
)
inline

Definition at line 78 of file StableProvenance.h.

References a, b, operator==(), and edm::StableProvenance::write().

78  {
79  p.write(os);
80  return os;
81  }
template<typename E >
std::ostream& edm::operator<< ( std::ostream &  t,
OStreamColumnEntry< E > const &  ce 
)

Definition at line 79 of file OStreamColumn.h.

References edm::OStreamColumnEntry< T >::t.

80  {
81  t << std::setw(ce.col.width_) << ce.t;
82  return t;
83  }
std::ostream & edm::operator<< ( std::ostream &  os,
ProcessConfiguration const &  pc 
)

Definition at line 108 of file ProcessConfiguration.cc.

References edm::ProcessConfiguration::parameterSetID(), edm::ProcessConfiguration::passID(), edm::ProcessConfiguration::processName(), and edm::ProcessConfiguration::releaseVersion().

108  {
109  os << pc.processName() << ' '
110  << pc.parameterSetID() << ' '
111  << pc.releaseVersion() << ' '
112  << pc.passID();
113  return os;
114  }
std::ostream & edm::operator<< ( std::ostream &  os,
StreamContext const &  sc 
)

Definition at line 36 of file StreamContext.cc.

References edm::StreamContext::eventID(), edm::StreamContext::kBeginLuminosityBlock, edm::StreamContext::kBeginRun, edm::StreamContext::kBeginStream, edm::StreamContext::kEndLuminosityBlock, edm::StreamContext::kEndRun, edm::StreamContext::kEndStream, edm::StreamContext::kEvent, edm::StreamContext::kInvalid, edm::StreamContext::luminosityBlockIndex(), edm::Timestamp::microsecondOffset(), edm::StreamContext::processContext(), edm::StreamContext::runIndex(), edm::StreamContext::streamID(), edm::StreamContext::timestamp(), edm::StreamContext::transition(), edm::Timestamp::unixTime(), edm::RunIndex::value(), and edm::LuminosityBlockIndex::value().

36  {
37  os << "StreamContext: StreamID = " << sc.streamID()
38  << " transition = ";
39  switch (sc.transition()) {
41  os << "BeginStream";
42  break;
43  case StreamContext::Transition::kBeginRun:
44  os << "BeginRun";
45  break;
46  case StreamContext::Transition::kBeginLuminosityBlock:
47  os << "BeginLuminosityBlock";
48  break;
49  case StreamContext::Transition::kEvent:
50  os << "Event";
51  break;
52  case StreamContext::Transition::kEndLuminosityBlock:
53  os << "EndLuminosityBlock";
54  break;
55  case StreamContext::Transition::kEndRun:
56  os << "EndRun";
57  break;
59  os << "EndStream";
60  break;
61  case StreamContext::Transition::kInvalid:
62  os << "Invalid";
63  break;
64  }
65  os << "\n " << sc.eventID()
66  << "\n runIndex = " << sc.runIndex().value()
67  << " luminosityBlockIndex = " << sc.luminosityBlockIndex().value()
68  << " unixTime = " << sc.timestamp().unixTime()
69  << " microsecondOffset = " << sc.timestamp().microsecondOffset() <<"\n";
70  if(sc.processContext()) {
71  os << " " << *sc.processContext();
72  }
73  return os;
74  }
std::ostream & edm::operator<< ( std::ostream &  os,
ModuleCallingContext const &  mcc 
)

Definition at line 92 of file ModuleCallingContext.cc.

References edm::ModuleCallingContext::kInvalid, edm::ParentContext::kModule, edm::ModuleCallingContext::kPrefetching, edm::ModuleCallingContext::kRunning, edm::ModuleCallingContext::moduleCallingContext(), edm::ModuleCallingContext::moduleDescription(), edm::ModuleCallingContext::parent(), edm::ModuleCallingContext::previousModuleOnThread(), edm::ModuleCallingContext::state(), and edm::ModuleCallingContext::type().

92  {
93  os << "ModuleCallingContext state = ";
94  switch (mcc.state()) {
95  case ModuleCallingContext::State::kInvalid:
96  os << "Invalid";
97  break;
98  case ModuleCallingContext::State::kPrefetching:
99  os << "Prefetching";
100  break;
101  case ModuleCallingContext::State::kRunning:
102  os << "Running";
103  break;
104  }
105  os << "\n";
106  if(mcc.state() == ModuleCallingContext::State::kInvalid) {
107  return os;
108  }
109  if(mcc.moduleDescription()) {
110  os << " moduleDescription: " << *mcc.moduleDescription() << "\n";
111  }
112  os << " " << mcc.parent();
113  if(mcc.previousModuleOnThread()) {
114  if(mcc.type() == ParentContext::Type::kModule && mcc.moduleCallingContext() == mcc.previousModuleOnThread()) {
115  os << " previousModuleOnThread: same as parent module\n";
116  } else {
117  os << " previousModuleOnThread: " << *mcc.previousModuleOnThread();
118  }
119  }
120  return os;
121  }
std::ostream & edm::operator<< ( std::ostream &  oStream,
RunID const &  iID 
)

Definition at line 5 of file RunID.cc.

References edm::RunID::run().

5  {
6  oStream << "run: " << iID.run();
7  return oStream;
8  }
std::ostream& edm::operator<< ( std::ostream &  os,
Provenance const &  p 
)
inline

Definition at line 95 of file Provenance.h.

References a, b, operator==(), and edm::Provenance::write().

95  {
96  p.write(os);
97  return os;
98  }
std::ostream& edm::operator<< ( std::ostream &  os,
ModuleDescription const &  p 
)
inline

Definition at line 97 of file ModuleDescription.h.

References edm::ModuleDescription::write().

97  {
98  p.write(os);
99  return os;
100  }
std::ostream& edm::operator<< ( std::ostream &  os,
const EventAuxiliary p 
)
inline

Definition at line 102 of file EventAuxiliary.h.

References edm::EventAuxiliary::write().

102  {
103  p.write(os);
104  return os;
105  }
std::ostream& edm::operator<< ( std::ostream &  os,
ParameterSetEntry const &  psetEntry 
)

Definition at line 115 of file ParameterSetEntry.cc.

References edm::ParameterSetEntry::dump().

115  {
116  os << psetEntry.dump();
117  return os;
118  }
std::ostream& edm::operator<< ( std::ostream &  ost,
const HLTGlobalStatus hlt 
)
inline
std::ostream& edm::operator<< ( std::ostream &  os,
JobReport::RunReport const &  f 
)

Definition at line 119 of file JobReport.cc.

References print().

119  {
120  return print(os,f);
121  }
double f[11][100]
S & print(S &os, JobReport::RunReport const &rep)
Definition: JobReport.cc:95
template<class T >
ErrorObj& edm::operator<< ( ErrorObj e,
const T t 
)
inline
std::ostream & edm::operator<< ( std::ostream &  ost,
ProcessHistory const &  ph 
)

Definition at line 72 of file ProcessHistory.cc.

References copy_all().

72  {
73  ost << "Process History = ";
74  copy_all(ph, std::ostream_iterator<ProcessHistory::value_type>(ost,";"));
75  return ost;
76  }
Func copy_all(ForwardSequence &s, Func f)
wrappers for copy
Definition: Algorithms.h:24
ErrorObj & edm::operator<< ( ErrorObj e,
const char  s[] 
)

Definition at line 289 of file ErrorObj.cc.

References edm::ErrorObj::opltlt().

289  {
290  return e.opltlt(s);
291 }
std::ostream & edm::operator<< ( std::ostream &  oStream,
LuminosityBlockID const &  iID 
)

Definition at line 25 of file LuminosityBlockID.cc.

References edm::LuminosityBlockID::luminosityBlock(), and edm::LuminosityBlockID::run().

25  {
26  oStream<< "run: " << iID.run() << " luminosityBlock: " << iID.luminosityBlock();
27  return oStream;
28  }
std::ostream & edm::operator<< ( std::ostream &  oStream,
EventID const &  iID 
)

Definition at line 5 of file EventID.cc.

References edm::EventID::event(), edm::EventID::luminosityBlock(), and edm::EventID::run().

5  {
6  oStream << "run: " << iID.run() << " lumi: " << iID.luminosityBlock() << " event: " << iID.event();
7  return oStream;
8  }
std::ostream& edm::operator<< ( std::ostream &  os,
const edm::FileInPath fip 
)
inline

Definition at line 146 of file FileInPath.h.

References edm::FileInPath::write().

147  {
148  fip.write(os);
149  return os;
150  }
void write(std::ostream &os) const
Definition: FileInPath.cc:203
std::ostream& edm::operator<< ( std::ostream &  os,
VParameterSetEntry const &  vpsetEntry 
)

Definition at line 151 of file VParameterSetEntry.cc.

References edm::VParameterSetEntry::dump().

151  {
152  os << vpsetEntry.dump();
153  return os;
154  }
std::ostream & edm::operator<< ( std::ostream &  os,
TypeWithDict const &  id 
)

Definition at line 946 of file TypeWithDict.cc.

References edm::TypeWithDict::print().

946  {
947  ty.print(os);
948  return os;
949  }
std::ostream & edm::operator<< ( std::ostream &  os,
FileIndex const &  fileIndex 
)

Definition at line 211 of file FileIndex.cc.

References edm::FileIndex::begin(), edm::FileIndex::end(), edm::FileIndex::kEvent, edm::FileIndex::kLumi, and edm::FileIndex::kRun.

211  {
212 
213  os << "\nPrinting FileIndex contents. This includes a list of all Runs, LuminosityBlocks\n"
214  << "and Events stored in the root file.\n\n";
215  os << std::setw(15) << "Run"
216  << std::setw(15) << "Lumi"
217  << std::setw(15) << "Event"
218  << std::setw(15) << "TTree Entry"
219  << "\n";
220  for(std::vector<FileIndex::Element>::const_iterator it = fileIndex.begin(), itEnd = fileIndex.end(); it != itEnd; ++it) {
221  if(it->getEntryType() == FileIndex::kEvent) {
222  os << std::setw(15) << it->run_
223  << std::setw(15) << it ->lumi_
224  << std::setw(15) << it->event_
225  << std::setw(15) << it->entry_
226  << "\n";
227  }
228  else if(it->getEntryType() == FileIndex::kLumi) {
229  os << std::setw(15) << it->run_
230  << std::setw(15) << it ->lumi_
231  << std::setw(15) << " "
232  << std::setw(15) << it->entry_ << " (LuminosityBlock)"
233  << "\n";
234  }
235  else if(it->getEntryType() == FileIndex::kRun) {
236  os << std::setw(15) << it->run_
237  << std::setw(15) << " "
238  << std::setw(15) << " "
239  << std::setw(15) << it->entry_ << " (Run)"
240  << "\n";
241  }
242  }
243  return os;
244  }
std::ostream& edm::operator<< ( std::ostream &  os,
ProductResolverBase const &  phb 
)
inline

Definition at line 201 of file ProductResolverBase.h.

References edm::ProductResolverBase::write().

201  {
202  phb.write(os);
203  return os;
204  }
std::ostream& edm::operator<< ( std::ostream &  os,
ProductRegistry const &  pr 
)
inline

Definition at line 201 of file ProductRegistry.h.

References edm::ProductRegistry::print().

201  {
202  pr.print(os);
203  return os;
204  }
std::ostream& edm::operator<< ( std::ostream &  os,
BranchDescription const &  p 
)
inline
std::ostream& edm::operator<< ( std::ostream &  os,
const ELseverityLevel sev 
)

Definition at line 235 of file ELseverityLevel.cc.

References edm::ELseverityLevel::getName().

235  {
236  return os << " -" << sev.getName() << "- ";
237 }
template<int I>
std::ostream& edm::operator<< ( std::ostream &  os,
Hash< I > const &  h 
)
inline

Definition at line 249 of file Hash.h.

References h.

249  {
250  return h.print(os);
251  }
FWCore Framework interface EventSetupRecordImplementation h
Helper function to determine trigger accepts.
template<typename PROD >
std::ostream& edm::operator<< ( std::ostream &  os,
Handle< PROD > const &  h 
)
inline

Definition at line 276 of file PrincipalGetAdapter.h.

References h.

276  {
277  os << h.product() << " " << h.provenance() << " " << h.id();
278  return os;
279  }
template<typename C , typename T , typename F >
std::ostream& edm::operator<< ( std::ostream &  os,
RefVector< C, T, F > const &  r 
)

Definition at line 283 of file RefVector.h.

References MillePedeFileConverter_cfg::e, mps_fire::i, and alignCSCRings::r.

283  {
284  for(typename RefVector<C,T,F>::const_iterator
285  i = r.begin(),
286  e = r.end();
287  i != e;
288  ++i) {
289  os << *i << '\n';
290  }
291  return os;
292  }
std::ostream & edm::operator<< ( std::ostream &  os,
JobReport::InputFile const &  f 
)

Definition at line 113 of file JobReport.cc.

References print().

113  {
114  return print(os,f);
115  }
double f[11][100]
S & print(S &os, JobReport::RunReport const &rep)
Definition: JobReport.cc:95
std::ostream & edm::operator<< ( std::ostream &  os,
JobReport::OutputFile const &  f 
)

Definition at line 116 of file JobReport.cc.

References print().

116  {
117  return print(os,f);
118  }
double f[11][100]
S & print(S &os, JobReport::RunReport const &rep)
Definition: JobReport.cc:95
std::ostream& edm::operator<< ( std::ostream &  os,
ParameterSet const &  pset 
)

Definition at line 948 of file ParameterSet.cc.

References edm::ParameterSet::dump().

948  {
949  os << pset.dump();
950  return os;
951  }
std::ostream& edm::operator<< ( std::ostream &  os,
Entry const &  entry 
)

Definition at line 954 of file Entry.cc.

References MillePedeFileConverter_cfg::e, edm::Entry::getInt32(), edm::Entry::getPSet(), edm::Entry::getString(), edm::Entry::getUInt32(), edm::Entry::getVESInputTag(), edm::Entry::getVInputTag(), edm::Entry::getVPSet(), edm::Entry::getVString(), mps_fire::i, edm::Entry::isTracked(), kTVESInputTag, edm::Entry::rep, AlCaHLTBitMon_QueryRunRegistry::string, nano_cff::strings, edm::pset::TypeTrans::table_, and edm::Entry::typeCode().

954  {
955  os << sTypeTranslations.table_[entry.typeCode()] << " "
956  << (entry.isTracked() ? "tracked " : "untracked ") <<" = ";
957 
958  // now handle the difficult cases
959  switch(entry.typeCode()) {
960  case 'P': // ParameterSet
961  {
962  os << entry.getPSet();
963  break;
964  }
965  case 'p': // vector<ParameterSet>
966  {
967  // Make sure we get the representation of each contained
968  // ParameterSet including *only* tracked parameters
969  std::vector<ParameterSet> whole = entry.getVPSet();
970  std::vector<ParameterSet>::const_iterator i = whole.begin();
971  std::vector<ParameterSet>::const_iterator e = whole.end();
972  std::string start ="";
973  std::string const between(",\n");
974  os << "{"<<std::endl;
975  for (; i != e; ++i) {
976  os << start<< *i;
977  start = between;
978  }
979  if (!whole.empty()) {
980  os << std::endl;
981  }
982  os << "}";
983  break;
984  }
985  case 'S':
986  {
987  os << "'" << entry.getString() << "'";
988  break;
989  }
990  case 's':
991  {
992 
993  os << "{";
994  std::string start ="'";
995  std::string const between(",'");
996  std::vector<std::string> strings = entry.getVString();
997  for(std::vector<std::string>::const_iterator it = strings.begin(), itEnd = strings.end();
998  it != itEnd;
999  ++it) {
1000  os << start << *it << "'";
1001  start = between;
1002  }
1003  os << "}";
1004  break;
1005  }
1006  case 'I':
1007  {
1008  os << entry.getInt32();
1009  break;
1010  }
1011  case 'U':
1012  {
1013  os << entry.getUInt32();
1014  break;
1015  }
1016  case 'v':
1017  {
1018  //VInputTag needs to be treated seperately because it is encode like
1019  // vector<string> rather than using the individual encodings of each InputTag
1020  os << "{";
1021  std::string start = "";
1022  std::string const between(",");
1023  std::vector<InputTag> tags = entry.getVInputTag();
1024  for(std::vector<InputTag>::const_iterator it = tags.begin(), itEnd = tags.end();
1025  it != itEnd;
1026  ++it) {
1027  os << start << it->encode();
1028  start = between;
1029  }
1030  os << "}";
1031  break;
1032  }
1033  case kTVESInputTag:
1034  {
1035  //VESInputTag needs to be treated seperately because it is encode like
1036  // vector<string> rather than using the individual encodings of each ESInputTag
1037  os << "{";
1038  std::string start = "";
1039  std::string const between(",");
1040  std::vector<ESInputTag> tags = entry.getVESInputTag();
1041  for(std::vector<ESInputTag>::const_iterator it = tags.begin(), itEnd = tags.end();
1042  it != itEnd;
1043  ++it) {
1044  os << start << it->encode();
1045  start = between;
1046  }
1047  os << "}";
1048  break;
1049  }
1050  default:
1051  {
1052  os << entry.rep;
1053  break;
1054  }
1055  }
1056 
1057  return os;
1058  }
Definition: start.py:1
static TypeTrans const sTypeTranslations
bool edm::operator<= ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)
inline

Definition at line 147 of file FileIndex.h.

References mathSSE::lh.

147 {return !(rh < lh);}
bool int lh
Definition: SIMDVec.h:21
template<typename T >
bool edm::operator<= ( View< T > const &  lhs,
View< T > const &  rhs 
)
inline

Definition at line 376 of file View.h.

376  {
377  return !(rhs<lhs);
378  }
bool edm::operator<= ( ELseverityLevel const &  e1,
ELseverityLevel const &  e2 
)
bool edm::operator== ( FileID const &  lh,
FileID const &  rh 
)
inline

Definition at line 25 of file FileID.h.

References edm::FileID::fid().

25 {return lh.fid() == rh.fid();}
bool int lh
Definition: SIMDVec.h:21
bool edm::operator== ( RunLumiEntryInfo const &  a,
RunLumiEntryInfo const &  b 
)

Definition at line 21 of file RunLumiEntryInfo.cc.

References edm::RunLumiEntryInfo::branchID().

21  {
22  return a.branchID() == b.branchID();
23  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator== ( ProductID const &  lh,
ProductID const &  rh 
)
inline

Definition at line 54 of file ProductID.h.

References edm::ProductID::processIndex(), and edm::ProductID::productIndex().

54  {
55  return lh.processIndex() == rh.processIndex() && lh.productIndex() == rh.productIndex();
56  }
bool int lh
Definition: SIMDVec.h:21
bool edm::operator== ( EventEntryInfo const &  a,
EventEntryInfo const &  b 
)

Definition at line 25 of file EventEntryInfo.cc.

References edm::EventEntryInfo::branchID(), edm::EventEntryInfo::entryDescriptionID(), and edm::EventEntryInfo::productID().

25  {
26  return
27  a.branchID() == b.branchID()
28  && a.productID() == b.productID()
29  && a.entryDescriptionID() == b.entryDescriptionID();
30  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator== ( EventEntryDescription const &  a,
EventEntryDescription const &  b 
)

Definition at line 43 of file EventEntryDescription.cc.

References edm::EventEntryDescription::parents().

43  {
44  return
45  a.parents() == b.parents();
46  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator== ( BranchKey const &  a,
BranchKey const &  b 
)
inline

Definition at line 60 of file BranchKey.h.

References a.

60  {
61  return !(a < b || b < a);
62  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator== ( ProductProvenance const &  a,
ProductProvenance const &  b 
)

Definition at line 72 of file ProductProvenance.cc.

References edm::ProductProvenance::branchID(), and edm::ProductProvenance::parentageID().

72  {
73  return
74  a.branchID() == b.branchID() && a.parentageID() == b.parentageID();
75  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator== ( ProcessConfiguration const &  a,
ProcessConfiguration const &  b 
)
inline

Definition at line 71 of file ProcessConfiguration.h.

References edm::ProcessConfiguration::parameterSetID(), edm::ProcessConfiguration::passID(), edm::ProcessConfiguration::processName(), and edm::ProcessConfiguration::releaseVersion().

71  {
72  return a.processName() == b.processName() &&
73  a.parameterSetID() == b.parameterSetID() &&
74  a.releaseVersion() == b.releaseVersion() &&
75  a.passID() == b.passID();
76  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<class X , class Y >
bool edm::operator== ( debugging_allocator< X > const &  ,
debugging_allocator< Y > const &   
)
noexcept
bool edm::operator== ( Parentage const &  a,
Parentage const &  b 
)

Definition at line 42 of file Parentage.cc.

References edm::Parentage::parents().

42  {
43  return a.parents() == b.parents();
44  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator== ( StableProvenance const &  a,
StableProvenance const &  b 
)

Definition at line 41 of file StableProvenance.cc.

References edm::StableProvenance::branchDescription().

41  {
42  return a.branchDescription() == b.branchDescription();
43  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<class T >
bool edm::operator== ( RefToBaseVector< T > const &  a,
RefToBaseVector< T > const &  b 
)
inline

Definition at line 97 of file RefToBaseVector.h.

References edm::RefToBaseVector< T >::begin(), edm::RefToBaseVector< T >::end(), cond::serialization::equal(), edm::RefToBaseVector< T >::isInvalid(), and edm::RefToBaseVector< T >::size().

99  {
100  if ( a.isInvalid() && b.isInvalid() ) return true;
101  if ( a.isInvalid() || b.isInvalid() ) return false;
102  return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
103  }
bool equal(const T &first, const T &second)
Definition: Equal.h:34
bool edm::operator== ( Provenance const &  a,
Provenance const &  b 
)

Definition at line 49 of file Provenance.cc.

References edm::Provenance::stable().

49  {
50  return a.stable() == b.stable();
51  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator== ( ProcessHistory const &  a,
ProcessHistory const &  b 
)
inline

Definition at line 102 of file ProcessHistory.h.

References edm::ProcessHistory::data().

102  {
103  return a.data() == b.data();
104  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T >
bool edm::operator== ( FwdPtr< T > const &  lhs,
FwdPtr< T > const &  rhs 
)
inline

Definition at line 135 of file FwdPtr.h.

135  {
136  return (lhs.ptr() == rhs.ptr() ||
137  lhs.backPtr() == rhs.ptr() ||
138  lhs.ptr() == rhs.backPtr() ||
139  lhs.backPtr() == rhs.backPtr());
140  }
bool edm::operator== ( TypeWithDict const &  a,
TypeWithDict const &  b 
)

Definition at line 932 of file TypeWithDict.cc.

References edm::TypeWithDict::name().

932  {
933  return a.name() == b.name();
934  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator== ( RefCore const &  lhs,
RefCore const &  rhs 
)
inline

Definition at line 139 of file RefCore.h.

References edm::RefCore::id(), edm::RefCore::isTransient(), and edm::RefCore::productPtr().

139  {
140  return lhs.isTransient() == rhs.isTransient() && (lhs.isTransient() ? lhs.productPtr() == rhs.productPtr() : lhs.id() == rhs.id());
141  }
template<typename KEY >
bool edm::operator== ( RefVectorBase< KEY > const &  lhs,
RefVectorBase< KEY > const &  rhs 
)

Equality operator.

Definition at line 139 of file RefVectorBase.h.

References edm::RefVectorBase< KEY >::keys(), and edm::RefVectorBase< KEY >::refCore().

139  {
140  return lhs.refCore() == rhs.refCore() && lhs.keys() == rhs.keys();
141  }
bool edm::operator== ( TypeWithDict const &  a,
std::type_info const &  b 
)

Definition at line 937 of file TypeWithDict.cc.

References b, edm::TypeID::className(), edm::TypeWithDict::isArray(), edm::TypeWithDict::isPointer(), edm::TypeWithDict::name(), and edm::TypeWithDict::ti_.

937  {
938  if(*a.ti_ == typeid(TypeWithDict::dummyType) || a.isPointer() || a.isArray()) {
939  // No accurate type_info
940  return a.name() == TypeID(b).className();
941  }
942  return *a.ti_ == b;
943  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T >
bool edm::operator== ( View< T > const &  lhs,
View< T > const &  rhs 
)
inline

Definition at line 352 of file View.h.

References cond::serialization::equal().

352  {
353  return
354  lhs.size() == rhs.size() &&
355  std::equal(lhs.begin(), lhs.end(), rhs.begin());
356  }
bool equal(const T &first, const T &second)
Definition: Equal.h:34
bool edm::operator== ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)
inline

Definition at line 150 of file FileIndex.h.

References mathSSE::lh.

150 {return !(lh < rh || rh < lh);}
bool int lh
Definition: SIMDVec.h:21
bool edm::operator== ( std::type_info const &  a,
TypeWithDict const &  b 
)
inline

Definition at line 150 of file TypeWithDict.h.

References a.

150  {
151  return b == a;
152 }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator== ( edm::FileInPath const &  a,
edm::FileInPath const &  b 
)
inline

Definition at line 160 of file FileInPath.h.

References edm::FileInPath::location(), and edm::FileInPath::relativePath().

162  {
163  return a.location() == b.location() && a.relativePath() == b.relativePath();
164  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T >
bool edm::operator== ( RefToBaseProd< T > const &  lhs,
RefToBaseProd< T > const &  rhs 
)
inline

Definition at line 172 of file RefToBaseProd.h.

172  {
173  return lhs.refCore() == rhs.refCore();
174  }
template<typename T , typename U >
bool edm::operator== ( atomic_value_ptr< T > const &  lhs,
U const &  rhs 
)
inline

Definition at line 183 of file atomic_value_ptr.h.

References edm::atomic_value_ptr< T >::this_type_does_not_support_comparisons().

183  {
184  lhs.this_type_does_not_support_comparisons();
185  return false;
186  }
bool edm::operator== ( ProductRegistry const &  a,
ProductRegistry const &  b 
)
inline

Definition at line 189 of file ProductRegistry.h.

References edm::ProductRegistry::productList().

189  {
190  return a.productList() == b.productList();
191  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T , typename U >
bool edm::operator== ( U const &  lhs,
atomic_value_ptr< T > const &  rhs 
)
inline

Definition at line 195 of file atomic_value_ptr.h.

References edm::atomic_value_ptr< T >::this_type_does_not_support_comparisons().

195  {
196  rhs.this_type_does_not_support_comparisons();
197  return false;
198  }
template<typename C >
bool edm::operator== ( RefProd< C > const &  lhs,
RefProd< C > const &  rhs 
)
inline

Definition at line 197 of file RefProd.h.

197  {
198  return lhs.refCore() == rhs.refCore();
199  }
bool edm::operator== ( Entry const &  a,
Entry const &  b 
)
inline

Definition at line 200 of file Entry.h.

References edm::Entry::toString().

200  {
201  return a.toString() == b.toString();
202  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator== ( ELseverityLevel const &  e1,
ELseverityLevel const &  e2 
)
template<typename T , typename U >
bool edm::operator== ( value_ptr< T > const &  lhs,
U const &  rhs 
)
inline

Definition at line 207 of file value_ptr.h.

References edm::value_ptr< T >::this_type_does_not_support_comparisons().

207  {
208  lhs.this_type_does_not_support_comparisons();
209  return false;
210  }
template<typename T , typename U >
bool edm::operator== ( U const &  lhs,
value_ptr< T > const &  rhs 
)
inline

Definition at line 219 of file value_ptr.h.

References edm::value_ptr< T >::this_type_does_not_support_comparisons().

219  {
220  rhs.this_type_does_not_support_comparisons();
221  return false;
222  }
bool edm::operator== ( BranchDescription const &  a,
BranchDescription const &  b 
)

Definition at line 322 of file BranchDescription.cc.

References edm::BranchDescription::branchAliases(), combinable(), edm::BranchDescription::dropped(), and AlCaHLTBitMon_QueryRunRegistry::string.

322  {
323  return combinable(a, b) &&
324  (a.dropped() == b.dropped()) &&
325  (a.branchAliases() == b.branchAliases());
326  }
bool combinable(BranchDescription const &a, BranchDescription const &b)
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename C , typename T , typename F >
bool edm::operator== ( RefVector< C, T, F > const &  lhs,
RefVector< C, T, F > const &  rhs 
)
inline

Definition at line 225 of file RefVector.h.

225  {
226  return lhs.refVector() == rhs.refVector();
227  }
template<typename C , typename T , typename F >
bool edm::operator== ( FwdRef< C, T, F > const &  lhs,
FwdRef< C, T, F > const &  rhs 
)
inline

for two FwdRefs to be equal, both the "forward" and the "backward" Refs must be the same

Definition at line 241 of file FwdRef.h.

References edm::FwdRef< C, T, F >::backRef(), and edm::FwdRef< C, T, F >::ref().

241  {
242  return
243  (lhs.ref() == rhs.ref() ) &&
244  (lhs.backRef() == rhs.backRef() )
245  ;
246  }
template<typename C , typename T , typename F >
bool edm::operator== ( Ref< C, T, F > const &  lhs,
FwdRef< C, T, F > const &  rhs 
)
inline

for a FwdRef to equal a Ref, EITHER the "forward" or the "backward" Refs must equal to the test ref

Definition at line 253 of file FwdRef.h.

References edm::FwdRef< C, T, F >::backRef(), and edm::FwdRef< C, T, F >::ref().

253  {
254  return
255  (lhs == rhs.ref() ) ||
256  (lhs == rhs.backRef() )
257  ;
258  }
template<typename C , typename T , typename F >
bool edm::operator== ( FwdRef< C, T, F > const &  lhs,
Ref< C, T, F > const &  rhs 
)
inline

for a FwdRef to equal a Ref, EITHER the "forward" or the "backward" Refs must equal to the test ref

Definition at line 265 of file FwdRef.h.

References edm::FwdRef< C, T, F >::backRef(), and edm::FwdRef< C, T, F >::ref().

265  {
266  return
267  (lhs.ref() == rhs ) ||
268  (lhs.backRef() == rhs )
269  ;
270  }
template<typename T >
bool edm::operator== ( Ptr< T > const &  lhs,
Ptr< T > const &  rhs 
)
inline

Definition at line 266 of file Ptr.h.

266  {
267  return lhs.refCore() == rhs.refCore() && lhs.key() == rhs.key();
268  }
bool edm::operator== ( ParameterSet const &  a,
ParameterSet const &  b 
)

Definition at line 861 of file ParameterSet.cc.

References edm::ParameterSet::id(), edm::ParameterSet::isRegistered(), isTransientEqual(), and edm::ParameterSet::trackedPart().

861  {
862  if(a.isRegistered() && b.isRegistered()) {
863  return (a.id() == b.id());
864  }
865  return isTransientEqual(a.trackedPart(), b.trackedPart());
866  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool isTransientEqual(ParameterSet const &a, ParameterSet const &b)
template<typename T , typename SORT , typename ALLOC >
bool edm::operator== ( SortedCollection< T, SORT > const &  c,
std::vector< T, ALLOC > const &  v 
)
inline

Definition at line 428 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::begin(), cond::serialization::equal(), and edm::SortedCollection< T, SORT >::size().

429  {
430  return c.size() == v.size() && std::equal(v.begin(), v.end(), c.begin());
431  }
bool equal(const T &first, const T &second)
Definition: Equal.h:34
template<typename T , typename SORT >
bool edm::operator== ( SortedCollection< T, SORT > const &  a,
SortedCollection< T, SORT > const &  b 
)
inline

Definition at line 440 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), cond::serialization::equal(), and edm::SortedCollection< T, SORT >::size().

441  {
442  return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
443  }
bool equal(const T &first, const T &second)
Definition: Equal.h:34
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename C , typename T , typename F >
bool edm::operator== ( Ref< C, T, F > const &  lhs,
Ref< C, T, F > const &  rhs 
)
inline

Definition at line 625 of file Ref.h.

625  {
626  return lhs.key() == rhs.key() && lhs.refCore() == rhs.refCore() ;
627  }
bool edm::operator> ( TypeID const &  a,
TypeID const &  b 
)
inline

Definition at line 57 of file TypeID.h.

References a.

57  {
58  return b < a;
59  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
bool edm::operator> ( const TypeIDBase a,
const TypeIDBase b 
)
inline

Definition at line 71 of file TypeIDBase.h.

References a.

72  { return b<a; }
double a
Definition: hdecay.h:121
bool edm::operator> ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)
inline

Definition at line 141 of file FileIndex.h.

References mathSSE::lh.

141 {return rh < lh;}
bool int lh
Definition: SIMDVec.h:21
template<typename T >
bool edm::operator> ( View< T > const &  lhs,
View< T > const &  rhs 
)
inline

Definition at line 382 of file View.h.

382  {
383  return rhs<lhs;
384  }
bool edm::operator> ( ELseverityLevel const &  e1,
ELseverityLevel const &  e2 
)
bool edm::operator>= ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)
inline

Definition at line 144 of file FileIndex.h.

144 {return !(lh < rh);}
bool int lh
Definition: SIMDVec.h:21
template<typename T >
bool edm::operator>= ( View< T > const &  lhs,
View< T > const &  rhs 
)
inline

Definition at line 388 of file View.h.

388  {
389  return !(lhs<rhs);
390  }
bool edm::operator>= ( ELseverityLevel const &  e1,
ELseverityLevel const &  e2 
)
std::istream& edm::operator>> ( std::istream &  is,
FileInPath fip 
)
inline

Definition at line 153 of file FileInPath.h.

References edm::FileInPath::read().

Referenced by edm::value_ptr_traits< ParameterDescriptionNode >::destroy().

154  {
155  fip.read(is);
156  return is;
157  }
std::unique_ptr< ParameterDescriptionCases< bool > > edm::operator>> ( bool  caseValue,
ParameterDescriptionNode const &  node 
)

Definition at line 138 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone(), and eostools::move().

139  {
140  std::unique_ptr<ParameterDescriptionNode> clonedNode(node.clone());
141  return caseValue >> std::move(clonedNode);
142  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionCases< int > > edm::operator>> ( int  caseValue,
ParameterDescriptionNode const &  node 
)

Definition at line 145 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone(), and eostools::move().

146  {
147  std::unique_ptr<ParameterDescriptionNode> clonedNode(node.clone());
148  return caseValue >> std::move(clonedNode);
149  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>> ( std::string const &  caseValue,
ParameterDescriptionNode const &  node 
)

Definition at line 152 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone(), and eostools::move().

153  {
154  std::unique_ptr<ParameterDescriptionNode> clonedNode(node.clone());
155  return caseValue >> std::move(clonedNode);
156  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>> ( char const *  caseValue,
ParameterDescriptionNode const &  node 
)

Definition at line 159 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone(), and eostools::move().

160  {
161  std::unique_ptr<ParameterDescriptionNode> clonedNode(node.clone());
162  return caseValue >> std::move(clonedNode);
163  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionCases< bool > > edm::operator>> ( bool  caseValue,
std::unique_ptr< ParameterDescriptionNode node 
)

Definition at line 166 of file ParameterDescriptionNode.cc.

References eostools::move().

167  {
168  return std::unique_ptr<ParameterDescriptionCases<bool>>(
169  new ParameterDescriptionCases<bool>(caseValue, std::move(node)));
170  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionCases< int > > edm::operator>> ( int  caseValue,
std::unique_ptr< ParameterDescriptionNode node 
)

Definition at line 173 of file ParameterDescriptionNode.cc.

References eostools::move().

174  {
175  return std::unique_ptr<ParameterDescriptionCases<int>>(
176  new ParameterDescriptionCases<int>(caseValue, std::move(node)));
177  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>> ( std::string const &  caseValue,
std::unique_ptr< ParameterDescriptionNode node 
)

Definition at line 180 of file ParameterDescriptionNode.cc.

References eostools::move().

181  {
182  return std::unique_ptr<ParameterDescriptionCases<std::string>>(
183  new ParameterDescriptionCases<std::string>(caseValue, std::move(node)));
184  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>> ( char const *  caseValue,
std::unique_ptr< ParameterDescriptionNode node 
)

Definition at line 187 of file ParameterDescriptionNode.cc.

References eostools::move(), and AlCaHLTBitMon_QueryRunRegistry::string.

188  {
189  std::string caseValueString(caseValue);
190  return std::unique_ptr<ParameterDescriptionCases<std::string>>(
191  new ParameterDescriptionCases<std::string>(caseValue, std::move(node)));
192  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionNode > edm::operator^ ( ParameterDescriptionNode const &  node_left,
ParameterDescriptionNode const &  node_right 
)

Definition at line 249 of file ParameterDescriptionNode.cc.

Referenced by edm::value_ptr_traits< ParameterDescriptionNode >::destroy().

250  {
251  return std::make_unique<XORGroupDescription>(node_left, node_right);
252  }
std::unique_ptr< ParameterDescriptionNode > edm::operator^ ( std::unique_ptr< ParameterDescriptionNode node_left,
ParameterDescriptionNode const &  node_right 
)

Definition at line 255 of file ParameterDescriptionNode.cc.

References eostools::move().

256  {
257  return std::make_unique<XORGroupDescription>(std::move(node_left), node_right);
258  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionNode > edm::operator^ ( ParameterDescriptionNode const &  node_left,
std::unique_ptr< ParameterDescriptionNode node_right 
)

Definition at line 261 of file ParameterDescriptionNode.cc.

References eostools::move().

262  {
263  return std::make_unique<XORGroupDescription>(node_left, std::move(node_right));
264  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionNode > edm::operator^ ( std::unique_ptr< ParameterDescriptionNode node_left,
std::unique_ptr< ParameterDescriptionNode node_right 
)

Definition at line 267 of file ParameterDescriptionNode.cc.

References eostools::move().

268  {
269  return std::make_unique<XORGroupDescription>(std::move(node_left), std::move(node_right));
270  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionCases< bool > > edm::operator|| ( std::unique_ptr< ParameterDescriptionCases< bool > >  left,
std::unique_ptr< ParameterDescriptionCases< bool > >  right 
)

Definition at line 8 of file ParameterDescriptionCases.cc.

References genParticles_cff::map, and eostools::move().

Referenced by edm::value_ptr_traits< ParameterDescriptionNode >::destroy().

9  {
10 
11  std::unique_ptr<std::map<bool, edm::value_ptr<ParameterDescriptionNode> > > rightCases = right->caseMap();
12  for (std::map<bool, edm::value_ptr<ParameterDescriptionNode> >::const_iterator iter = rightCases->begin(),
13  iEnd = rightCases->end();
14  iter != iEnd; ++iter) {
15  bool caseValue = iter->first;
16  std::unique_ptr<ParameterDescriptionNode> node(iter->second->clone());
17  left->insert(caseValue, std::move(node));
18  }
19  return left;
20  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionCases< int > > edm::operator|| ( std::unique_ptr< ParameterDescriptionCases< int > >  left,
std::unique_ptr< ParameterDescriptionCases< int > >  right 
)

Definition at line 23 of file ParameterDescriptionCases.cc.

References genParticles_cff::map, and eostools::move().

24  {
25 
26  std::unique_ptr<std::map<int, edm::value_ptr<ParameterDescriptionNode> > > rightCases = right->caseMap();
27  for (std::map<int, edm::value_ptr<ParameterDescriptionNode> >::const_iterator iter = rightCases->begin(),
28  iEnd = rightCases->end();
29  iter != iEnd; ++iter) {
30  int caseValue = iter->first;
31  std::unique_ptr<ParameterDescriptionNode> node(iter->second->clone());
32  left->insert(caseValue, std::move(node));
33  }
34  return left;
35  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator|| ( std::unique_ptr< ParameterDescriptionCases< std::string > >  left,
std::unique_ptr< ParameterDescriptionCases< std::string > >  right 
)

Definition at line 38 of file ParameterDescriptionCases.cc.

References genParticles_cff::map, eostools::move(), and AlCaHLTBitMon_QueryRunRegistry::string.

39  {
40 
41  std::unique_ptr<std::map<std::string, edm::value_ptr<ParameterDescriptionNode> > > rightCases = right->caseMap();
42  for (std::map<std::string, edm::value_ptr<ParameterDescriptionNode> >::const_iterator iter = rightCases->begin(),
43  iEnd = rightCases->end();
44  iter != iEnd; ++iter) {
45  std::string caseValue = iter->first;
46  std::unique_ptr<ParameterDescriptionNode> node(iter->second->clone());
47  left->insert(caseValue, std::move(node));
48  }
49  return left;
50  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionNode > edm::operator|| ( ParameterDescriptionNode const &  node_left,
ParameterDescriptionNode const &  node_right 
)

Definition at line 223 of file ParameterDescriptionNode.cc.

224  {
225  return std::make_unique<ORGroupDescription>(node_left, node_right);
226  }
std::unique_ptr< ParameterDescriptionNode > edm::operator|| ( std::unique_ptr< ParameterDescriptionNode node_left,
ParameterDescriptionNode const &  node_right 
)

Definition at line 229 of file ParameterDescriptionNode.cc.

References eostools::move().

230  {
231  return std::make_unique<ORGroupDescription>(std::move(node_left), node_right);
232  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionNode > edm::operator|| ( ParameterDescriptionNode const &  node_left,
std::unique_ptr< ParameterDescriptionNode node_right 
)

Definition at line 235 of file ParameterDescriptionNode.cc.

References eostools::move().

236  {
237  return std::make_unique<ORGroupDescription>(node_left, std::move(node_right));
238  }
def move(src, dest)
Definition: eostools.py:510
std::unique_ptr< ParameterDescriptionNode > edm::operator|| ( std::unique_ptr< ParameterDescriptionNode node_left,
std::unique_ptr< ParameterDescriptionNode node_right 
)

Definition at line 241 of file ParameterDescriptionNode.cc.

References eostools::move().

242  {
243  return std::make_unique<ORGroupDescription>(std::move(node_left), std::move(node_right));
244  }
def move(src, dest)
Definition: eostools.py:510
static std::atomic<int> edm::ourSerial ( )
static

Referenced by edm::ErrorObj::set().

bool edm::overlaps ( LuminosityBlockRange const &  lh,
LuminosityBlockRange const &  rh 
)

Definition at line 66 of file LuminosityBlockRange.cc.

References distinct().

66  {
67  return !distinct(lh, rh);
68  }
bool int lh
Definition: SIMDVec.h:21
bool distinct(EventRange const &lh, EventRange const &rh)
Definition: EventRange.cc:72
bool edm::overlaps ( EventRange const &  lh,
EventRange const &  rh 
)

Definition at line 54 of file EventRange.cc.

References distinct(), and edm::EventRange::startLumi().

Referenced by distinct(), and merge().

54  {
55  assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
56  return !distinct(lh, rh);
57  }
bool int lh
Definition: SIMDVec.h:21
bool distinct(EventRange const &lh, EventRange const &rh)
Definition: EventRange.cc:72
ParameterSet const & edm::parameterSet ( Provenance const &  provenance)

Definition at line 11 of file Provenance.cc.

References edm::ParameterSet::existsAs(), edm::pset::Registry::getMapped(), edm::ParameterSet::getParameterSet(), edm::Provenance::getProcessConfiguration(), edm::pset::Registry::instance(), diffTwoXMLs::label, edm::Provenance::moduleLabel(), edm::ProcessConfiguration::parameterSetID(), source(), AlCaHLTBitMon_QueryRunRegistry::string, and triggerResults().

Referenced by edm::ScheduleItems::addCPRandTNS(), GsfElectronProducer::beginEvent(), GsfElectronBaseProducer::beginEvent(), fwlite::ChainEvent::event(), edm::EventProcessor::EventProcessor(), EcalSelectiveReadoutProducer::getBinOfMax(), edm::Event::getRefBeforePut(), fwlite::Event::getTFile(), edm::EventProcessor::init(), edm::ScheduleItems::initSchedule(), moduleName(), OniaVtxReProducer::OniaVtxReProducer(), PFCandidateDQMAnalyzer::PFCandidateDQMAnalyzer(), PFJetDQMAnalyzer::PFJetDQMAnalyzer(), PFMETDQMAnalyzer::PFMETDQMAnalyzer(), PFMuonDQMAnalyzer::PFMuonDQMAnalyzer(), DeepFlavourTagInfoProducer::produce(), PythonProcessDesc::pset(), and fwlite::MultiChainEvent::secondaryFileIndex().

11  {
12  ProcessConfiguration pc;
13  provenance.getProcessConfiguration(pc);
14  ParameterSet const& processParameterSet = *pset::Registry::instance()->getMapped(pc.parameterSetID());
15  std::string const& label = provenance.moduleLabel();
16  if (!processParameterSet.existsAs<ParameterSet>(label)) {
17  // Trigger results and input sources are special cases
18  if(label == triggerResults) {
19  return processParameterSet.getParameterSet("@trigger_paths");
20  } else if(label == source) {
21  return processParameterSet.getParameterSet("@main_input");
22  }
23  }
24  return processParameterSet.getParameterSet(label);
25  }
static PFTauRenderPlugin instance
static std::string const triggerResults
Definition: EdmProvDump.cc:41
static std::string const source
Definition: EdmProvDump.cc:43
template<>
std::string edm::ParameterSet::getParameter< std::string > ( std::string const &  name) const

Definition at line 1068 of file ParameterSet.cc.

References edm::Entry::getString(), dataset::name, and edm::ParameterSet::retrieve().

1068  {
1069  return retrieve(name).getString();
1070  }
template<>
std::string edm::ParameterSet::getParameter< std::string > ( char const *  name) const

Definition at line 1698 of file ParameterSet.cc.

References edm::Entry::getString(), and edm::ParameterSet::retrieve().

1698  {
1699  return retrieve(name).getString();
1700  }
template<>
std::vector<double> edm::ParameterSet::getParameter< std::vector< double > > ( std::string const &  name) const

Definition at line 1059 of file ParameterSet.cc.

References edm::Entry::getVDouble(), dataset::name, edm::ParameterSet::retrieve(), and AlCaHLTBitMon_QueryRunRegistry::string.

1059  {
1060  return retrieve(name).getVDouble();
1061  }
template<>
std::vector<double> edm::ParameterSet::getParameter< std::vector< double > > ( char const *  name) const

Definition at line 1689 of file ParameterSet.cc.

References edm::Entry::getVDouble(), edm::ParameterSet::retrieve(), and AlCaHLTBitMon_QueryRunRegistry::string.

1689  {
1690  return retrieve(name).getVDouble();
1691  }
template<>
std::vector<ESInputTag> edm::ParameterSet::getParameter< std::vector< ESInputTag > > ( std::string const &  name) const

Definition at line 1130 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), dataset::name, and edm::ParameterSet::retrieve().

1130  {
1131  return retrieve(name).getVESInputTag();
1132  }
template<>
std::vector<ESInputTag> edm::ParameterSet::getParameter< std::vector< ESInputTag > > ( char const *  name) const

Definition at line 1759 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), and edm::ParameterSet::retrieve().

1759  {
1760  return retrieve(name).getVESInputTag();
1761  }
template<>
std::vector<EventID> edm::ParameterSet::getParameter< std::vector< EventID > > ( std::string const &  name) const

Definition at line 1148 of file ParameterSet.cc.

References edm::Entry::getVEventID(), dataset::name, and edm::ParameterSet::retrieve().

1148  {
1149  return retrieve(name).getVEventID();
1150  }
template<>
std::vector<EventID> edm::ParameterSet::getParameter< std::vector< EventID > > ( char const *  name) const

Definition at line 1778 of file ParameterSet.cc.

References edm::Entry::getVEventID(), and edm::ParameterSet::retrieve().

1778  {
1779  return retrieve(name).getVEventID();
1780  }
template<>
std::vector<EventRange> edm::ParameterSet::getParameter< std::vector< EventRange > > ( std::string const &  name) const

Definition at line 1184 of file ParameterSet.cc.

References edm::Entry::getVEventRange(), dataset::name, and edm::ParameterSet::retrieve().

1184  {
1185  return retrieve(name).getVEventRange();
1186  }
template<>
std::vector<EventRange> edm::ParameterSet::getParameter< std::vector< EventRange > > ( char const *  name) const

Definition at line 1814 of file ParameterSet.cc.

References edm::Entry::getVEventRange(), and edm::ParameterSet::retrieve().

1814  {
1815  return retrieve(name).getVEventRange();
1816  }
template<>
std::vector<InputTag> edm::ParameterSet::getParameter< std::vector< InputTag > > ( std::string const &  name) const

Definition at line 1112 of file ParameterSet.cc.

References edm::Entry::getVInputTag(), dataset::name, and edm::ParameterSet::retrieve().

1112  {
1113  return retrieve(name).getVInputTag();
1114  }
template<>
std::vector<InputTag> edm::ParameterSet::getParameter< std::vector< InputTag > > ( char const *  name) const

Definition at line 1741 of file ParameterSet.cc.

References edm::Entry::getVInputTag(), and edm::ParameterSet::retrieve().

1741  {
1742  return retrieve(name).getVInputTag();
1743  }
template<>
std::vector<int> edm::ParameterSet::getParameter< std::vector< int > > ( std::string const &  name) const

Definition at line 999 of file ParameterSet.cc.

References edm::Entry::getVInt32(), dataset::name, and edm::ParameterSet::retrieve().

999  {
1000  return retrieve(name).getVInt32();
1001  }
template<>
std::vector<int> edm::ParameterSet::getParameter< std::vector< int > > ( char const *  name) const

Definition at line 1629 of file ParameterSet.cc.

References edm::Entry::getVInt32(), and edm::ParameterSet::retrieve().

1629  {
1630  return retrieve(name).getVInt32();
1631  }
template<>
std::vector<long long> edm::ParameterSet::getParameter< std::vector< long long > > ( std::string const &  name) const

Definition at line 1014 of file ParameterSet.cc.

References edm::Entry::getVInt64(), dataset::name, and edm::ParameterSet::retrieve().

1014  {
1015  return retrieve(name).getVInt64();
1016  }
template<>
std::vector<long long> edm::ParameterSet::getParameter< std::vector< long long > > ( char const *  name) const

Definition at line 1644 of file ParameterSet.cc.

References edm::Entry::getVInt64(), and edm::ParameterSet::retrieve().

1644  {
1645  return retrieve(name).getVInt64();
1646  }
template<>
std::vector<LuminosityBlockID> edm::ParameterSet::getParameter< std::vector< LuminosityBlockID > > ( std::string const &  name) const

Definition at line 1166 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockID(), dataset::name, and edm::ParameterSet::retrieve().

1166  {
1167  return retrieve(name).getVLuminosityBlockID();
1168  }
template<>
std::vector<LuminosityBlockID> edm::ParameterSet::getParameter< std::vector< LuminosityBlockID > > ( char const *  name) const

Definition at line 1796 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockID(), and edm::ParameterSet::retrieve().

1796  {
1797  return retrieve(name).getVLuminosityBlockID();
1798  }
template<>
std::vector<LuminosityBlockRange> edm::ParameterSet::getParameter< std::vector< LuminosityBlockRange > > ( std::string const &  name) const

Definition at line 1202 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockRange(), dataset::name, and edm::ParameterSet::retrieve().

1202  {
1203  return retrieve(name).getVLuminosityBlockRange();
1204  }
template<>
std::vector<LuminosityBlockRange> edm::ParameterSet::getParameter< std::vector< LuminosityBlockRange > > ( char const *  name) const

Definition at line 1832 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockRange(), and edm::ParameterSet::retrieve().

1832  {
1833  return retrieve(name).getVLuminosityBlockRange();
1834  }
template<>
std::vector<PdtEntry> edm::ParameterSet::getParameter< std::vector< PdtEntry > > ( char const *  name) const
inline

Definition at line 110 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

110  {
111  Entry const& e = retrieve(name);
113  }
Definition: Entry.h:18
std::vector< PdtEntry > getPdtEntryVector(Entry const &e, char const *name)
Definition: PdtEntry.cc:66
template<>
std::vector<PdtEntry> edm::ParameterSet::getParameter< std::vector< PdtEntry > > ( std::string const &  name) const
inline

Definition at line 90 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

90  {
91  Entry const& e = retrieve(name);
92  return pdtentry::getPdtEntryVector(e, name.c_str());
93  }
Definition: Entry.h:18
std::vector< PdtEntry > getPdtEntryVector(Entry const &e, char const *name)
Definition: PdtEntry.cc:66
template<>
std::vector<std::string> edm::ParameterSet::getParameter< std::vector< std::string > > ( std::string const &  name) const

Definition at line 1074 of file ParameterSet.cc.

References edm::Entry::getVString(), dataset::name, and edm::ParameterSet::retrieve().

1074  {
1075  return retrieve(name).getVString();
1076  }
template<>
std::vector<std::string> edm::ParameterSet::getParameter< std::vector< std::string > > ( char const *  name) const

Definition at line 1704 of file ParameterSet.cc.

References edm::Entry::getVString(), and edm::ParameterSet::retrieve().

1704  {
1705  return retrieve(name).getVString();
1706  }
template<>
std::vector<unsigned int> edm::ParameterSet::getParameter< std::vector< unsigned int > > ( std::string const &  name) const

Definition at line 1029 of file ParameterSet.cc.

References edm::Entry::getVUInt32(), dataset::name, and edm::ParameterSet::retrieve().

1029  {
1030  return retrieve(name).getVUInt32();
1031  }
template<>
std::vector<unsigned int> edm::ParameterSet::getParameter< std::vector< unsigned int > > ( char const *  name) const

Definition at line 1659 of file ParameterSet.cc.

References edm::Entry::getVUInt32(), and edm::ParameterSet::retrieve().

1659  {
1660  return retrieve(name).getVUInt32();
1661  }
template<>
std::vector<unsigned long long> edm::ParameterSet::getParameter< std::vector< unsigned long long > > ( std::string const &  name) const

Definition at line 1044 of file ParameterSet.cc.

References edm::Entry::getVUInt64(), dataset::name, and edm::ParameterSet::retrieve().

1044  {
1045  return retrieve(name).getVUInt64();
1046  }
template<>
std::vector<unsigned long long> edm::ParameterSet::getParameter< std::vector< unsigned long long > > ( char const *  name) const

Definition at line 1674 of file ParameterSet.cc.

References edm::Entry::getVUInt64(), and edm::ParameterSet::retrieve().

1674  {
1675  return retrieve(name).getVUInt64();
1676  }
template<>
std::vector<std::string> edm::ParameterSet::getParameterNamesForType< std::vector< PdtEntry > > ( bool  trackiness) const
inline

Definition at line 138 of file PdtEntry.h.

References popcon2dropbox::copy(), and nano_cff::strings.

138  {
139  std::vector<std::string> ints = getParameterNamesForType<std::vector<int> >(trackiness);
140  std::vector<std::string> strings = getParameterNamesForType<std::vector<std::string> >(trackiness);
141  std::copy( strings.begin(), strings.end(), std::back_insert_iterator<std::vector<std::string> >( ints ) );
142  return ints;
143  }
def copy(args, dbName)
template<>
std::string edm::ParameterSet::getUntrackedParameter< std::string > ( std::string const &  name,
std::string const &  defaultValue 
) const

Definition at line 1388 of file ParameterSet.cc.

References edm::Entry::getString(), edm::ParameterSet::retrieveUntracked(), and AlCaHLTBitMon_QueryRunRegistry::string.

1388  {
1389  Entry const* entryPtr = retrieveUntracked(name);
1390  return entryPtr == nullptr ? defaultValue : entryPtr->getString();
1391  }
Definition: Entry.h:18
template<>
std::string edm::ParameterSet::getUntrackedParameter< std::string > ( std::string const &  name) const

Definition at line 1395 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getString().

1395  {
1396  return getEntryPointerOrThrow_(name)->getString();
1397  }
template<>
std::string edm::ParameterSet::getUntrackedParameter< std::string > ( char const *  name,
std::string const &  defaultValue 
) const

Definition at line 2018 of file ParameterSet.cc.

References edm::Entry::getString(), edm::ParameterSet::retrieveUntracked(), and AlCaHLTBitMon_QueryRunRegistry::string.

2018  {
2019  Entry const* entryPtr = retrieveUntracked(name);
2020  return entryPtr == nullptr ? defaultValue : entryPtr->getString();
2021  }
Definition: Entry.h:18
template<>
std::string edm::ParameterSet::getUntrackedParameter< std::string > ( char const *  name) const

Definition at line 2025 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getString().

2025  {
2026  return getEntryPointerOrThrow_(name)->getString();
2027  }
template<>
std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > > ( std::string const &  name) const

Definition at line 1379 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), edm::Entry::getVDouble(), and AlCaHLTBitMon_QueryRunRegistry::string.

1379  {
1380  return getEntryPointerOrThrow_(name)->getVDouble();
1381  }
template<>
std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > > ( std::string const &  name,
std::vector< double > const &  defaultValue 
) const

Definition at line 1373 of file ParameterSet.cc.

References edm::Entry::getVDouble(), and edm::ParameterSet::retrieveUntracked().

1373  {
1374  Entry const* entryPtr = retrieveUntracked(name); return entryPtr == nullptr ? defaultValue : entryPtr->getVDouble();
1375  }
Definition: Entry.h:18
template<>
std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > > ( char const *  name) const

Definition at line 2009 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), edm::Entry::getVDouble(), and AlCaHLTBitMon_QueryRunRegistry::string.

2009  {
2010  return getEntryPointerOrThrow_(name)->getVDouble();
2011  }
template<>
std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > > ( char const *  name,
std::vector< double > const &  defaultValue 
) const

Definition at line 2003 of file ParameterSet.cc.

References edm::Entry::getVDouble(), and edm::ParameterSet::retrieveUntracked().

2003  {
2004  Entry const* entryPtr = retrieveUntracked(name); return entryPtr == nullptr ? defaultValue : entryPtr->getVDouble();
2005  }
Definition: Entry.h:18
template<>
std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > ( std::string const &  name) const

Definition at line 1484 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVESInputTag().

1484  {
1485  return getEntryPointerOrThrow_(name)->getVESInputTag();
1486  }
template<>
std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > ( std::string const &  name,
std::vector< ESInputTag > const &  defaultValue 
) const

Definition at line 1476 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), and edm::ParameterSet::retrieveUntracked().

1477  {
1478  Entry const* entryPtr = retrieveUntracked(name);
1479  return entryPtr == nullptr ? defaultValue : entryPtr->getVESInputTag();
1480  }
Definition: Entry.h:18
template<>
std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > ( char const *  name,
std::vector< ESInputTag > const &  defaultValue 
) const

Definition at line 2106 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), and edm::ParameterSet::retrieveUntracked().

2107  {
2108  Entry const* entryPtr = retrieveUntracked(name);
2109  return entryPtr == nullptr ? defaultValue : entryPtr->getVESInputTag();
2110  }
Definition: Entry.h:18
template<>
std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > ( char const *  name) const

Definition at line 2114 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVESInputTag().

2114  {
2115  return getEntryPointerOrThrow_(name)->getVESInputTag();
2116  }
template<>
std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > > ( std::string const &  name,
std::vector< EventID > const &  defaultValue 
) const

Definition at line 1506 of file ParameterSet.cc.

References edm::Entry::getVEventID(), and edm::ParameterSet::retrieveUntracked().

1507  {
1508  Entry const* entryPtr = retrieveUntracked(name);
1509  return entryPtr == nullptr ? defaultValue : entryPtr->getVEventID();
1510  }
Definition: Entry.h:18
template<>
std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > > ( std::string const &  name) const

Definition at line 1514 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVEventID().

1514  {
1515  return getEntryPointerOrThrow_(name)->getVEventID();
1516  }
template<>
std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > > ( char const *  name,
std::vector< EventID > const &  defaultValue 
) const

Definition at line 2136 of file ParameterSet.cc.

References edm::Entry::getVEventID(), and edm::ParameterSet::retrieveUntracked().

2137  {
2138  Entry const* entryPtr = retrieveUntracked(name);
2139  return entryPtr == nullptr ? defaultValue : entryPtr->getVEventID();
2140  }
Definition: Entry.h:18
template<>
std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > > ( char const *  name) const

Definition at line 2144 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVEventID().

2144  {
2145  return getEntryPointerOrThrow_(name)->getVEventID();
2146  }
template<>
std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > > ( std::string const &  name,
std::vector< EventRange > const &  defaultValue 
) const

Definition at line 1566 of file ParameterSet.cc.

References edm::Entry::getVEventRange(), and edm::ParameterSet::retrieveUntracked().

1567  {
1568  Entry const* entryPtr = retrieveUntracked(name);
1569  return entryPtr == nullptr ? defaultValue : entryPtr->getVEventRange();
1570  }
Definition: Entry.h:18
template<>
std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > > ( std::string const &  name) const

Definition at line 1574 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVEventRange().

1574  {
1575  return getEntryPointerOrThrow_(name)->getVEventRange();
1576  }
template<>
std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > > ( char const *  name) const

Definition at line 2204 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVEventRange().

2204  {
2205  return getEntryPointerOrThrow_(name)->getVEventRange();
2206  }
template<>
std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > > ( char const *  name,
std::vector< EventRange > const &  defaultValue 
) const

Definition at line 2196 of file ParameterSet.cc.

References edm::Entry::getVEventRange(), and edm::ParameterSet::retrieveUntracked().

2197  {
2198  Entry const* entryPtr = retrieveUntracked(name);
2199  return entryPtr == nullptr ? defaultValue : entryPtr->getVEventRange();
2200  }
Definition: Entry.h:18
template<>
std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > > ( std::string const &  name) const

Definition at line 1454 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInputTag().

1454  {
1455  return getEntryPointerOrThrow_(name)->getVInputTag();
1456  }
template<>
std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > > ( std::string const &  name,
std::vector< InputTag > const &  defaultValue 
) const

Definition at line 1446 of file ParameterSet.cc.

References edm::Entry::getVInputTag(), and edm::ParameterSet::retrieveUntracked().

1447  {
1448  Entry const* entryPtr = retrieveUntracked(name);
1449  return entryPtr == nullptr ? defaultValue : entryPtr->getVInputTag();
1450  }
Definition: Entry.h:18
template<>
std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > > ( char const *  name,
std::vector< InputTag > const &  defaultValue 
) const

Definition at line 2076 of file ParameterSet.cc.

References edm::Entry::getVInputTag(), and edm::ParameterSet::retrieveUntracked().

2077  {
2078  Entry const* entryPtr = retrieveUntracked(name);
2079  return entryPtr == nullptr ? defaultValue : entryPtr->getVInputTag();
2080  }
Definition: Entry.h:18
template<>
std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > > ( char const *  name) const

Definition at line 2084 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInputTag().

2084  {
2085  return getEntryPointerOrThrow_(name)->getVInputTag();
2086  }
template<>
std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > > ( std::string const &  name,
std::vector< int > const &  defaultValue 
) const

Definition at line 1257 of file ParameterSet.cc.

References edm::Entry::getVInt32(), and edm::ParameterSet::retrieveUntracked().

1257  {
1258  Entry const* entryPtr = retrieveUntracked(name);
1259  return entryPtr == nullptr ? defaultValue : entryPtr->getVInt32();
1260  }
Definition: Entry.h:18
template<>
std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > > ( std::string const &  name) const

Definition at line 1264 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInt32().

1264  {
1265  return getEntryPointerOrThrow_(name)->getVInt32();
1266  }
template<>
std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > > ( char const *  name,
std::vector< int > const &  defaultValue 
) const

Definition at line 1887 of file ParameterSet.cc.

References edm::Entry::getVInt32(), and edm::ParameterSet::retrieveUntracked().

1887  {
1888  Entry const* entryPtr = retrieveUntracked(name);
1889  return entryPtr == nullptr ? defaultValue : entryPtr->getVInt32();
1890  }
Definition: Entry.h:18
template<>
std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > > ( char const *  name) const

Definition at line 1894 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInt32().

1894  {
1895  return getEntryPointerOrThrow_(name)->getVInt32();
1896  }
template<>
std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > > ( std::string const &  name) const

Definition at line 1351 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInt64().

1351  {
1352  return getEntryPointerOrThrow_(name)->getVInt64();
1353  }
template<>
std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > > ( std::string const &  name,
std::vector< long long > const &  defaultValue 
) const

Definition at line 1344 of file ParameterSet.cc.

References edm::Entry::getVInt64(), and edm::ParameterSet::retrieveUntracked().

1344  {
1345  Entry const* entryPtr = retrieveUntracked(name);
1346  return entryPtr == nullptr ? defaultValue : entryPtr->getVInt64();
1347  }
Definition: Entry.h:18
template<>
std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > > ( char const *  name) const

Definition at line 1981 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInt64().

1981  {
1982  return getEntryPointerOrThrow_(name)->getVInt64();
1983  }
template<>
std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > > ( char const *  name,
std::vector< long long > const &  defaultValue 
) const

Definition at line 1974 of file ParameterSet.cc.

References edm::Entry::getVInt64(), and edm::ParameterSet::retrieveUntracked().

1974  {
1975  Entry const* entryPtr = retrieveUntracked(name);
1976  return entryPtr == nullptr ? defaultValue : entryPtr->getVInt64();
1977  }
Definition: Entry.h:18
template<>
std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > ( std::string const &  name) const

Definition at line 1544 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVLuminosityBlockID().

1544  {
1545  return getEntryPointerOrThrow_(name)->getVLuminosityBlockID();
1546  }
template<>
std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > ( std::string const &  name,
std::vector< LuminosityBlockID > const &  defaultValue 
) const

Definition at line 1536 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockID(), and edm::ParameterSet::retrieveUntracked().

1537  {
1538  Entry const* entryPtr = retrieveUntracked(name);
1539  return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockID();
1540  }
Definition: Entry.h:18
template<>
std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > ( char const *  name) const

Definition at line 2174 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVLuminosityBlockID().

2174  {
2175  return getEntryPointerOrThrow_(name)->getVLuminosityBlockID();
2176  }
template<>
std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > ( char const *  name,
std::vector< LuminosityBlockID > const &  defaultValue 
) const

Definition at line 2166 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockID(), and edm::ParameterSet::retrieveUntracked().

2167  {
2168  Entry const* entryPtr = retrieveUntracked(name);
2169  return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockID();
2170  }
Definition: Entry.h:18
template<>
std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > ( std::string const &  name) const

Definition at line 1604 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVLuminosityBlockRange().

1604  {
1605  return getEntryPointerOrThrow_(name)->getVLuminosityBlockRange();
1606  }
template<>
std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > ( std::string const &  name,
std::vector< LuminosityBlockRange > const &  defaultValue 
) const

Definition at line 1596 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockRange(), and edm::ParameterSet::retrieveUntracked().

1597  {
1598  Entry const* entryPtr = retrieveUntracked(name);
1599  return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockRange();
1600  }
Definition: Entry.h:18
template<>
std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > ( char const *  name,
std::vector< LuminosityBlockRange > const &  defaultValue 
) const

Definition at line 2226 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockRange(), and edm::ParameterSet::retrieveUntracked().

2227  {
2228  Entry const* entryPtr = retrieveUntracked(name);
2229  return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockRange();
2230  }
Definition: Entry.h:18
template<>
std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > ( char const *  name) const

Definition at line 2234 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVLuminosityBlockRange().

2234  {
2235  return getEntryPointerOrThrow_(name)->getVLuminosityBlockRange();
2236  }
template<>
std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( std::string const &  name) const
inline

Definition at line 96 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

96  {
97  Entry const* e = getEntryPointerOrThrow_(name);
98  return pdtentry::getPdtEntryVector(*e, name.c_str());
99  }
Definition: Entry.h:18
std::vector< PdtEntry > getPdtEntryVector(Entry const &e, char const *name)
Definition: PdtEntry.cc:66
template<>
std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( char const *  name) const
inline

Definition at line 116 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

116  {
117  Entry const* e = getEntryPointerOrThrow_(name);
118  return pdtentry::getPdtEntryVector(*e, name);
119  }
Definition: Entry.h:18
std::vector< PdtEntry > getPdtEntryVector(Entry const &e, char const *name)
Definition: PdtEntry.cc:66
template<>
std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( std::string const &  name,
std::vector< PdtEntry > const &  defaultValue 
) const
inline

Definition at line 102 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

103  {
104  Entry const* e = retrieveUntracked(name);
105  if (e == nullptr) return defaultValue;
106  return pdtentry::getPdtEntryVector(*e, name.c_str());
107  }
Definition: Entry.h:18
std::vector< PdtEntry > getPdtEntryVector(Entry const &e, char const *name)
Definition: PdtEntry.cc:66
template<>
std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( char const *  name,
std::vector< PdtEntry > const &  defaultValue 
) const
inline

Definition at line 122 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

123  {
124  Entry const* e = retrieveUntracked(name);
125  if (e == nullptr) return defaultValue;
126  return pdtentry::getPdtEntryVector(*e, name);
127  }
Definition: Entry.h:18
std::vector< PdtEntry > getPdtEntryVector(Entry const &e, char const *name)
Definition: PdtEntry.cc:66
template<>
std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > > ( std::string const &  name,
std::vector< std::string > const &  defaultValue 
) const

Definition at line 1401 of file ParameterSet.cc.

References edm::Entry::getVString(), and edm::ParameterSet::retrieveUntracked().

1401  {
1402  Entry const* entryPtr = retrieveUntracked(name);
1403  return entryPtr == nullptr ? defaultValue : entryPtr->getVString();
1404  }
Definition: Entry.h:18
template<>
std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > > ( std::string const &  name) const

Definition at line 1408 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVString().

1408  {
1409  return getEntryPointerOrThrow_(name)->getVString();
1410  }
template<>
std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > > ( char const *  name,
std::vector< std::string > const &  defaultValue 
) const

Definition at line 2031 of file ParameterSet.cc.

References edm::Entry::getVString(), and edm::ParameterSet::retrieveUntracked().

2031  {
2032  Entry const* entryPtr = retrieveUntracked(name);
2033  return entryPtr == nullptr ? defaultValue : entryPtr->getVString();
2034  }
Definition: Entry.h:18
template<>
std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > > ( char const *  name) const

Definition at line 2038 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVString().

2038  {
2039  return getEntryPointerOrThrow_(name)->getVString();
2040  }
template<>
std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > > ( std::string const &  name) const

Definition at line 1293 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVUInt32().

1293  {
1294  return getEntryPointerOrThrow_(name)->getVUInt32();
1295  }
template<>
std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > > ( std::string const &  name,
std::vector< unsigned int > const &  defaultValue 
) const

Definition at line 1286 of file ParameterSet.cc.

References edm::Entry::getVUInt32(), and edm::ParameterSet::retrieveUntracked().

1286  {
1287  Entry const* entryPtr = retrieveUntracked(name);
1288  return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt32();
1289  }
Definition: Entry.h:18
template<>
std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > > ( char const *  name,
std::vector< unsigned int > const &  defaultValue 
) const

Definition at line 1916 of file ParameterSet.cc.

References edm::Entry::getVUInt32(), and edm::ParameterSet::retrieveUntracked().

1916  {
1917  Entry const* entryPtr = retrieveUntracked(name);
1918  return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt32();
1919  }
Definition: Entry.h:18
template<>
std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > > ( char const *  name) const

Definition at line 1923 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVUInt32().

1923  {
1924  return getEntryPointerOrThrow_(name)->getVUInt32();
1925  }
template<>
std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > ( std::string const &  name) const

Definition at line 1322 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVUInt64().

1322  {
1323  return getEntryPointerOrThrow_(name)->getVUInt64();
1324  }
template<>
std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > ( std::string const &  name,
std::vector< unsigned long long > const &  defaultValue 
) const

Definition at line 1315 of file ParameterSet.cc.

References edm::Entry::getVUInt64(), and edm::ParameterSet::retrieveUntracked().

1315  {
1316  Entry const* entryPtr = retrieveUntracked(name);
1317  return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt64();
1318  }
Definition: Entry.h:18
template<>
std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > ( char const *  name,
std::vector< unsigned long long > const &  defaultValue 
) const

Definition at line 1945 of file ParameterSet.cc.

References edm::Entry::getVUInt64(), and edm::ParameterSet::retrieveUntracked().

1945  {
1946  Entry const* entryPtr = retrieveUntracked(name);
1947  return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt64();
1948  }
Definition: Entry.h:18
template<>
std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > ( char const *  name) const

Definition at line 1952 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVUInt64().

1952  {
1953  return getEntryPointerOrThrow_(name)->getVUInt64();
1954  }
std::string edm::parameterTypeEnumToString ( ParameterTypes  iType)

Definition at line 55 of file ParameterDescriptionNode.cc.

References TYPE_TO_NAME, and HistogramManager_cfi::VPSet().

Referenced by edm::ParameterSwitchBase::insertAndCheckTypes(), edm::ParameterWildcardBase::print_(), edm::ParameterDescriptionBase::print_(), edm::ParameterSwitch< T >::print_(), edm::AllowedLabelsDescriptionBase::printNestedContentBase_(), edm::IfExistsDescription::throwIfDuplicateTypes(), edm::ORGroupDescription::throwIfDuplicateTypes(), edm::ANDGroupDescription::throwIfDuplicateTypes(), edm::ParameterWildcardBase::throwIfInvalidPattern(), edm::ParameterSetDescription::throwIfWildcardCollision(), edm::ParameterDescriptionBase::throwMissingRequiredNoDefault(), edm::ParameterDescriptionBase::throwParameterWrongTrackiness(), edm::ParameterDescriptionBase::throwParameterWrongType(), edm::ParameterWildcardBase::validateMatchingNames(), and edm::ParameterDescriptionBase::writeCfi_().

55  {
56  switch(iType) {
57  TYPE_TO_NAME(int32);
58  TYPE_TO_NAME(vint32);
60  TYPE_TO_NAME(vuint32);
61  TYPE_TO_NAME(int64);
62  TYPE_TO_NAME(vint64);
64  TYPE_TO_NAME(vuint64);
65  TYPE_TO_NAME(double);
67  TYPE_TO_NAME(bool);
68  TYPE_TO_NAME(string);
70  TYPE_TO_NAME(EventID);
71  TYPE_TO_NAME(VEventID);
72  TYPE_TO_NAME(LuminosityBlockID);
73  TYPE_TO_NAME(VLuminosityBlockID);
74  TYPE_TO_NAME(InputTag);
75  TYPE_TO_NAME(VInputTag);
76  TYPE_TO_NAME(FileInPath);
77  TYPE_TO_NAME(PSet);
80  TYPE_TO_NAME(VLuminosityBlockRange);
81  TYPE_TO_NAME(EventRange);
82  TYPE_TO_NAME(VEventRange);
83  default:
84  assert(false);
85  }
86  return "";
87  }
vector< string > vstring
Definition: ExoticaDQM.cc:8
unsigned int uint32
Definition: MsgTools.h:13
std::vector< double > vdouble
unsigned long long uint64
Definition: MsgTools.h:14
#define TYPE_TO_NAME(type)
template<>
ParameterTypes edm::ParameterTypeToEnum::toEnum< std::string > ( )

Definition at line 36 of file ParameterDescriptionNode.cc.

template<>
ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< double > > ( )

Definition at line 34 of file ParameterDescriptionNode.cc.

template<>
ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< EventID > > ( )

Definition at line 39 of file ParameterDescriptionNode.cc.

Definition at line 48 of file ParameterDescriptionNode.cc.

template<>
ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< InputTag > > ( )

Definition at line 43 of file ParameterDescriptionNode.cc.

template<>
ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< int > > ( )

Definition at line 26 of file ParameterDescriptionNode.cc.

template<>
ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< long long > > ( )

Definition at line 30 of file ParameterDescriptionNode.cc.

Definition at line 41 of file ParameterDescriptionNode.cc.

Definition at line 46 of file ParameterDescriptionNode.cc.

template<>
ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< std::string > > ( )

Definition at line 37 of file ParameterDescriptionNode.cc.

template<>
ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< unsigned > > ( )

Definition at line 28 of file ParameterDescriptionNode.cc.

template<>
ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< unsigned long long > > ( )

Definition at line 32 of file ParameterDescriptionNode.cc.

template<typename T >
void const* edm::pointerToBase ( std::type_info const &  baseTypeInfo,
T const *  address 
)

Definition at line 50 of file OffsetToBase.h.

References PFRecoTauDiscriminationByIsolation_cfi::offset, and edm::OffsetToBase< T >::offsetToBase().

Referenced by edm::reftobase::RefHolder< REF >::pointerToType(), edm::detail::reallyfillPtrVector(), and edm::detail::reallySetPtr().

50  {
51  OffsetToBase<T> offsetToBase;
52  int offset = offsetToBase.offsetToBase(baseTypeInfo);
53  void const* ptr = address;
54  return static_cast<char const*>(ptr) + offset;
55  }
std::vector< ParameterSet > edm::popSubProcessVParameterSet ( ParameterSet parameterSet)

Definition at line 684 of file SubProcess.cc.

References edm::ParameterSet::getUntrackedParameter(), and edm::ParameterSet::popVParameterSet().

Referenced by edm::EventProcessor::init(), and edm::SubProcess::SubProcess().

684  {
685  std::vector<std::string> subProcesses = parameterSet.getUntrackedParameter<std::vector<std::string>>("@all_subprocesses");
686  if(!subProcesses.empty()) {
687  return parameterSet.popVParameterSet("subProcesses");
688  }
689  return {};
690  }
static void edm::postIndexIntoFilePrintEventLists ( TFile *  tfl,
FileFormatVersion const &  fileFormatVersion,
TTree *  metaDataTree 
)
static

Definition at line 150 of file CollUtil.cc.

References edm::IndexIntoFile::begin(), gather_cfg::cout, edm::IndexIntoFile::end(), edm::EventID::event(), edm::poolNames::eventTreeName(), edm::IndexIntoFile::firstAppearanceOrder, edm::EventAuxiliary::id(), edm::poolNames::indexIntoFileBranchName(), edm::IndexIntoFile::iterationWillBeInEntryOrder(), edm::IndexIntoFile::kEvent, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, AlCaHLTBitMon_QueryRunRegistry::string, and lumiQTWidget::t.

Referenced by printEventLists().

150  {
151  IndexIntoFile indexIntoFile;
152  IndexIntoFile *findexPtr = &indexIntoFile;
153  if (metaDataTree->FindBranch(poolNames::indexIntoFileBranchName().c_str()) != nullptr) {
154  TBranch *fndx = metaDataTree->GetBranch(poolNames::indexIntoFileBranchName().c_str());
155  fndx->SetAddress(&findexPtr);
156  fndx->GetEntry(0);
157  } else {
158  std::cout << "IndexIntoFile not found. If this input file was created with release 1_8_0 or later\n"
159  "this indicates a problem with the file. This condition should be expected with\n"
160  "files created with earlier releases and printout of the event list will fail.\n";
161  return;
162  }
163  //need to read event # from the EventAuxiliary branch
164  TTree* eventsTree = dynamic_cast<TTree*>(tfl->Get(poolNames::eventTreeName().c_str()));
165  TBranch* eventAuxBranch = nullptr;
166  assert(nullptr != eventsTree);
167  char const* const kEventAuxiliaryBranchName = "EventAuxiliary";
168  if(eventsTree->FindBranch(kEventAuxiliaryBranchName) != nullptr){
169  eventAuxBranch = eventsTree->GetBranch(kEventAuxiliaryBranchName);
170  } else {
171  std::cout << "Failed to find " << kEventAuxiliaryBranchName << " branch in Events TTree. Something is wrong with this file." << std::endl;
172  return;
173  }
174  EventAuxiliary eventAuxiliary;
175  EventAuxiliary* eAPtr = &eventAuxiliary;
176  eventAuxBranch->SetAddress(&eAPtr);
177  std::cout << "\nPrinting IndexIntoFile contents. This includes a list of all Runs, LuminosityBlocks\n"
178  << "and Events stored in the root file.\n\n";
179  std::cout << std::setw(15) << "Run"
180  << std::setw(15) << "Lumi"
181  << std::setw(15) << "Event"
182  << std::setw(15) << "TTree Entry"
183  << "\n";
184 
185  for(IndexIntoFile::IndexIntoFileItr it = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder),
186  itEnd = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
187  it != itEnd; ++it) {
188  IndexIntoFile::EntryType t = it.getEntryType();
189  std::cout << std::setw(15) << it.run() << std::setw(15) << it.lumi();
190  EventNumber_t eventNum = 0;
192  switch(t) {
193  case IndexIntoFile::kRun:
194  type = "(Run)";
195  break;
196  case IndexIntoFile::kLumi:
197  type = "(Lumi)";
198  break;
199  case IndexIntoFile::kEvent:
200  eventAuxBranch->GetEntry(it.entry());
201  eventNum = eventAuxiliary.id().event();
202  break;
203  default:
204  break;
205  }
206  std::cout << std::setw(15) << eventNum << std::setw(15) << it.entry() << " " << type << std::endl;
207  }
208 
209  std::cout << "\nFileFormatVersion = " << fileFormatVersion << ". ";
210  if (fileFormatVersion.fastCopyPossible()) std::cout << "This version supports fast copy\n";
211  else std::cout << "This version does not support fast copy\n";
212 
213  if (indexIntoFile.iterationWillBeInEntryOrder(IndexIntoFile::firstAppearanceOrder)) {
214  std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort = false\" mode\n";
215  } else {
216  std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort = false\" mode\n";
217  }
218 
219  // This will not work unless the other nonpersistent parts of the Index are filled first
220  // I did not have time to implement this yet.
221  // if (indexIntoFile.iterationWillBeInEntryOrder(IndexIntoFile::numericalOrder)) {
222  // std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort\" mode\n";
223  // } else {
224  // std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort\" mode\n";
225  // }
226  std::cout << "(Note that other factors can prevent fast copy from occurring)\n\n";
227  }
type
Definition: HCALResponse.h:21
unsigned long long EventNumber_t
std::string const & indexIntoFileBranchName()
Definition: BranchType.cc:233
std::string const & eventTreeName()
Definition: BranchType.cc:260
static void edm::postIndexIntoFilePrintEventsInLumis ( TFile *  tfl,
FileFormatVersion const &  fileFormatVersion,
TTree *  metaDataTree 
)
static

Definition at line 296 of file CollUtil.cc.

References edm::IndexIntoFile::begin(), gather_cfg::cout, edm::IndexIntoFile::end(), edm::IndexIntoFile::firstAppearanceOrder, edm::poolNames::indexIntoFileBranchName(), edm::IndexIntoFile::kEvent, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, nEvents, and lumiQTWidget::t.

Referenced by printEventsInLumis().

296  {
297  IndexIntoFile indexIntoFile;
298  IndexIntoFile *findexPtr = &indexIntoFile;
299  if (metaDataTree->FindBranch(poolNames::indexIntoFileBranchName().c_str()) != nullptr) {
300  TBranch *fndx = metaDataTree->GetBranch(poolNames::indexIntoFileBranchName().c_str());
301  fndx->SetAddress(&findexPtr);
302  fndx->GetEntry(0);
303  } else {
304  std::cout << "IndexIntoFile not found. If this input file was created with release 1_8_0 or later\n"
305  "this indicates a problem with the file. This condition should be expected with\n"
306  "files created with earlier releases and printout of the event list will fail.\n";
307  return;
308  }
309  std::cout <<"\n"<< std::setw(15) << "Run"
310  << std::setw(15) << "Lumi"
311  << std::setw(15) << "# Events"
312  << "\n";
313 
314  unsigned long nEvents = 0;
315  unsigned long runID = 0;
316  unsigned long lumiID = 0;
317 
318  for(IndexIntoFile::IndexIntoFileItr it = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder),
319  itEnd = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
320  it != itEnd; ++it) {
321  IndexIntoFile::EntryType t = it.getEntryType();
322  switch(t) {
323  case IndexIntoFile::kRun:
324  break;
325  case IndexIntoFile::kLumi:
326  if(runID != it.run() || lumiID != it.lumi()) {
327  //print the previous one
328  if(lumiID !=0) {
329  std::cout << std::setw(15) << runID
330  << std::setw(15) << lumiID
331  << std::setw(15) << nEvents<<"\n";
332  }
333  nEvents=0;
334  runID = it.run();
335  lumiID = it.lumi();
336  }
337  break;
338  case IndexIntoFile::kEvent:
339  ++nEvents;
340  break;
341  default:
342  break;
343  }
344  }
345  //print the last one
346  if(lumiID !=0) {
347  std::cout << std::setw(15) << runID
348  << std::setw(15) << lumiID
349  << std::setw(15) << nEvents<<"\n";
350  }
351  std::cout << "\n";
352  }
std::string const & indexIntoFileBranchName()
Definition: BranchType.cc:233
UInt_t nEvents
Definition: hcalCalib.cc:42
static void edm::preIndexIntoFilePrintEventLists ( TFile *  ,
FileFormatVersion const &  fileFormatVersion,
TTree *  metaDataTree 
)
static

Definition at line 115 of file CollUtil.cc.

References gather_cfg::cout, and edm::poolNames::fileIndexBranchName().

Referenced by printEventLists().

115  {
116  FileIndex fileIndex;
117  FileIndex *findexPtr = &fileIndex;
118  if (metaDataTree->FindBranch(poolNames::fileIndexBranchName().c_str()) != nullptr) {
119  TBranch *fndx = metaDataTree->GetBranch(poolNames::fileIndexBranchName().c_str());
120  fndx->SetAddress(&findexPtr);
121  fndx->GetEntry(0);
122  } else {
123  std::cout << "FileIndex not found. If this input file was created with release 1_8_0 or later\n"
124  "this indicates a problem with the file. This condition should be expected with\n"
125  "files created with earlier releases and printout of the event list will fail.\n";
126  return;
127  }
128 
129  std::cout << "\n" << fileIndex;
130 
131  std::cout << "\nFileFormatVersion = " << fileFormatVersion << ". ";
132  if (fileFormatVersion.fastCopyPossible()) std::cout << "This version supports fast copy\n";
133  else std::cout << "This version does not support fast copy\n";
134 
135  if (fileIndex.allEventsInEntryOrder()) {
136  std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort = False\" mode\n";
137  } else {
138  std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort = False\" mode\n";
139  }
140 
141  fileIndex.sortBy_Run_Lumi_EventEntry();
142  if (fileIndex.allEventsInEntryOrder()) {
143  std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort\" mode\n";
144  } else {
145  std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort\" mode\n";
146  }
147  std::cout << "(Note that other factors can prevent fast copy from occurring)\n\n";
148  }
std::string const & fileIndexBranchName()
Definition: BranchType.cc:228
static void edm::preIndexIntoFilePrintEventsInLumis ( TFile *  ,
FileFormatVersion const &  fileFormatVersion,
TTree *  metaDataTree 
)
static

Definition at line 247 of file CollUtil.cc.

References edm::FileIndex::begin(), gather_cfg::cout, edm::FileIndex::end(), edm::poolNames::fileIndexBranchName(), edm::FileIndex::kEvent, edm::FileIndex::kLumi, and nEvents.

Referenced by printEventsInLumis().

247  {
248  FileIndex fileIndex;
249  FileIndex *findexPtr = &fileIndex;
250  if (metaDataTree->FindBranch(poolNames::fileIndexBranchName().c_str()) != nullptr) {
251  TBranch *fndx = metaDataTree->GetBranch(poolNames::fileIndexBranchName().c_str());
252  fndx->SetAddress(&findexPtr);
253  fndx->GetEntry(0);
254  } else {
255  std::cout << "FileIndex not found. If this input file was created with release 1_8_0 or later\n"
256  "this indicates a problem with the file. This condition should be expected with\n"
257  "files created with earlier releases and printout of the event list will fail.\n";
258  return;
259  }
260 
261  std::cout <<"\n"<< std::setw(15) << "Run"
262  << std::setw(15) << "Lumi"
263  << std::setw(15) << "# Events"
264  << "\n";
265  unsigned long nEvents = 0;
266  unsigned long runID = 0;
267  unsigned long lumiID = 0;
268  for(std::vector<FileIndex::Element>::const_iterator it = fileIndex.begin(), itEnd = fileIndex.end(); it != itEnd; ++it) {
269  if(it->getEntryType() == FileIndex::kEvent) {
270  ++nEvents;
271  }
272  else if(it->getEntryType() == FileIndex::kLumi) {
273  if(runID !=it->run_ || lumiID !=it->lumi_) {
274  //print the previous one
275  if(lumiID !=0) {
276  std::cout << std::setw(15) << runID
277  << std::setw(15) << lumiID
278  << std::setw(15) << nEvents<<"\n";
279  }
280  nEvents=0;
281  runID = it->run_;
282  lumiID = it->lumi_;
283  }
284  }
285  }
286  //print the last one
287  if(lumiID !=0) {
288  std::cout << std::setw(15) << runID
289  << std::setw(15) << lumiID
290  << std::setw(15) << nEvents<<"\n";
291  }
292 
293  std::cout << "\n";
294  }
std::string const & fileIndexBranchName()
Definition: BranchType.cc:228
UInt_t nEvents
Definition: hcalCalib.cc:42
template<typename S >
S& edm::print ( S os,
JobReport::InputFile const &  f 
)

Definition at line 65 of file JobReport.cc.

References formatFile(), edm::JobReport::InputFile::inputSourceClassName, edm::JobReport::InputFile::inputType, and edm::JobReport::InputFile::numEventsRead.

Referenced by TH2PolyOfflineMaps.TH2PolyOfflineMaps::__del__(), OrderedSet.OrderedSet::__eq__(), PhaseITreeProducer.ModuleLvlValuesReader::__TraverseDirTree(), TH2PolyOfflineMaps.TH2PolyOfflineMaps::__TraverseDirTree(), FilterSelection::acceptMap(), reco::IsoDeposit::addCandEnergy(), data_sources.json_list::as_dicts(), data_sources.json_list::as_table(), PixelTrackBuilder::build(), shell::close_connections(), helper::ConfigSectionMap(), command_line::copy_tag(), PhaseITreeProducer.ModuleLvlValuesReader::CreateTree(), PhaseITreeProducer.ModuleLvlValuesReader::CreateTree2(), AlCaHLTBitMon_ParallelJobs::defineOptions(), AlCaHLTBitMon_QueryRunRegistry::defineOptions(), SRBlockFormatter::DigiToRaw(), TCCBlockFormatter::DigiToRaw(), TowerBlockFormatter::DigiToRaw(), PhaseITreeProducer.ModuleLvlValuesReader::DumpData(), TH2PolyOfflineMaps.TH2PolyOfflineMaps::DumpData(), dqmd_manager::exec_func(), uploads.uploader::exit_upload(), sistrip::FEDDAQHeader::FEDDAQHeader(), pileupCalc::fillPileupHistogram(), NuclearInteractionEDProducer::findAdditionalSecondaryTracks(), models::generate(), uploadConditions::get_local_commit_hash(), PixelMapPlotter::GetAffectedRocs(), edmPickEvents::getFileNames_dasgoclient(), SimpleL1MuGMTCand::getMomentum(), SiStripSummary::getRunNr(), L1TMuon::TriggerPrimitive::getSubSector(), querying_tests::global_tag_tests(), grid1d_t(), L1GlobalTriggerReadoutRecord::gtPsbVector(), L1GtTechnicalTrigger::gtTechnicalTriggerResult(), dqmd_manager::info(), command_line::list_object(), python.rootplot.tree2hists::main(), nano_cff::nanoAOD_addDeepInfo(), nano_cff::nanoAOD_addDeepInfoAK8(), edm::ProductResolverIndexHelper::nextIndexValue(), helper::ScannerBase::numberOfExtraCuts(), L1GtAlgorithmEvaluation::operandTokenVector(), l1t::AlgorithmEvaluation::operandTokenVector(), operator<<(), uploadConditions::parse_arguments(), command_line::parse_command_line(), PixelMapPlotter.HistogramManager::prettifyCanvas(), PFCheckHitPattern::print(), createFEDtable::printHtmlTable(), studyJets::printJetProperties(), TH2PolyOfflineMaps.TH2PolyOfflineMaps::PrintTrackerMaps(), createFEDtable::printTwikiTable(), RPCUnpackingModule::produce(), EcalTrigPrimProducer::produce(), L1TGlobalProducer::produce(), __class__< T >::produce(), EcalDigiToRaw::produce(), NuclearInteractionEDProducer::produce(), uploadConditions::pull_code_from_git(), edm::RandomNumberGenerator::RandomNumberGenerator(), PhaseITreeProducer.ModuleLvlValuesReader::ReadHistograms(), TH2PolyOfflineMaps.TH2PolyOfflineMaps::ReadHistograms(), InefficientDoubleROC.InefficientDeadROCs::ReadHistograms(), python.rootplot.core::report_progress(), querying.connection::rollback(), L1GlobalTriggerGTL::run(), l1t::GlobalBoard::runGTL(), url_query.url_query::send(), uploads.uploader::send_metadata(), L1GlobalTriggerRecord::setGtPrescaleFactorIndexAlgo(), optutl::CommandLineParser::setPrintOptoins(), edm::pathStatusExpression::BinaryOperator< T >::setRight(), TtFullLeptonicEvent::setWrongCharge(), TtSemiLeptonicEvent::singleNeutrino(), muonisolation::Cuts::size(), MSLayersAtAngle::size(), sistrip::FEDDAQTrailer::slinkCRCError(), sqr(), RPCLinkSynchroStat::SynchroCounts::sum(), data_formats_tests.data_formats_tests::test_dicts_to_orm_objects(), FBaseSimEvent::theTable(), coreTools.RemoveMCMatching::toolCode(), TopGenEvent::topBar(), PixelMapPlotter::TranslatePartString(), PixelMapPlotter::TranslateReasonStringBPix(), PixelMapPlotter::TranslateReasonStringFPix(), dqmd_manager::usage(), TtFullHadronicEvent::wMinus(), uploads.output::write(), uploads.uploader::write_server_side_log(), edm::ParameterDescriptionNode::writeCfi(), hitfit::Base_Constrainer::~Base_Constrainer(), hitfit::Chisq_Constrainer::~Chisq_Constrainer(), lumi::LumiSectionData::~LumiSectionData(), RecoTauCleanerImpl< Prod >::~RecoTauCleanerImpl(), and RPCRawDataCounts::~RPCRawDataCounts().

65  {
66 
67  os << "\n<InputFile>";
68  formatFile(f, os);
69  os << "\n<InputType>" << f.inputType << "</InputType>";
70  os << "\n<InputSourceClass>" << TiXmlText(f.inputSourceClassName)
71  << "</InputSourceClass>";
72  os << "\n<EventsRead>" << f.numEventsRead << "</EventsRead>";
73  return os;
74  }
double f[11][100]
S & formatFile(T const &f, S &os)
Definition: JobReport.cc:39
template<typename S >
S& edm::print ( S os,
JobReport::OutputFile const &  f 
)

Definition at line 77 of file JobReport.cc.

References edm::JobReport::OutputFile::branchHash, edm::JobReport::OutputFile::dataType, formatFile(), edm::JobReport::OutputFile::numEventsWritten, and edm::JobReport::OutputFile::outputModuleClassName.

77  {
78  formatFile(f, os);
79  os << "\n<OutputModuleClass>"
80  << TiXmlText(f.outputModuleClassName)
81  << "</OutputModuleClass>";
82  os << "\n<TotalEvents>"
83  << f.numEventsWritten
84  << "</TotalEvents>\n";
85  os << "\n<DataType>"
86  << TiXmlText(f.dataType)
87  << "</DataType>\n";
88  os << "\n<BranchHash>"
89  << TiXmlText(f.branchHash)
90  << "</BranchHash>\n";
91  return os;
92  }
double f[11][100]
S & formatFile(T const &f, S &os)
Definition: JobReport.cc:39
template<typename S >
S& edm::print ( S os,
JobReport::RunReport const &  rep 
)

Definition at line 95 of file JobReport.cc.

References edm::JobReport::RunReport::lumiSectionsToNEvents, SiStripPI::max, and edm::JobReport::RunReport::runNumber.

96  {
97  os << "\n<Run ID=\""
98  << rep.runNumber
99  << "\">\n";
100 
101  for(auto const& il : rep.lumiSectionsToNEvents) {
102  if(std::numeric_limits<unsigned long>::max() == il.second) {
103  os << " <LumiSection ID=\"" << il.first << "\"/>\n";
104 
105  } else {
106  os << " <LumiSection ID=\"" << il.first << "\" NEvents=\""<<il.second<< "\"/>\n";
107  }
108  }
109  os << "</Run>\n";
110  return os;
111  }
rep
Definition: cuy.py:1189
template<typename RecordT >
void edm::print_eventsetup_record_dependencies ( std::ostream &  oStream,
std::string const &  iIndent = std::string() 
)

Definition at line 77 of file print_eventsetup_record_dependencies.h.

References edm::rec_dep::inherits_from_DependentRecordTag(), and dataset::name.

Referenced by print_eventsetup_record_dependencies(), and print_eventsetup_record_dependencies_recursive().

77  {
78  oStream<<iIndent<<edm::eventsetup::EventSetupRecordKey::makeKey<RecordT>().name()<<std::endl;
79 
80  print_eventsetup_record_dependencies_recursive<RecordT>(oStream, iIndent, rec_dep::inherits_from_DependentRecordTag(static_cast<RecordT const*>(nullptr)));
81  }
boost::mpl::true_ inherits_from_DependentRecordTag(edm::eventsetup::DependentRecordTag const *)
template<typename T >
void edm::print_eventsetup_record_dependencies ( std::ostream &  ,
std::string  ,
T const *  ,
T const *   
)

Definition at line 42 of file print_eventsetup_record_dependencies.h.

45  { }
template<typename TFirst , typename TEnd >
void edm::print_eventsetup_record_dependencies ( std::ostream &  oStream,
std::string  iIndent,
TFirst const *  ,
TEnd const *  iEnd 
)

Definition at line 48 of file print_eventsetup_record_dependencies.h.

References GetRecoTauVFromDQM_MC_cff::next, and print_eventsetup_record_dependencies().

50  {
51  iIndent +=" ";
53  typename boost::mpl::next< TFirst >::type const* next(nullptr);
54  print_eventsetup_record_dependencies(oStream, iIndent, next, iEnd);
55  }
type
Definition: HCALResponse.h:21
void print_eventsetup_record_dependencies(std::ostream &oStream, std::string iIndent, TFirst const *, TEnd const *iEnd)
template<typename RecordT >
void edm::print_eventsetup_record_dependencies_recursive ( std::ostream &  oStream,
std::string const &  iIndent,
boost::mpl::true_   
)

Definition at line 63 of file print_eventsetup_record_dependencies.h.

References begin, end, and print_eventsetup_record_dependencies().

63  {
64  typedef typename RecordT::list_type list_type;
65 
66  typename boost::mpl::begin<list_type>::type const* begin(nullptr);
67  typename boost::mpl::end<list_type>::type const* end(nullptr);
69  }
type
Definition: HCALResponse.h:21
void print_eventsetup_record_dependencies(std::ostream &oStream, std::string iIndent, TFirst const *, TEnd const *iEnd)
#define end
Definition: vmac.h:39
#define begin
Definition: vmac.h:32
template<typename RecordT >
void edm::print_eventsetup_record_dependencies_recursive ( std::ostream &  ,
std::string const &  ,
boost::mpl::false_   
)

Definition at line 72 of file print_eventsetup_record_dependencies.h.

72  {
73  return;
74  }
void edm::printBranchNames ( TTree *  tree)

Definition at line 73 of file CollUtil.cc.

References gather_cfg::cout, mps_fire::i, and findQualityFiles::size.

73  {
74  if (tree != nullptr) {
75  Long64_t nB = tree->GetListOfBranches()->GetEntries();
76  for (Long64_t i = 0; i < nB; ++i) {
77  Long64_t size = 0LL;
78  TBranch *btemp = (TBranch *)tree->GetListOfBranches()->At(i);
79  addBranchSizes(btemp, size);
80  std::cout << "Branch " << i << " of " << tree->GetName() << " tree: " << btemp->GetName() << " Total size = " << size << std::endl;
81  }
82  } else {
83  std::cout << "Missing Events tree?\n";
84  }
85  }
size
Write out results.
Definition: tree.py:1
void edm::printCmsException ( cms::Exception e,
edm::JobReport jobRep = nullptr,
int  rc = -1 
)

Definition at line 13 of file ExceptionMessages.cc.

References cms::Exception::explainSelf(), edm::JobReport::reportError(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by addContextAndPrintException().

13  {
14  std::string shortDesc("Fatal Exception");
15  std::ostringstream longDesc;
16  longDesc << e.explainSelf();
17  LogAbsolute(shortDesc)
18  << "----- Begin " << shortDesc << " "
19  << std::setprecision(0) << TimeOfDay()
20  << "-----------------------\n"
21  << longDesc.str()
22  << "----- End " << shortDesc << " -------------------------------------------------";
23  if(jobRep) jobRep->reportError(shortDesc, longDesc.str(), rc);
24  } catch(...) {
25  }
virtual std::string explainSelf() const
Definition: Exception.cc:146
void reportError(std::string const &shortDesc, std::string const &longDesc, int const &exitCode)
Definition: JobReport.cc:528
void edm::printCmsExceptionWarning ( char const *  behavior,
cms::Exception const &  e 
)

Definition at line 28 of file ExceptionMessages.cc.

References cms::Exception::explainSelf(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::EDLooperBase::doDuringLoop(), edm::StreamSchedule::finishedPaths(), edm::Path::handleWorkerFailure(), and edm::Worker::shouldRethrowException().

28  {
29  std::string shortDesc(behavior);
30  shortDesc += " Exception";
31  std::ostringstream longDesc;
32  longDesc << e.explainSelf();
33  LogPrint(shortDesc)
34  << "----- Begin " << shortDesc << " "
35  << std::setprecision(0) << TimeOfDay()
36  << "-----------------------\n"
37  << longDesc.str()
38  << "----- End " << shortDesc << " -------------------------------------------------";
39  } catch(...) {
40  }
void edm::printEventLists ( TFile *  tfl)

Definition at line 229 of file CollUtil.cc.

References edm::poolNames::fileFormatVersionBranchName(), edm::FileFormatVersion::hasIndexIntoFile(), edm::poolNames::metaDataTreeName(), postIndexIntoFilePrintEventLists(), and preIndexIntoFilePrintEventLists().

229  {
230  TTree *metaDataTree = dynamic_cast<TTree *>(tfl->Get(poolNames::metaDataTreeName().c_str()));
231  assert(nullptr != metaDataTree);
232 
233  FileFormatVersion fileFormatVersion;
234  FileFormatVersion *fftPtr = &fileFormatVersion;
235  if (metaDataTree->FindBranch(poolNames::fileFormatVersionBranchName().c_str()) != nullptr) {
236  TBranch *fft = metaDataTree->GetBranch(poolNames::fileFormatVersionBranchName().c_str());
237  fft->SetAddress(&fftPtr);
238  fft->GetEntry(0);
239  }
240  if(fileFormatVersion.hasIndexIntoFile()) {
241  postIndexIntoFilePrintEventLists(tfl, fileFormatVersion, metaDataTree);
242  } else {
243  preIndexIntoFilePrintEventLists(tfl, fileFormatVersion, metaDataTree);
244  }
245  }
std::string const & fileFormatVersionBranchName()
Definition: BranchType.cc:218
std::string const & metaDataTreeName()
Definition: BranchType.cc:168
static void preIndexIntoFilePrintEventLists(TFile *, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
Definition: CollUtil.cc:115
static void postIndexIntoFilePrintEventLists(TFile *tfl, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
Definition: CollUtil.cc:150
void edm::printEventsInLumis ( TFile *  tfl)

Definition at line 354 of file CollUtil.cc.

References edm::poolNames::fileFormatVersionBranchName(), edm::FileFormatVersion::hasIndexIntoFile(), edm::poolNames::metaDataTreeName(), postIndexIntoFilePrintEventsInLumis(), and preIndexIntoFilePrintEventsInLumis().

354  {
355  TTree *metaDataTree = dynamic_cast<TTree *>(tfl->Get(poolNames::metaDataTreeName().c_str()));
356  assert(nullptr != metaDataTree);
357 
358  FileFormatVersion fileFormatVersion;
359  FileFormatVersion *fftPtr = &fileFormatVersion;
360  if (metaDataTree->FindBranch(poolNames::fileFormatVersionBranchName().c_str()) != nullptr) {
361  TBranch *fft = metaDataTree->GetBranch(poolNames::fileFormatVersionBranchName().c_str());
362  fft->SetAddress(&fftPtr);
363  fft->GetEntry(0);
364  }
365  if(fileFormatVersion.hasIndexIntoFile()) {
366  postIndexIntoFilePrintEventsInLumis(tfl, fileFormatVersion, metaDataTree);
367  } else {
368  preIndexIntoFilePrintEventsInLumis(tfl, fileFormatVersion, metaDataTree);
369  }
370  }
std::string const & fileFormatVersionBranchName()
Definition: BranchType.cc:218
static void preIndexIntoFilePrintEventsInLumis(TFile *, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
Definition: CollUtil.cc:247
std::string const & metaDataTreeName()
Definition: BranchType.cc:168
static void postIndexIntoFilePrintEventsInLumis(TFile *tfl, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
Definition: CollUtil.cc:296
void edm::printTrees ( TFile *  hdl)

Definition at line 35 of file CollUtil.cc.

References fftjetcommon_cfi::Class, crabWrapper::key, and GetRecoTauVFromDQM_MC_cff::obj.

35  {
36  hdl->ls();
37  TList *keylist = hdl->GetListOfKeys();
38  TIterator *iter = keylist->MakeIterator();
39  TKey *key = nullptr;
40  while ((key = (TKey*)iter->Next())) {
41  TObject *obj = hdl->Get(key->GetName());
42  if (obj->IsA() == TTree::Class()) {
43  obj->Print();
44  }
45  }
46  return;
47  }
void edm::printUuids ( TTree *  uuidTree)

Definition at line 106 of file CollUtil.cc.

References gather_cfg::cout, edm::FileID::fid(), and edm::poolNames::fileIdentifierBranchName().

106  {
107  FileID fid;
108  FileID *fidPtr = &fid;
109  uuidTree->SetBranchAddress(poolNames::fileIdentifierBranchName().c_str(), &fidPtr);
110  uuidTree->GetEntry(0);
111 
112  std::cout << "UUID: " << fid.fid() << std::endl;
113  }
std::string const & fileIdentifierBranchName()
Definition: BranchType.cc:223
BranchID edm::productIDToBranchID ( ProductID const &  pid,
BranchIDLists const &  lists,
BranchListIndexes const &  indexes 
)

Definition at line 12 of file ProductIDToBranchID.cc.

References edm::ProductID::isValid(), edm::ProductID::processIndex(), and edm::ProductID::productIndex().

Referenced by edm::EventPrincipal::pidToBid(), fwlite::internal::BranchMapReaderStrategyV11::productToBranchID(), and fwlite::internal::BranchMapReaderStrategyV17::productToBranchID().

12  {
13 
14  if (pid.isValid()) {
15  size_t procIndex = pid.processIndex()-1;
16  if (procIndex < indexes.size()) {
17  BranchListIndex blix = indexes[procIndex];
18  if (blix < lists.size()) {
19  BranchIDList const& blist = lists[blix];
20  size_t prodIndex =pid.productIndex()-1;
21  if (prodIndex<blist.size()) {
22  BranchID::value_type bid = blist[prodIndex];
23  return BranchID(bid);
24  }
25  }
26  }
27  }
28  return BranchID();
29  }
std::vector< BranchID::value_type > BranchIDList
Definition: classes.h:18
bool edm::public_base_classes ( std::vector< std::string > &  missingDictionaries,
TypeID const &  typeID,
std::vector< TypeWithDict > &  baseTypes 
)

Definition at line 340 of file DictionaryTools.cc.

References runEdmFileComparison::base, checkDictionary(), edm::BaseWithDict::isPublic(), edm::TypeWithDict::name(), search_all(), edm::TypeIDBase::typeInfo(), edm::TypeWithDict::typeInfo(), and edm::BaseWithDict::typeOf().

Referenced by edm::ProductRegistry::checkDictionariesOfConsumedTypes(), edm::ProductRegistry::initializeLookupTables(), and edm::ProductResolverIndexHelper::insert().

342  {
343 
344  if (!checkDictionary(missingDictionaries, typeID)) {
345  return false;
346  }
347  TypeWithDict typeWithDict(typeID.typeInfo());
348 
349  if (!typeWithDict.isClass()) {
350  return true;
351  }
352 
353  TypeBases bases(typeWithDict);
354  bool returnValue = true;
355  for (auto const& basex : bases) {
356  BaseWithDict base(basex);
357  if (!base.isPublic()) {
358  continue;
359  }
360  TypeWithDict baseRflxType = base.typeOf();
361  if (!checkDictionary(missingDictionaries, baseRflxType.name(), baseRflxType)) {
362  returnValue = false;
363  continue;
364  }
365  TypeWithDict baseType(baseRflxType.typeInfo());
366  // Check to make sure this base appears only once in the
367  // inheritance hierarchy.
368  if (!search_all(baseTypes, baseType)) {
369  // Save the type and recursive look for its base types
370  baseTypes.push_back(baseType);
371  if (!public_base_classes(missingDictionaries, TypeID(baseType.typeInfo()), baseTypes)) {
372  returnValue = false;
373  continue;
374  }
375  }
376  // For now just ignore it if the class appears twice,
377  // After some more testing we may decide to uncomment the following
378  // exception.
379  //
380  //else {
381  // throw Exception(errors::UnimplementedFeature)
382  // << "DataFormats/Common/src/DictionaryTools.cc in function public_base_classes.\n"
383  // << "Encountered class that has a public base class that appears\n"
384  // << "multiple times in its inheritance heirarchy.\n"
385  // << "Please contact the EDM Framework group with details about\n"
386  // << "this exception. It was our hope that this complicated situation\n"
387  // << "would not occur. There are three possible solutions. 1. Change\n"
388  // << "the class design so the public base class does not appear multiple\n"
389  // << "times in the inheritance heirarchy. In many cases, this is a\n"
390  // << "sign of bad design. 2. Modify the code that supports Views to\n"
391  // << "ignore these base classes, but not supply support for creating a\n"
392  // << "View of this base class. 3. Improve the View infrastructure to\n"
393  // << "deal with this case. Class name of base class: " << baseType.Name() << "\n\n";
394  //}
395  }
396  return returnValue;
397  }
bool public_base_classes(std::vector< std::string > &missingDictionaries, TypeID const &typeID, std::vector< TypeWithDict > &baseTypes)
bool checkDictionary(std::vector< std::string > &missingDictionaries, TypeID const &typeID)
base
Make Sure CMSSW is Setup ##.
bool search_all(ForwardSequence const &s, Datum const &d)
Definition: Algorithms.h:46
std::string edm::pythonFileToConfigure ( const std::string &  iPythonFileName)

Definition at line 14 of file pythonFileToConfigure.cc.

References mps_check::command, pythonToCppException(), mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

15 {
16  std::string returnValue;
17  std::string initCommand("import FWCore.ParameterSet.Config as cms\n"
18  "fileDict = dict()\n"
19  "execfile('");
20  initCommand += iPythonFileName+"',fileDict)";
21 
22  Py_InitializeEx(0);
23  using namespace boost::python;
24 
25  object main_module((
26  boost::python::handle<PyObject>(borrowed(PyImport_AddModule(const_cast<char *>("__main__"))))));
27  object main_namespace = main_module.attr("__dict__");
28  try {
29  try {
30  object result((boost::python::handle<>(PyRun_String(initCommand.c_str(),
31  Py_file_input,
32  main_namespace.ptr(),
33  main_namespace.ptr()))));
34  } catch(error_already_set const&) {
35  edm::pythonToCppException("Configuration");
36  }
37  try {
38  std::string command("cms.findProcess(fileDict).dumpConfig()");
39  object result((handle<>(PyRun_String(command.c_str(),
40  Py_eval_input,
41  main_namespace.ptr(),
42  main_namespace.ptr()))));
43  returnValue= extract<std::string>(result);
44 
45  }catch( error_already_set const& ) {
46  edm::pythonToCppException("Configuration");
47  }
48  }catch(...) {
49  Py_Finalize();
50  throw;
51  }
52  Py_Finalize();
53  return returnValue;
54 }
void pythonToCppException(const std::string &iType)
Definition: PythonWrapper.cc:6
list command
Definition: mps_check.py:23
void edm::pythonToCppException ( const std::string &  iType)

Definition at line 6 of file PythonWrapper.cc.

References Exception, GsfMatrixTools::trace(), and heppy_batch::val.

Referenced by pythonFileToConfigure(), PythonProcessDesc::read(), readPSetsFrom(), and FWPathsPopup::scheduleReloadEvent().

7  {
8  using namespace boost::python;
9  PyObject *exc=nullptr, *val=nullptr, *trace=nullptr;
10  PyErr_Fetch(&exc,&val,&trace);
11  PyErr_NormalizeException(&exc,&val,&trace);
12  handle<> hExc(allow_null(exc));
13  handle<> hVal(allow_null(val));
14  handle<> hTrace(allow_null(trace));
15 
16  if(hTrace) {
17  object oTrace(hTrace);
18  handle<> hStringTr(PyObject_Str(oTrace.ptr()));
19  object stringTr(hStringTr);
20 //std::cout << "PR TR " << stringTr << " DONE "<< std::endl;
21  }
22 
23  if(hVal && hExc) {
24  object oExc(hExc);
25  object oVal(hVal);
26  handle<> hStringVal(PyObject_Str(oVal.ptr()));
27  object stringVal( hStringVal );
28 
29  handle<> hStringExc(PyObject_Str(oExc.ptr()));
30  object stringExc( hStringExc);
31 
32  //PyErr_Print();
33  throw cms::Exception(iType)
34  << "python encountered the error: "
35  // include python exception type
36  << PyString_AsString(stringExc.ptr()) << "\n"
37  // message in the python exception
38  << PyString_AsString(stringVal.ptr()) << "\n";
39  } else {
40  throw cms::Exception(iType)<<" unknown python problem occurred.\n";
41  }
42 }
T trace(ROOT::Math::SMatrix< T, N, N > const &matrix)
void edm::read_from_cin ( std::string &  output)

Definition at line 27 of file Parse.cc.

References geometryCSVtoXML::line, and AlCaHLTBitMon_QueryRunRegistry::string.

27  {
29  while (getline(std::cin, line)) {
30  output += line;
31  output += '\n';
32  }
33  }
std::string edm::read_whole_file ( std::string const &  filename)

only does the yacc interpretation

Definition at line 10 of file Parse.cc.

References edmScanValgrind::buffer, edm::errors::Configuration, Exception, corrVsCorr::filename, input, mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

10  {
12  std::ifstream input(filename.c_str());
13  if (!input) {
14  throw edm::Exception(errors::Configuration,"MissingFile")
15  << "Cannot read file " << filename;
16  }
18  while (getline(input, buffer)) {
19  // getline strips newlines; we have to put them back by hand.
20  result += buffer;
21  result += '\n';
22  }
23  return result;
24  }
static std::string const input
Definition: EdmProvDump.cc:44
std::shared_ptr< ParameterSet > edm::readConfig ( std::string const &  config)

Definition at line 42 of file MakeParameterSets.cc.

References PythonProcessDesc::parameterSet().

Referenced by XMLConfigReader::setEventsFile().

42  {
43  PythonProcessDesc pythonProcessDesc(config);
44  return pythonProcessDesc.parameterSet();
45  }
Definition: config.py:1
std::shared_ptr< ParameterSet > edm::readConfig ( std::string const &  config,
int  argc,
char *  argv[] 
)

same, but with arguments

Definition at line 48 of file MakeParameterSets.cc.

References PythonProcessDesc::parameterSet().

48  {
49  PythonProcessDesc pythonProcessDesc(config, argc, argv);
50  return pythonProcessDesc.parameterSet();
51  }
Definition: config.py:1
std::shared_ptr< ParameterSet > edm::readPSetsFrom ( std::string const &  fileOrString)

finds all the PSets used in the top level module referred as a file or as a string containing python commands. These PSets are bundled into a top level PSet from which they can be retrieved

Definition at line 61 of file MakeParameterSets.cc.

References edm::python::initializeModule(), makePSetsFromFile(), makePSetsFromString(), resolutioncreator_cfi::object, PythonParameterSet::pset(), pythonToCppException(), and edm::ParameterSet::swap().

Referenced by main(), and MakeVersionedSelector< reco::Muon >::operator()().

61  {
63 
64  boost::python::object mainModule = object(handle<>(borrowed(PyImport_AddModule(const_cast<char*>("__main__")))));
65 
66  boost::python::object mainNamespace = mainModule.attr("__dict__");
67  PythonParameterSet theProcessPSet;
68  mainNamespace["topPSet"] = ptr(&theProcessPSet);
69 
70  try {
71  // if it ends with py, it's a file
72  if(module.substr(module.size()-3) == ".py") {
73  makePSetsFromFile(module,mainNamespace);
74  } else {
75  makePSetsFromString(module,mainNamespace);
76  }
77  }
78  catch( error_already_set const& ) {
79  pythonToCppException("Configuration");
80  Py_Finalize();
81  }
82  auto returnValue = std::make_shared<ParameterSet>();
83  theProcessPSet.pset().swap(*returnValue);
84  return returnValue;
85  }
static void makePSetsFromString(std::string const &module, boost::python::object &mainNamespace)
void pythonToCppException(const std::string &iType)
Definition: PythonWrapper.cc:6
void swap(ParameterSet &other)
edm::ParameterSet & pset()
void initializeModule()
Definition: vlib.h:208
static void makePSetsFromFile(std::string const &fileName, boost::python::object &mainNamespace)
void edm::reenableSigs ( sigset_t *  oldset)

Definition at line 72 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

Referenced by installCustomHandler().

73  {
74  // reenable the signals
75  MUST_BE_ZERO(pthread_sigmask(SIG_SETMASK,oldset,nullptr));
76  }
#define MUST_BE_ZERO(fun)
template<typename C >
Ptr<typename C::value_type> edm::refToPtr ( Ref< C, typename C::value_type, refhelper::FindUsingAdvance< C, typename C::value_type > > const &  ref)

Definition at line 18 of file RefToPtr.h.

Referenced by ParticleLevelProducer::addGenJet(), EgammaHLTFilteredObjProducer< OutCollType >::addObj(), PFEGammaAlgo::attachPSClusters(), PFEGammaProducer::createSingleLegConversions(), DeepBoostedJetTagInfoProducer::fillParticleFeatures(), EGammaMvaEleEstimator::isoMvaValue(), noPuUtils::isVertexAssociated(), reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::operator()(), reco::operator<<(), ParticleLevelProducer::produce(), pat::PATTauSlimmer::produce(), pat::PackedPFCandidateRefMixer::produce(), pat::PATSecondaryVertexSlimmer::produce(), IsolatedTrackCleaner::produce(), GEDPhotonCoreProducer::produce(), pat::PATGenJetSlimmer::produce(), pat::PATJetSlimmer::produce(), pat::PATMuonSlimmer::produce(), TauGenJetProducer::produce(), JetSubstructurePacker::produce(), PFEGammaToCandidate::run(), and reco::PFTau::sourceCandidatePtr().

19  {
20  typedef typename C::value_type T;
21  if (ref.isNull()) {
22  return Ptr<T>();
23  }
24  if (ref.isTransient()) {
25  return Ptr<T>(ref.get(), ref.key());
26  } else {
27  //Another thread could change this value so get only once
28  EDProductGetter const* getter = ref.productGetter();
29  if (getter) {
30  return Ptr<T>(ref.id(), ref.key(), getter);
31  }
32  }
33  return Ptr<T>(ref.id(), ref.get(), ref.key());
34  }
long double T
std::vector< std::vector< std::string >::const_iterator > edm::regexMatch ( std::vector< std::string > const &  strings,
std::regex const &  regexp 
)

Definition at line 30 of file RegexMatch.cc.

References mps_fire::i, and patRefSel_triggerMatching_cfi::matches.

Referenced by triggerExpression::PathReader::init(), HLTHighLevel::init(), ZCounting::initHLT(), edm::EventSelector::initPathNames(), dqmservices::DQMStreamerReader::matchTriggerSel(), hltdqm::passTrig(), regexMatch(), and dqmservices::TriggerSelector::TreeElement::TreeElement().

30  {
31  std::vector< std::vector<std::string>::const_iterator> matches;
32  for (std::vector<std::string>::const_iterator i = strings.begin(), iEnd = strings.end(); i != iEnd; ++i) {
33  if (std::regex_match((*i), regexp)) {
34  matches.push_back(i);
35  }
36  }
37  return matches;
38  }
std::vector< std::vector< std::string >::const_iterator > edm::regexMatch ( std::vector< std::string > const &  strings,
std::string const &  pattern 
)

Definition at line 41 of file RegexMatch.cc.

References glob2reg(), regexMatch(), and fetchall_from_DQM_v2::regexp.

41  {
42  std::regex regexp(glob2reg(pattern));
43  return regexMatch(strings, regexp);
44  }
std::string glob2reg(std::string const &pattern)
Definition: RegexMatch.cc:22
std::vector< std::vector< std::string >::const_iterator > regexMatch(std::vector< std::string > const &strings, std::regex const &regexp)
Definition: RegexMatch.cc:30
void edm::replaceString ( std::string &  demangledName,
std::string const &  from,
std::string const &  to 
)

Definition at line 88 of file TypeDemangler.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::TypeWithDict::cppName(), L1GtVhdlTemplateFile::findAndReplaceString(), and typeDemangle().

88  {
89  // from must not be a substring of to.
90  std::string::size_type length = from.size();
92  while((pos = demangledName.find(from, pos)) != std::string::npos) {
93  demangledName.replace(pos, length, to);
94  }
95  }
uint16_t size_type
void edm::resolveSymbolicLinks ( std::string &  fullPath)

Definition at line 48 of file resolveSymbolicLinks.cc.

References runEdmFileComparison::found.

48  {
49  bool found = resolveOneSymbolicLink(fullPath);
50  if(found) {
51  resolveSymbolicLinks(fullPath);
52  }
53  }
void resolveSymbolicLinks(std::string &fullPath)
static const edm::ParameterSetDescriptionFillerPluginFactory::PMaker<edm::ParameterSetDescriptionFiller< HiMixingModule > > edm::s_filler__LINE__ ( "HiMixingModule"  )
static
static const edm::MakerPluginFactory ::PMaker< edm::WorkerMaker< HiMixingModule > > edm::s_maker__LINE__ ( "HiMixingModule"  )
static
template<typename ForwardSequence , typename Datum >
bool edm::search_all ( ForwardSequence const &  s,
Datum const &  d 
)
inline
template<typename ForwardSequence , typename Predicate >
bool edm::search_if_in_all ( ForwardSequence const &  s,
Predicate const &  p 
)
inline

Definition at line 68 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p.

68  {
69  return std::find_if(s.begin(), s.end(), p) != s.end();
70  }
template<typename T , typename U >
U edm::second ( std::pair< T, U > const &  p)

Definition at line 250 of file ParameterSet.cc.

Referenced by FilterOR::accept(), HGCDigitizer::accumulate(), CaloTruthAccumulator::accumulateEvent(), TkTrackingRegionsMargin< float >::add(), edm::eventsetup::EventSetupRecordImpl::add(), pos::PixelConfigFile::addAlias(), FWTrackHitsDetailView::addModules(), FWConvTrackHitsDetailView::addModules(), PrintGeomSummary::addName(), Hector::addPartToHepMC(), CTPPSHector::addPartToHepMC(), TrackingRecHitProduct::addRecHit(), SurveyInputTrackerFromDB::addSurveyInfo(), SurveyMisalignmentInput::addSurveyInfo(), HGCalTriggerBackend::HGCalTriggerSimCluster< FECODEC, DATA >::addToCluster(), HGCalTriggerBackend::HGCalTriggerSimCluster< FECODEC, DATA >::addToClusterShapes(), gen::EvtGenInterface::addToHepMC(), EcalPreshowerGeometry::alignmentTransformIndexLocal(), PFCandConnector::analyseNuclearWPrim(), PFCandConnector::analyseNuclearWSec(), SiStripDetVOffHandler::analyze(), SiStripThresholdBuilder::analyze(), EcalDQMonitorTask::analyze(), L1TGlobalSummary::analyze(), RPCGeometryServTest::analyze(), DTPreCalibrationTask::analyze(), DTNoiseCalibration::analyze(), BxTiming::analyze(), HcalQIEDataCheck::analyze(), HcalPedestalWidthsCheck::analyze(), HcalHBHEMuonSimAnalyzer::analyze(), HeavyFlavorValidation::analyze(), DTNoiseTask::analyze(), TopMonitor::analyze(), L1TRPCTPG::analyze(), l1t::GtRecordDump::analyze(), HLTScalers::analyze(), HcalHBHEMuonAnalyzer::analyze(), DTDigiTask::analyze(), HLTExoticaSubAnalysis::analyze(), EcalSelectiveReadoutValidation::analyzeEB(), EcalSelectiveReadoutValidation::analyzeEE(), L1GtAnalyzer::analyzeL1GtUtilsCore(), SiStripBadAPVAlgorithmFromClusterOccupancy::AnalyzeOccupancy(), SiStripBadAPVandHotStripAlgorithmFromClusterOccupancy::AnalyzeOccupancy(), HGCalTBAnalyzer::analyzeRecHits(), HGCalTimingAnalyzer::analyzeSimHits(), HGCalTBAnalyzer::analyzeSimHits(), SurveyDataConverter::applyFineSurveyInfo(), TrackerHitAssociator::associateHit(), L1GtTriggerMenuTester::associateL1SeedsHltPath(), VertexAssociatorByPositionAndTracks::associateRecoToSim(), VertexAssociatorByPositionAndTracks::associateSimToReco(), Tracker_OldtoNewConverter::beginJob(), GctFormatTranslateV35::blockToRctEmCand(), GctFormatTranslateV38::blockToRctEmCand(), GctFormatTranslateMCLegacy::blockToRctEmCand(), SiStripGainFromCalibTree::bookDQMHistos(), QIE11Task::bookHistograms(), SimHitsValidationHcal::bookHistograms(), BxTiming::bookHistograms(), HLTSeedL1LogicScalers::bookHistograms(), SiStripGainsPCLWorker::bookHistograms(), CSCGeometryParsFromDD::build(), ME0PadDigiClusterProducer::buildClusters(), GEMPadDigiClusterProducer::buildClusters(), RunRangeDependentPedeLabeler::buildRunRangeDependencyMap(), SeedFromGenericPairOrTriplet::buildSeed(), CocoaUnitDefinition::BuildUnitsTable(), ALIUnitDefinition::BuildUnitsTable(), CSCEventData::calcALCTcrc(), FWInvMassDialog::Calculate(), JetPartonMatching::calculate(), ClusterShapeAlgo::Calculate_Covariances(), ClusterShapeAlgo::Calculate_e3x2(), ClusterShapeAlgo::Calculate_e3x3(), ClusterShapeAlgo::Calculate_e4x4(), ClusterShapeAlgo::Calculate_e5x5(), MultipleAlgoIterator::calculatePedestal(), ReflectedIterator::calculatePedestal(), PileUpSubtractor::calculatePedestal(), PedeLabelerBase::calibrationParamFromLabel(), cert_plot(), GEMCSCSegAlgoRR::chainHitsToSegm(), HiggsValidation::MonitoredDecays::channel(), AlignmentTwoBodyDecayTrackSelector::checkMETMass(), OniaPhotonConversionProducer::checkTkVtxCompatibility(), IsoTrig::chgIsolation(), SiStripAPVRestorer::cleaner_LocalMinimumAdder(), SiStripAPVRestorer::cleaner_MonotonyChecker(), PFMuonAlgo::cleanPunchThroughAndFakes(), TrackCleaner::cleanTracks(), SimTrackManager::cleanTracksWithHistory(), EcalClusterToolsT< noZS >::cluster2ndMoments(), SimplePlan1RechitCombiner::combine(), AlignableObjectId::commonGeometry(), L1TLSBlock::computeErrorFromRange(), GaussianSumUtilities1D::computeMode(), SiStripFecCabling::connections(), DDHCalBarrelAlgo::constructGeneralVolume(), DDHCalEndcapAlgo::constructGeneralVolume(), DDHCalBarrelAlgo::constructInsideDetectors(), DDHCalBarrelAlgo::constructInsideLayers(), DDHCalEndcapModuleAlgo::constructInsideModule(), DDHCalEndcapAlgo::constructInsideModule(), DDHCalEndcapModuleAlgo::constructInsideModule0(), DDHCalEndcapAlgo::constructInsideModule0(), DDHCalBarrelAlgo::constructInsideSector(), DDHCalEndcapAlgo::constructInsideSector(), DDAHcalModuleAlgo::constructLayers(), DDHGCalModule::constructLayers(), DDHGCalModuleAlgo::constructLayers(), DDHGCalTBModule::constructLayers(), DDHGCalEEAlgo::constructLayers(), DDHGCalHEAlgo::constructLayers(), DDHCalBarrelAlgo::constructMidLayer(), DDHCalEndcapModuleAlgo::constructScintLayer(), DDHCalEndcapAlgo::constructScintLayer(), DDHCalBarrelAlgo::constructSideLayer(), SiPixelStatusHarvester::constructTag(), CaloTowersCreationAlgo::convert(), GctFormatTranslateV35::convertBlock(), GctFormatTranslateMCLegacy::convertBlock(), GctFormatTranslateV38::convertBlock(), popcon::PopConSourceHandler< CastorPedestals >::convertFromOld(), FFTJetCorrectorSequence< Jet, InitialConverter, FinalConverter >::correct(), TauJetCorrector::correction(), JetPartonCorrector::correction(), LatencyHistosUsingDb::create(), PFCand_AssoMapAlgos::CreatePFCandToVertexMap(), PF_PU_AssoMapAlgos::CreateTrackToVertexMap(), PFCand_AssoMapAlgos::CreateVertexToPFCandMap(), PF_PU_AssoMapAlgos::CreateVertexToTrackMap(), HFSimpleTimeCheck::determineAnodeStatus(), PFRecoTauDiscriminationByInvMass::discriminate(), SurveyPxbDicer::doDice(), VectorDoublet< Vector3D, Vector3D >::dot(), drawMap(), DTSC::DTSectCollsort2(), MuScleFit::duringFastLoop(), ZeeCalibration::duringLoop(), EcalClusterToolsT< noZS >::e2nd(), EcalDQMonitorTask::EcalDQMonitorTask(), EcalMonitorPrescaler::EcalMonitorPrescaler(), EcalClusterToolsT< noZS >::eMax(), edm::service::ELoutput::emitToken(), iterator_pair_as_a_range< I >::end(), TowerBlockFormatter::EndEvent(), IsoTrig::endJob(), AlcaBeamMonitor::endLuminosityBlock(), AlcaBeamSpotHarvester::endRun(), AlcaBeamMonitorClient::endRun(), SiPixelStatusHarvester::endRunProduce(), cond::serialization::access< T, typename std::enable_if< std::is_integral< T >::value or std::is_enum< T >::value >::type >::equal_(), cond::serialization::access< T, typename std::enable_if< std::is_floating_point< T >::value >::type >::equal_(), cond::serialization::access< std::string >::equal_(), cond::serialization::access< std::bitset< N > >::equal_(), cond::serialization::access< T, typename std::enable_if< std::is_pointer< T >::value >::type >::equal_(), cond::serialization::access< T[N]>::equal_(), DDTIDModulePosAlgo::execute(), DDHGCalCell::execute(), DDHGCalWafer8::execute(), DDTIDModuleAlgo::execute(), DDTOBAxCableAlgo::execute(), DDTOBRodAlgo::execute(), DDTOBRadCableAlgo::execute(), DDTrackerLinear::execute(), DDTrackerXYZPosAlgo::execute(), DDTrackerZPosAlgo::execute(), DDTIBLayerAlgo_MTCC::execute(), DDTIBRadCableAlgo_MTCC::execute(), DDPixBarLayerUpgradeAlgo::execute(), DDPixFwdDiskAlgo::execute(), DDPixPhase1FwdDiskAlgo::execute(), DDTrackerLinearXY::execute(), DDTECCoolAlgo::execute(), DDTECOptoHybAlgo::execute(), DDHCalTBCableAlgo::execute(), DDPixBarLayerAlgo::execute(), DDBHMAngular::execute(), DDHCalForwardAlgo::execute(), DDTIBLayerAlgo::execute(), DDHCalTBZposAlgo::execute(), DDTIDRingAlgo::execute(), DDTrackerAngular::execute(), DDTrackerPhiAlgo::execute(), DDTrackerPhiAltAlgo::execute(), DDTECAxialCableAlgo::execute(), DDTIDAxialCableAlgo::execute(), DDTrackerAngularV1::execute(), DDHCalFibreBundle::execute(), DDTECPhiAltAlgo::execute(), DDHCalLinearXY::execute(), DDTECModuleAlgo::execute(), DDTECPhiAlgo::execute(), DDTrackerRingAlgo::execute(), DDPixFwdBlades::execute(), CommissioningHistograms::extractHistograms(), TrackTimeValueMapProducer::extractTrackVertexTime(), BPHWriteSpecificDecay::fill(), SingleTopTChannelLepton_miniAOD::MonitorEnsemble::fill(), TopSingleLepton_miniAOD::MonitorEnsemble::fill(), TopSingleLepton::MonitorEnsemble::fill(), OutInConversionSeedFinder::fillClusterSeeds(), GenParticleProducer::fillDaughters(), PixelTripletLargeTipGenerator::fillDescriptions(), DTLocalTriggerTest::fillGlobalSummary(), edm::RootFile::fillIndexIntoFile(), EcalTrigPrimFunctionalAlgo::fillMap(), EcalEBTrigPrimTestAlgo::fillMap(), SiStripCMMonitorPlugin::fillMaps(), SiStripNoisesDQM::fillMEsForLayer(), SiStripBackPlaneCorrectionDQM::fillMEsForLayer(), SiStripLorentzAngleDQM::fillMEsForLayer(), SiStripPedestalsDQM::fillMEsForLayer(), SiStripThresholdDQM::fillMEsForLayer(), SiStripApvGainsDQM::fillMEsForLayer(), SiStripQualityDQM::fillMEsForLayer(), SiPixelUtility::fillPaveText(), RunDCSHVDat::fillTheMapByTime(), GEMTrackMatch::FillWithTrigger(), ProbeTreeProducer::filter(), CSCDigiValidator::filter(), JetHTJetPlusHOFilter::filter(), SinglePhotonJetPlusHOFilter::filter(), CTPPSHector::filterCTPPS(), Hector::filterD1(), Hector::filterFP420(), Hector::filterZDC(), pftools::SpaceManager::findCalibrator(), EcalTBCrystalMap::findCrystalAngles(), SymmetryFit::findUsableMinMax(), CosmicMuonSmoother::fit(), KFTrajectoryFitter::fitOne(), JetCoreClusterSplitter::fittingSplit(), alpgen::fixEventHiggsTTbar(), alpgen::fixEventSingleTop(), alpgen::fixEventTTbar(), NuclearTester::fwdEstimate(), SiStripGainsPCLHarvester::gainQualityMonitor(), edm::RangeMap< int, std::vector< float >, edm::CopyPolicy< float > >::get(), DTTPGParameters::get(), DTLVStatus::get(), edm::helper::IndexRangeAssociation::get(), DTHVStatus::get(), DTRangeT0::get(), DTTtrig::get(), DTDeadFlag::get(), DTPerformance::get(), DTStatusFlag::get(), DTMtime::get(), GctFormatTranslateBase::getBlockDescription(), CalibrationInterface< CategoryT, CalibDataT >::getCalibData(), lumi::fPoly::getCorrection(), SiStripPsuDetIdMap::getDcuId(), SiStripPsuDetIdMap::getDetectorLocation(), hcaldqm::quantity::getEid_FED(), hcaldqm::quantity::getEid_FEDuTCA(), l1t::L1TGlobalUtil::getFinalDecisionByBit(), l1t::L1TGlobalUtil::getFinalDecisionByName(), LMFCorrCoefDat::getFlag(), metsig::SignAlgoResolutions::getfunc(), l1t::L1TGlobalUtil::getInitialDecisionByBit(), l1t::L1TGlobalUtil::getInitialDecisionByName(), l1t::L1TGlobalUtil::getIntermDecisionByBit(), l1t::L1TGlobalUtil::getIntermDecisionByName(), EcalLaserDbService::getLaserCorrection(), HcalLayerDepthMap::getLayerDepth(), pftools::IO::GetLineData(), EcalElectronicsMapping::getLMNumber(), l1t::L1TGlobalUtil::getMaskByBit(), l1t::L1TGlobalUtil::getMaskByName(), PileUpSubtractor::getMeanAtTower(), FillInfoPopConSourceHandler::getNewObjects(), pftools::IO::GetNextLineData(), trigger::TriggerEventWithRefs::getObjects(), LMFRunIOV::getParameters(), PileUpSubtractor::getPileUpAtTower(), l1t::L1TGlobalUtil::getPrescaleByBit(), l1t::L1TGlobalUtil::getPrescaleByName(), fastTrackingUtilities::getRecHitCombinationIndex(), OMTFConfiguration::getRegionNumberFromMap(), HcalDDDRecConstants::getRZ(), LMFCorrCoefDat::getSeqID(), LMFCorrCoefDat::getSequence(), PileUpSubtractor::getSigmaAtTower(), RPCSeedPattern::getSpecialAlgorithmErrorMatrix(), SiStripBaseCondObjDQM::getSummaryMEs(), HcalDDDRecConstants::getThickActive(), ZIterativeAlgorithmWithFit::getWeight(), hgcal::ClusterTools::getWidths(), SimTrackManager::giveMotherNeeded(), HcalPiecewiseLinearFunctor::HcalPiecewiseLinearFunctor(), HcalTopology::HcalTopology(), HFPreRecHit::HFPreRecHit(), PixelTripletLargeTipGenerator::hitTriplets(), HLTEgammaEtFilterPairs::hltFilter(), HLTJetSortedVBFFilter< T >::hltFilter(), SimTrackManager::idSavedTrack(), L1MuGMTLUT::Init(), init_filter(), MultiHitGeneratorFromChi2::initES(), HcalLayerDepthMap::initialize(), HcalDDDRecConstants::initialize(), L1GtUtils::LogicalExpressionL1Results::initialize(), edm::ParentageRegistry::insertMapped(), egammaisolation::EgammaRange< float >::inside(), muonisolation::Range< float >::inside(), TRange< int >::inside(), PixelRecoRange< float >::inside(), EcalTB07DaqFormatter::interpretRawData(), EcalTBDaqFormatter::interpretRawData(), APVCyclePhaseProducerFromL1TS::isBadRun(), TtGenEvent::isFullLeptonic(), GEMSegmentAlgorithm::isGoodToMerge(), AntiElectronIDCut2::isInEcalCrack(), RPCFw::isMajor(), CSCGEMMotherboard::isPadInOverlap(), CSCDDUMap::item(), CSCChamberMap::item(), CSCCrateMap::item(), TtEvent::jetLeptonCombination(), L1GtUtils::LogicalExpressionL1Results::l1Results(), HcalIndexLookup::largestIndex(), fftjetcms::LinInterpolatedTable1D::LinInterpolatedTable1D(), G4SimEvent::load(), dqmservices::DQMFileIterator::LumiEntry::load_json(), dqmservices::DQMFileIterator::EorEntry::load_json(), CalorimetryManager::loadFromEcalBarrel(), CalorimetryManager::loadFromEcalEndcap(), CalorimetryManager::loadFromHcal(), HcalFlexiHardcodeGeometryLoader::makeHECells(), pos::PixelConfigFile::makeKey(), match(), JetPartonMatching::matchingPtOrderedMinDist(), egammaisolation::EgammaRange< float >::max(), muonisolation::Range< float >::max(), TRange< int >::max(), PixelRecoRange< float >::max(), egammaisolation::EgammaRange< float >::mean(), muonisolation::Range< float >::mean(), TRange< int >::mean(), PixelRecoRange< float >::mean(), lhef::LHEReader::next(), Quantile::next(), MultipleAlgoIterator::offsetCorrectJets(), ReflectedIterator::offsetCorrectJets(), PileUpSubtractor::offsetCorrectJets(), DDValuePair::operator const double &(), DDValuePair::operator double &(), PhysicsTools::AtomicId::operator!=(), CastorDbASCIIIO::DetIdLess::operator()(), reco::tau::RecoTauDiscriminantFromDiscriminator::operator()(), CheckHitPattern::operator()(), reco::tau::RecoTauPiZeroStripPlugin::operator()(), reco::tau::RecoTauPiZeroStripPlugin2::operator()(), reco::tau::RecoTauPiZeroStripPlugin3::operator()(), L1MuGMTExtendedCand::Rank::operator()(), SimpleL1MuGMTCand::Rank::operator()(), PhysicsTools::AtomicId::operator<(), operator<<(), PhysicsTools::AtomicId::operator<=(), PhysicsTools::AtomicId::operator==(), PhysicsTools::AtomicId::operator>(), PhysicsTools::AtomicId::operator>=(), ClusterClusterMapping::overlap(), CovarianceParameterization::pack(), l1t::Parameter::Parameter(), reco::modules::TrackerTrackHitFilter::parseStoN(), PartitionGenerator::partitions(), L1MuDTAssignmentUnit::PhiAU(), L1MuBMAssignmentUnit::PhiAU(), PhiBorderFinder::PhiBorderFinder(), HiggsValidation::MonitoredDecays::position(), SiStripRegionCabling::position(), DDHGCalHEAlgo::positionMix(), DDAHcalModuleAlgo::positionSensitive(), DDHGCalTBModule::positionSensitive(), DDHGCalEEAlgo::positionSensitive(), DDHGCalHEAlgo::positionSensitive(), Quantile::prev(), TtFullLeptonicEvent::print(), TrackerHitAssociator::printDetBnchEvtTrk(), PixelTemplateSmearerBase::process(), hcalCalib::Process(), PFAlgoTestBenchElectrons::processBlock(), PFAlgo::processBlock(), cscdqm::EventProcessor::processCSC(), DDLSpecPar::processElement(), DDLString::processElement(), DDLNumeric::processElement(), TTTrackAssociator< T >::produce(), CandOneToManyDeltaRMatcher::produce(), TtFullLepKinSolutionProducer::produce(), PFConversionProducer::produce(), HcalRawToDigi::produce(), DTFakeT0ESProducer::produce(), PFTrackProducer::produce(), L1ExtraParticleMapProd::produce(), RunManagerMTWorker::produce(), PF_PU_FirstVertexTracks::produce(), HLTScoutingMuonProducer::produce(), PFCand_NoPU_WithAM::produce(), HFPreReconstructor::produce(), JetPlusTrackProducerAA::produce(), PixelJetPuId::produce(), BoostedDoubleSVProducer::produce(), reco::PhysObjectMatcher< C1, C2, S, D, Q >::produce(), BTagProbabilityToDiscriminator::produce(), RunManager::produce(), NuclearTrackCorrector::produce(), emtf::Forest::rankVariables(), RBorderFinder::RBorderFinder(), RunSummaryRead::readData(), L1TriggerScalerRead::readData(), SiStripDetVOffBuilder::readLastValueFromFile(), FedRawDataInputSource::readWorker(), GroupedDAFHitCollector::recHits(), CSCEfficiency::recHitSegment_Efficiencies(), CSCEfficiency::recSimHitEfficiency(), SiStripDetVOffBuilder::reduce(), SiStripDetVOffBuilder::reduction(), CandidateSeededTrackingRegionsProducer::regions(), PointSeededTrackingRegionsProducer::regions(), jsoncollector::FastMonitor::registerGlobalMonitorable(), pftools::CaloWindow::relativePosition(), DDI::rep_type< DDName, pimpl_type >::rep(), L1GtUtils::LogicalExpressionL1Results::reset(), l1t::L1TGlobalUtil::resetDecisionVectors(), L1TOccupancyClientHistogramService::resetHisto(), l1t::L1TGlobalUtil::resetPrescaleVectors(), l1t::L1TGlobalUtil::retrieveL1Event(), l1t::L1TGlobalUtil::retrieveL1Setup(), EmbeddingHepMCFilter::DecayChannel::reverse(), TkTrackingRegionsMargin< float >::right(), EcalClusterToolsT< noZS >::roundnessBarrelSuperClusters(), EcalClusterToolsT< noZS >::roundnessBarrelSuperClustersUserExtended(), reco::modules::TrackerTrackHitFilter::Rule::Rule(), DTTSS::run(), EcalEBTrigPrimTestAlgo::run(), DTTSM::run(), DTSC::run(), MillePedeAlignmentAlgorithm::run(), EcalTrigPrimFunctionalAlgo::run_part2(), DTLocalTriggerLutTest::runClientDiagnostic(), DTTriggerEfficiencyTest::runClientDiagnostic(), math::Graph< N, E >::value_type::secondToValue(), SortCollectionSelector< InputCollection, Comparator, OutputCollection, StoreContainer, RefAdder >::select(), FWTableView::selectCollection(), MuScleFit::selectMuons(), PhotonConversionTrajectorySeedProducerFromSingleLegAlgo::selectPriVtxCompatibleWithTrack(), DTLVStatus::set(), DTTPGParameters::set(), DTRangeT0::set(), DTHVStatus::set(), DTTtrig::set(), DTPerformance::set(), DTStatusFlag::set(), DTDeadFlag::set(), DTMtime::set(), PFElectronAlgo::SetActive(), pixeltemp::Cluster1DMerger< reco::Track >::setBeamSpot(), EGRegressionModifierV2::setConsumes(), EGPfIsolationModifierFromValueMaps::setConsumes(), EGRegressionModifierV1::setConsumes(), EGFull5x5ShowerShapeModifierFromValueMaps::setConsumes(), EGExtraInfoModifierFromValueMaps< MapType, OutputType >::setConsumes(), EcalDeadCellTriggerPrimitiveFilter::setEvtRecHitstatus(), FWEventItemsManager::setFrom(), CSCGEMMotherboard::setGEMGeometry(), TauJetCorrector::setParameters(), JetPartonCorrector::setParameters(), DDLSolid::setReference(), L1Analysis::L1AnalysisCSCTF::SetTracks(), ShallowTree::ShallowTree(), ConvBremSeedProducer::sharedHits(), SiStripGainESProducerTemplate< TDependentRecord, TInputRecord >::SiStripGainNormalizationFunction(), muonisolation::Range< float >::sort(), egammaisolation::EgammaRange< float >::sort(), TRange< int >::sort(), PixelRecoRange< float >::sort(), edm::OneToManyWithQualityGeneric< std::vector< reco::Track >, std::vector< reco::Vertex >, int, unsigned int >::sort(), PF_PU_AssoMapAlgos::SortAssociationMap(), PFCand_AssoMapAlgos::SortPFCandAssociationMap(), DTTSM::sortTSM2(), DTTSS::sortTSS2(), DAClusterizerInZ::split(), DAClusterizerInZ_vect::split(), DAClusterizerInZT_vect::split(), CombinationGenerator< T >::splitInTwoCollections(), splitNumeric(), splitString(), PropagateToMuon::startingState(), L1MuGMTLUT::PortDecoder::str(), StringBasedNTupler::StringBasedNTupler(), RPCDigiL1Link::strip(), StripCPE::StripCPE(), MagGeoBuilderFromDDD::summary(), PixelRecoRange< float >::swap(), CompositeLogicalTrajectoryFilter::TBC(), TwoBodyDecayTrajectoryFactory::trajectories(), L3MuonTrajectoryBuilder::trajectories(), GsfTrajectorySmoother::trajectory(), CovarianceParameterization::unpack(), MonopoleSteppingAction::update(), LatencyHistosUsingDb::update(), SiTrackerMultiRecHitUpdator::update(), TauJetCorrector::ParametrizationTauJet::value(), viewNameFrom(), MuonAssociatorByHitsHelper::write_matched_simtracks(), and VirtualJetProducer::writeJets().

250  {
251  return p.second;
252  }
static std::string const edm::separator ( ":"  )
static
template<typename T >
void edm::SetCustomStreamer ( )

Definition at line 41 of file CustomStreamer.h.

References GetRecoTauVFromDQM_MC_cff::cl.

41  {
42  TClass *cl = TClass::GetClass(typeid(T));
43  if (cl->GetStreamer() == 0) {
44  cl->AdoptStreamer(new CustomStreamer<T>());
45  }
46  }
long double T
template<typename T >
void edm::SetCustomStreamer ( T const &  )

Definition at line 50 of file CustomStreamer.h.

References GetRecoTauVFromDQM_MC_cff::cl.

50  {
51  TClass *cl = TClass::GetClass(typeid(T));
52  if (cl->GetStreamer() == 0) {
53  cl->AdoptStreamer(new CustomStreamer<T>());
54  }
55  }
long double T
void edm::setMaxLoggedErrorsSummaryIndicies ( unsigned int  iMax)

Definition at line 198 of file MessageSender.cc.

References errorSummaryMaps.

Referenced by edm::service::MessageLogger::MessageLogger().

198  {
199  errorSummaryMaps.resize(iMax);
200  }
static std::vector< tbb::concurrent_unordered_map< ErrorSummaryMapKey, AtomicUnsignedInt, ErrorSummaryMapKey::key_hash > > errorSummaryMaps
template<typename T , typename A >
void edm::setPtr ( std::vector< T, A > const &  obj,
std::type_info const &  iToType,
unsigned long  iIndex,
void const *&  oPtr 
)

Definition at line 72 of file setPtr.h.

References edm::detail::reallySetPtr().

Referenced by edm::WrapperBase::isPresent(), and edm::SortedCollection< FTLDataFrameT< ETLDetId, ETLSample > >::pop_back().

75  {
76  detail::reallySetPtr(obj, iToType, iIndex, oPtr);
77  }
void reallySetPtr(COLLECTION const &coll, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
Definition: setPtr.h:37
template<typename T , typename A >
void edm::setPtr ( std::list< T, A > const &  obj,
std::type_info const &  iToType,
unsigned long  iIndex,
void const *&  oPtr 
)

Definition at line 81 of file setPtr.h.

References edm::detail::reallySetPtr().

84  {
85  detail::reallySetPtr(obj, iToType, iIndex, oPtr);
86  }
void reallySetPtr(COLLECTION const &coll, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
Definition: setPtr.h:37
template<typename T , typename A >
void edm::setPtr ( std::deque< T, A > const &  obj,
std::type_info const &  iToType,
unsigned long  iIndex,
void const *&  oPtr 
)

Definition at line 90 of file setPtr.h.

References edm::detail::reallySetPtr().

93  {
94  detail::reallySetPtr(obj, iToType, iIndex, oPtr);
95  }
void reallySetPtr(COLLECTION const &coll, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
Definition: setPtr.h:37
template<typename T , typename A , typename Comp >
void edm::setPtr ( std::set< T, A, Comp > const &  obj,
std::type_info const &  iToType,
unsigned long  iIndex,
void const *&  oPtr 
)

Definition at line 99 of file setPtr.h.

References edm::detail::reallySetPtr().

102  {
103  detail::reallySetPtr(obj, iToType, iIndex, oPtr);
104  }
void reallySetPtr(COLLECTION const &coll, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
Definition: setPtr.h:37
template<typename T , typename SORT >
void edm::setPtr ( SortedCollection< T, SORT > const &  obj,
std::type_info const &  toType,
unsigned long  index,
void const *&  ptr 
)
inline
template<typename T , unsigned int M, typename P >
void edm::setPtr ( OwnArray< T, M, P > const &  obj,
std::type_info const &  toType,
unsigned long  index,
void const *&  ptr 
)
inline

Definition at line 469 of file OwnArray.h.

References edm::OwnArray< T, MAX_SIZE, P >::setPtr().

template<typename T , typename P >
void edm::setPtr ( OwnVector< T, P > const &  obj,
std::type_info const &  toType,
unsigned long  index,
void const *&  ptr 
)
inline

Definition at line 544 of file OwnVector.h.

References edm::OwnVector< T, P >::setPtr().

void edm::setRefCoreStreamer ( bool  resetAll = false)
EDProductGetter const * edm::setRefCoreStreamer ( EDProductGetter const *  ep)

Definition at line 97 of file RefCoreStreamer.cc.

References edm::EDProductGetter::switchProductGetter().

97  {
98  EDProductGetter const* returnValue=nullptr;
99  if (ep != nullptr) {
101  }
102  return returnValue;
103  }
static EDProductGetter const * switchProductGetter(EDProductGetter const *)
These can only be used internally by the framework.
void edm::setRefCoreStreamerInTClass ( )

Definition at line 77 of file RefCoreStreamer.cc.

References GetRecoTauVFromDQM_MC_cff::cl, and edm::RefCoreStreamer::RefCoreStreamer().

Referenced by edm::service::InitRootHandlers::InitRootHandlers().

77  {
78 
79  TClass *cl = TClass::GetClass("edm::RefCore");
80  TClassStreamer *st = cl->GetStreamer();
81  if (st == nullptr) {
82  cl->AdoptStreamer(new RefCoreStreamer());
83  }
84  {
85  TClass *cl = TClass::GetClass("edm::RefCoreWithIndex");
86  TClassStreamer *st = cl->GetStreamer();
87  if (st == nullptr) {
88  cl->AdoptStreamer(new RefCoreWithIndexStreamer());
89  }
90  }
91  }
void edm::setStandAloneMessageThreshold ( edm::ELseverityLevel const &  severity)

Definition at line 139 of file MessageLogger.cc.

References edm::MessageLoggerQ::standAloneThreshold().

Referenced by edm::Suppress_LogDebug_::log().

139  {
141 }
static void standAloneThreshold(edm::ELseverityLevel const &severity)
void edm::sigInventory ( )

Definition at line 141 of file UnixSignalHandlers.cc.

References MessageLogger_cfi::cerr, gen::k, and MUST_BE_ZERO.

142  {
143  sigset_t tmpset, oldset;
144 // Make a full house set of signals, except for SIGKILL = 9
145 // and SIGSTOP = 19 which cannot be blocked
146  MUST_BE_ZERO(sigfillset(&tmpset));
147  MUST_BE_ZERO(sigdelset(&tmpset, SIGKILL));
148  MUST_BE_ZERO(sigdelset(&tmpset, SIGSTOP));
149 // Swap it with the current sigset_t
150  MUST_BE_ZERO(pthread_sigmask( SIG_SETMASK, &tmpset, &oldset ));
151 // Now see what's included in the set
152  for(int k=1; k<NSIG; ++k) {
153  std::cerr << "sigismember is " << sigismember( &tmpset, k )
154  << " for signal " << std::setw(2) << k
155 #if defined(__linux__)
156  << " (" << strsignal(k) << ")"
157 #endif
158  << std::endl;
159  }
160 // Finally put the original sigset_t back
161  MUST_BE_ZERO(pthread_sigmask( SIG_SETMASK, &oldset, &tmpset));
162  }
int k[5][pyjets_maxn]
#define MUST_BE_ZERO(fun)
template<typename RandomAccessSequence >
void edm::sort_all ( RandomAccessSequence &  s)
inline
template<typename RandomAccessSequence , typename Predicate >
void edm::sort_all ( RandomAccessSequence &  s,
Predicate  p 
)
inline

Definition at line 127 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p.

127  {
128  std::sort(s.begin(), s.end(), p);
129  }
std::vector< LuminosityBlockRange > & edm::sortAndRemoveOverlaps ( std::vector< LuminosityBlockRange > &  lumiRange)

Definition at line 96 of file LuminosityBlockRange.cc.

References MillePedeFileConverter_cfg::e, mps_fire::i, merge(), sort_all(), and mitigatedMETSequence_cff::U.

96  {
97  if (lumiRange.size() <= 1U) return lumiRange;
98  sort_all(lumiRange, sortByStartLuminosityBlockID);
99  for (std::vector<LuminosityBlockRange>::iterator i = lumiRange.begin() + 1, e = lumiRange.end();
100  i != e; ++i) {
101  std::vector<LuminosityBlockRange>::iterator iprev = i - 1;
102  if (merge(*iprev, *i)) {
103  i = lumiRange.erase(iprev);
104  e = lumiRange.end();
105  }
106  }
107  return lumiRange;
108  }
void sort_all(RandomAccessSequence &s)
wrappers for std::sort
Definition: Algorithms.h:120
def merge(dictlist, TELL=False)
Definition: MatrixUtil.py:193
std::vector< EventRange > & edm::sortAndRemoveOverlaps ( std::vector< EventRange > &  eventRange)

Definition at line 102 of file EventRange.cc.

References MillePedeFileConverter_cfg::e, mps_fire::i, sort_all(), and mitigatedMETSequence_cff::U.

Referenced by edm::service::CondorStatusService::beginPost(), DQMRootSource::DQMRootSource(), and edm::EventSkipperByID::EventSkipperByID().

102  {
103  if (eventRange.size() <= 1U) return eventRange;
104  sort_all(eventRange, sortByStartEventIDSpecial);
105  for (std::vector<EventRange>::iterator i = eventRange.begin() + 1, e = eventRange.end();
106  i != e; ++i) {
107  std::vector<EventRange>::iterator iprev = i - 1;
108  if (mergeSpecial(*iprev, *i)) {
109  i = eventRange.erase(iprev);
110  e = eventRange.end();
111  }
112  }
113  return eventRange;
114  }
void sort_all(RandomAccessSequence &s)
wrappers for std::sort
Definition: Algorithms.h:120
static std::string const edm::source ( "source"  )
static
template<class OutIter >
bool edm::split ( OutIter  result,
std::string const &  string_to_split,
char  first,
char  sep,
char  last 
)

Definition at line 88 of file split.h.

References b, contextual_find(), contextual_find_not(), MillePedeFileConverter_cfg::e, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::ParameterSetConverter::convertParameterSets(), decode(), edm::ParameterSet::fromString(), and edm::VParameterSetEntry::VParameterSetEntry().

90 {
91  typedef std::string::const_iterator str_c_iter;
92  str_c_iter b = s.begin()
93  , e = s.end();
94 
95  if(static_cast<unsigned int>(e - b) < 2u) return false;
96 
97  if(*b == first) ++b;
98  else return false;
99 
100  if(*--e != last) return false;
101 
102  // invariant: we've found all items in [b..boi)
103  for(str_c_iter //boi = std::find_if(b, e, is_not_a(sep))
104  boi = contextual_find_not(b, e, first, sep, last)
105  , eoi
106  ; boi != e
107  //; boi = std::find_if(eoi, e, is_not_a(sep))
108  ; boi = contextual_find_not(eoi, e, first, sep, last))
109  {
110  // find end of current item:
111  //eoi = std::find_if(boi, e, is_a(sep));
112  eoi = contextual_find(boi, e, first, sep, last);
113 
114  // copy the item formed from characters in [boi..eoi):
115  *dest++ = std::string(boi, eoi);
116  } // for
117 
118  return true;
119 } // split< >()
FwdIter contextual_find_not(FwdIter b, FwdIter e, char first, char sep, char last)
Definition: split.h:70
double b
Definition: hdecay.h:120
FwdIter contextual_find(FwdIter b, FwdIter e, char first, char sep, char last)
Definition: split.h:48
void edm::squelchStandAloneMessageCategory ( std::string const &  category)

Definition at line 142 of file MessageLogger.cc.

References edm::MessageLoggerQ::squelch().

Referenced by edm::Suppress_LogDebug_::log().

142  {
144 }
static void squelch(std::string const &category)
template<typename RandomAccessSequence >
void edm::stable_sort_all ( RandomAccessSequence &  s)
inline
template<typename RandomAccessSequence , typename Predicate >
void edm::stable_sort_all ( RandomAccessSequence &  s,
Predicate  p 
)
inline

Definition at line 142 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p.

142  {
143  std::stable_sort(s.begin(), s.end(), p);
144  }
std::string_view edm::stemFromPath ( std::string_view  path)

Definition at line 4 of file stemFromPath.cc.

References begin, and end.

Referenced by edm::RootFile::validateFile().

4  {
5  auto begin = path.rfind("/");
6  if (begin == std::string_view::npos) {
7  begin = path.rfind(":");
8  if (begin == std::string_view::npos) {
9  // shouldn't really happen?
10  begin = 0;
11  } else {
12  begin += 1;
13  }
14  } else {
15  begin += 1;
16  }
17  auto end = path.find(".", begin);
18  return path.substr(begin, end - begin);
19  }
#define end
Definition: vmac.h:39
#define begin
Definition: vmac.h:32
std::string edm::stripLeadingDirectoryTree ( const std::string &  file)
std::string edm::stripNamespace ( std::string const &  theName)

Definition at line 97 of file TypeID.cc.

References EnergyCorrector::c, and egammaForCoreTracking_cff::depth.

Referenced by edm::TypeWithDict::byName(), and edm::TypeWithDict::unscopedName().

97  {
98  // Find last colon
99  std::string::size_type colonIndex = theName.rfind(':');
100  if(colonIndex == std::string::npos) {
101  // No colons, so no namespace to strip
102  return theName;
103  }
104  std::string::size_type bracketIndex = theName.rfind('>');
105  if(bracketIndex == std::string::npos || bracketIndex < colonIndex) {
106  // No '>' after last colon. Strip up to and including last colon.
107  return theName.substr(colonIndex+1);
108  }
109  // There is a '>' after the last colon.
110  int depth = 1;
111  for(size_t index = bracketIndex; index != 0; --index) {
112  char c = theName[index - 1];
113  if(c == '>') {
114  ++depth;
115  } else if(c == '<') {
116  --depth;
117  assert(depth >= 0);
118  } else if(depth == 0 && c == ':') {
119  return theName.substr(index);
120  }
121  }
122  return theName;
123  }
uint16_t size_type
bool edm::stripTemplate ( std::string &  theName)

Definition at line 72 of file TypeID.cc.

References first(), training_settings::idx, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::TypeID::userClassName().

72  {
73  std::string const spec("<,>");
74  char const space = ' ';
75  std::string::size_type idx = theName.find_first_of(spec);
76  if (idx == std::string::npos) {
77  return false;
78  }
81  if (theName[idx] == '<') {
82  after = theName.rfind('>');
83  assert (after != std::string::npos);
84  first = ++idx;
85  } else {
86  theName = theName.substr(0, idx);
87  }
88  std::string::size_type idxa = after;
89  while (space == theName[--idxa]) --after;
91  while (space == theName[idxf++]) ++first;
92  theName = theName.substr(first, after - first);
93  return true;
94  }
uint16_t size_type
void edm::subProcessDoGlobalBeginTransitionAsync ( WaitingTaskHolder  iHolder,
SubProcess iSubProcess,
LuminosityBlockPrincipal iPrincipal,
IOVSyncValue const &  iTS 
)
inline

Definition at line 38 of file globalTransitionAsync.h.

References edm::SubProcess::doBeginLuminosityBlockAsync(), and eostools::move().

Referenced by beginGlobalTransitionAsync().

38  {
39  iSubProcess.doBeginLuminosityBlockAsync(std::move(iHolder),iPrincipal, iTS);
40  }
def move(src, dest)
Definition: eostools.py:510
void edm::subProcessDoGlobalBeginTransitionAsync ( WaitingTaskHolder  iHolder,
SubProcess iSubProcess,
RunPrincipal iPrincipal,
IOVSyncValue const &  iTS 
)
inline

Definition at line 42 of file globalTransitionAsync.h.

References edm::SubProcess::doBeginRunAsync(), and eostools::move().

42  {
43  iSubProcess.doBeginRunAsync(std::move(iHolder),iPrincipal, iTS);
44  }
def move(src, dest)
Definition: eostools.py:510
void edm::subProcessDoGlobalEndTransitionAsync ( WaitingTaskHolder  iHolder,
SubProcess iSubProcess,
LuminosityBlockPrincipal iPrincipal,
IOVSyncValue const &  iTS,
bool  cleaningUpAfterException 
)
inline

Definition at line 46 of file globalTransitionAsync.h.

References edm::SubProcess::doEndLuminosityBlockAsync(), and eostools::move().

Referenced by endGlobalTransitionAsync().

46  {
47  iSubProcess.doEndLuminosityBlockAsync(std::move(iHolder),iPrincipal, iTS,cleaningUpAfterException);
48  }
def move(src, dest)
Definition: eostools.py:510
void edm::subProcessDoGlobalEndTransitionAsync ( WaitingTaskHolder  iHolder,
SubProcess iSubProcess,
RunPrincipal iPrincipal,
IOVSyncValue const &  iTS,
bool  cleaningUpAfterException 
)
inline

Definition at line 50 of file globalTransitionAsync.h.

References edm::SubProcess::doEndRunAsync(), and eostools::move().

50  {
51  iSubProcess.doEndRunAsync(std::move(iHolder), iPrincipal, iTS, cleaningUpAfterException);
52  }
def move(src, dest)
Definition: eostools.py:510
void edm::subProcessDoStreamBeginTransitionAsync ( WaitingTaskHolder  iHolder,
SubProcess iSubProcess,
unsigned int  i,
LuminosityBlockPrincipal iPrincipal,
IOVSyncValue const &  iTS 
)
inline

Definition at line 38 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamBeginLuminosityBlockAsync(), and eostools::move().

Referenced by beginStreamTransitionAsync().

38  {
39  iSubProcess.doStreamBeginLuminosityBlockAsync(std::move(iHolder),i,iPrincipal, iTS);
40  }
def move(src, dest)
Definition: eostools.py:510
void edm::subProcessDoStreamBeginTransitionAsync ( WaitingTaskHolder  iHolder,
SubProcess iSubProcess,
unsigned int  i,
RunPrincipal iPrincipal,
IOVSyncValue const &  iTS 
)
inline

Definition at line 42 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamBeginRunAsync(), and eostools::move().

42  {
43  iSubProcess.doStreamBeginRunAsync(std::move(iHolder),i,iPrincipal, iTS);
44  }
def move(src, dest)
Definition: eostools.py:510
void edm::subProcessDoStreamEndTransitionAsync ( WaitingTaskHolder  iHolder,
SubProcess iSubProcess,
unsigned int  i,
LuminosityBlockPrincipal iPrincipal,
IOVSyncValue const &  iTS,
bool  cleaningUpAfterException 
)
inline

Definition at line 46 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamEndLuminosityBlockAsync(), and eostools::move().

Referenced by endStreamTransitionAsync().

46  {
47  iSubProcess.doStreamEndLuminosityBlockAsync(std::move(iHolder),i,iPrincipal, iTS,cleaningUpAfterException);
48  }
def move(src, dest)
Definition: eostools.py:510
void edm::subProcessDoStreamEndTransitionAsync ( WaitingTaskHolder  iHolder,
SubProcess iSubProcess,
unsigned int  i,
RunPrincipal iPrincipal,
IOVSyncValue const &  iTS,
bool  cleaningUpAfterException 
)
inline

Definition at line 50 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamEndRunAsync(), and eostools::move().

50  {
51  iSubProcess.doStreamEndRunAsync(std::move(iHolder), i ,iPrincipal, iTS, cleaningUpAfterException);
52  }
def move(src, dest)
Definition: eostools.py:510
void edm::swap ( ProductID a,
ProductID b 
)
inline

Definition at line 49 of file ProductID.h.

References edm::ProductID::swap().

49  {
50  a.swap(b);
51  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
void edm::swap ( Parentage a,
Parentage b 
)
inline

Definition at line 63 of file Parentage.h.

References edm::Parentage::swap().

63  {
64  a.swap(b);
65  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<class T , class P >
void edm::swap ( CloningPtr< T, P > &  a,
CloningPtr< T, P > &  b 
)
inline

Definition at line 65 of file CloningPtr.h.

References edm::CloningPtr< T, P >::swap().

66  {
67  a.swap(b);
68  }
void edm::swap ( OrphanHandleBase a,
OrphanHandleBase b 
)
inline

Definition at line 75 of file OrphanHandleBase.h.

References edm::OrphanHandleBase::swap().

75  {
76  a.swap(b);
77  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
void edm::swap ( ProductData a,
ProductData b 
)
inline

Definition at line 80 of file ProductData.h.

References edm::ProductData::swap().

80  {
81  a.swap(b);
82  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<class T >
void edm::swap ( RefToBaseVector< T > &  a,
RefToBaseVector< T > &  b 
)
inline

Definition at line 90 of file RefToBaseVector.h.

References edm::RefToBaseVector< T >::swap().

90  {
91  a.swap(b);
92  }
void edm::swap ( ProcessHistory a,
ProcessHistory b 
)
inline

Definition at line 96 of file ProcessHistory.h.

References edm::ProcessHistory::swap().

96  {
97  a.swap(b);
98  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
void edm::swap ( TriggerResults lhs,
TriggerResults rhs 
)
inline

Definition at line 99 of file TriggerResults.h.

References edm::TriggerResults::swap().

99  {
100  lhs.swap(rhs);
101  }
void edm::swap ( ESHandleBase a,
ESHandleBase b 
)
inline

Definition at line 105 of file ESHandle.h.

References edm::ESHandleBase::swap().

106  {
107  a.swap(b);
108  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
void edm::swap ( HLTGlobalStatus lhs,
HLTGlobalStatus rhs 
)
inline

Free swap function.

Definition at line 110 of file HLTGlobalStatus.h.

References edm::HLTGlobalStatus::swap().

110  {
111  lhs.swap(rhs);
112  }
template<typename C >
void edm::swap ( Association< C > &  lhs,
Association< C > &  rhs 
)
inline

Definition at line 116 of file Association.h.

References edm::Association< C >::swap().

Referenced by L1TStage2CaloLayer1::analyze(), ftl_digitizer::FTLDigitizer< SensorPhysics, ElectronicsSim >::beginRun(), CaloSD::cleanHitCollection(), SimTrackManager::cleanTkCaloStateInfoMap(), CaloSD::clearHits(), SimCluster::clearHitsAndFractions(), edm::DetSetRefVector< Phase2ITPixelCluster >::DetSetRefVector(), edm::IndexIntoFile::doneFileInitialization(), HGCDigitizer::endRun(), LA_Filler_Fitter::fill(), CaloTruthAccumulator::finalizeEvent(), EgHLTOfflineSummaryClient::getEgHLTFiltersToMon_(), EgHLTOfflineSource::getHLTFilterNamesUsed(), hitfit::Constraint_Intermed_Labels::has_labels(), HcalDcsMap::HcalDcsMap(), HcalElectronicsMap::HcalElectronicsMap(), HcalFrontEndMap::HcalFrontEndMap(), HcalSiPMCharacteristics::HcalSiPMCharacteristics(), HGCDigitizer::HGCDigitizer(), HGCDigitizerBase< DFr >::HGCDigitizerBase(), PixelTripletNoTipGenerator::hitTriplets(), PixelTripletHLTGenerator::hitTriplets(), edm::IndexIntoFile::IndexIntoFileItr::IndexIntoFileItr(), edm::IndexIntoFile::inputFileClosed(), FastCandMatcher< C >::operator()(), CandMatcherBase< C1, C2 >::operator()(), edm::RefVectorBase< key_type >::operator=(), fwlite::Handle< Collection >::operator=(), edm::value_ptr< edm::service::MessageLoggerDefaults >::operator=(), TempTrajectory::operator=(), edm::Handle< GenericObject >::operator=(), edm::Handle< FWGenericObject >::operator=(), Trajectory::operator=(), TrajectoryMeasurement::operator=(), edm::PtrVector< reco::FFTJPTJet >::operator=(), edm::DetSetRefVector< T, C >::operator=(), edm::SortedCollection< FTLDataFrameT< ETLDetId, ETLSample > >::pop_back(), FWRecoGeometryESProducer::produce(), StripCompactDigiSimLinksProducer::produce(), PFElecTkProducer::produce(), FastjetJetProducer::produceTrackJets(), MultiHitGeneratorFromChi2::refit2Hits(), HGCal3DClustering::reset(), SimTrackManager::reset(), HGCalImagingAlgo::reset(), SubjetFilterAlgorithm::run(), SiStripBaseCondObjDQM::selectModules(), hitfit::Top_Decaykin::solve_nu(), hitfit::Top_Decaykin::solve_nu_tmass(), DynamicTruncation::sort(), SimTrackManager::storeTracks(), FWGUIManager::subviewSwapped(), HcalDataFrameContainer< QIE10DataFrame >::swap(), edm::Handle< GenericObject >::swap(), edm::RefToBaseProd< T >::swap(), edm::Handle< FWGenericObject >::swap(), edm::RefProd< C >::swap(), edmNew::DetSetVector< edm::Ref< edmNew::DetSetVector< SiStripCluster >, SiStripCluster, edmNew::DetSetVector< SiStripCluster >::FindForDetSetVector > >::swap(), and timestudy::SleepingServer::threadWork().

116  {
117  lhs.swap(rhs);
118  }
template<class T >
void edm::swap ( DetSet< T > &  a,
DetSet< T > &  b 
)
inline

Definition at line 119 of file DetSet.h.

References edm::DetSet< T >::swap().

119  {
120  a.swap(b);
121  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
void edm::swap ( BasicHandle a,
BasicHandle b 
)
inline

Definition at line 129 of file BasicHandle.h.

References edm::BasicHandle::swap().

Referenced by edm::BasicHandle::operator=(), and edm::BasicHandle::swap().

129  {
130  a.swap(b);
131  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
void edm::swap ( HandleBase a,
HandleBase b 
)
inline

Definition at line 129 of file HandleBase.h.

References edm::HandleBase::swap().

Referenced by edm::HandleBase::operator=(), and edm::HandleBase::swap().

129  {
130  a.swap(b);
131  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
void edm::swap ( ErrorObj a,
ErrorObj b 
)
inline

Definition at line 134 of file ErrorObj.h.

References edm::ErrorObj::swap().

134  {
135  a.swap(b);
136 }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
void edm::swap ( FileInPath a,
FileInPath b 
)
inline

Definition at line 140 of file FileInPath.h.

References edm::FileInPath::swap().

141  {
142  a.swap(b);
143  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename KEY >
void edm::swap ( RefVectorBase< KEY > &  a,
RefVectorBase< KEY > &  b 
)
inline

swap two vectors

Definition at line 154 of file RefVectorBase.h.

References edm::RefVectorBase< KEY >::swap().

154  {
155  a.swap(b);
156  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<class T >
void edm::swap ( EDCollection< T > &  a,
EDCollection< T > &  b 
)
inline

Definition at line 161 of file EDCollection.h.

References edm::EDCollection< T >::swap().

162  {
163  a.swap(b);
164  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
void edm::swap ( edm::RefCore lhs,
edm::RefCore rhs 
)
inline

Definition at line 163 of file RefCore.h.

References edm::RefCore::swap().

163  {
164  lhs.swap(rhs);
165  }
void swap(RefCore &) noexcept
Definition: RefCore.h:157
template<typename K , typename T >
void edm::swap ( MapOfVectors< K, T > &  lhs,
MapOfVectors< K, T > &  rhs 
)
inline

Definition at line 165 of file MapOfVectors.h.

References edm::MapOfVectors< K, T >::swap().

165  {
166  lhs.swap(rhs);
167  }
void edm::swap ( edm::RefCoreWithIndex lhs,
edm::RefCoreWithIndex rhs 
)
inline

Definition at line 169 of file RefCoreWithIndex.h.

References edm::RefCoreWithIndex::swap().

169  {
170  lhs.swap(rhs);
171  }
void swap(RefCoreWithIndex &)
template<typename C , typename T , typename F >
void edm::swap ( RefVector< C, T, F > &  a,
RefVector< C, T, F > &  b 
)
inline

Definition at line 186 of file RefVector.h.

References a, and b.

186  {
187  a.swap(b);
188  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T >
void edm::swap ( edm::RefToBaseProd< T > const &  lhs,
edm::RefToBaseProd< T > const &  rhs 
)
inline

Definition at line 191 of file RefToBaseProd.h.

References edm::RefToBaseProd< T >::swap().

191  {
192  lhs.swap(rhs);
193  }
void swap(RefToBaseProd< T > &)
template<typename ID , typename C , typename P >
void edm::swap ( IDVectorMap< ID, C, P > &  a,
IDVectorMap< ID, C, P > &  b 
)
inline

Definition at line 192 of file IDVectorMap.h.

References edm::IDVectorMap< ID, C, P >::swap().

192  {
193  a.swap(b);
194  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T >
void edm::swap ( value_ptr< T > &  vp1,
value_ptr< T > &  vp2 
)
inline

Definition at line 199 of file value_ptr.h.

References edm::value_ptr< T >::swap().

199 { vp1.swap(vp2); }
template<typename T >
void edm::swap ( PtrVector< T > &  lhs,
PtrVector< T > &  rhs 
)
inline

Definition at line 213 of file PtrVector.h.

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

213  {
214  lhs.swap(rhs);
215  }
template<typename C >
void edm::swap ( RefProd< C > const &  lhs,
RefProd< C > const &  rhs 
)
inline

Definition at line 217 of file RefProd.h.

217  {
218  lhs.swap(rhs);
219  }
template<typename ID , typename C , typename P >
void edm::swap ( RangeMap< ID, C, P > &  a,
RangeMap< ID, C, P > &  b 
)
inline

Definition at line 221 of file RangeMap.h.

References edm::RangeMap< ID, C, P >::swap().

221  {
222  a.swap(b);
223  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
void edm::swap ( DataFrameContainer lhs,
DataFrameContainer rhs 
)
inline

Definition at line 226 of file DataFrameContainer.h.

References edm::DataFrameContainer::swap().

226  {
227  lhs.swap(rhs);
228  }
template<int I>
void edm::swap ( Hash< I > &  a,
Hash< I > &  b 
)
inline

Definition at line 242 of file Hash.h.

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

242  {
243  a.swap(b);
244  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T >
void edm::swap ( ValueMap< T > &  lhs,
ValueMap< T > &  rhs 
)
inline

Definition at line 263 of file ValueMap.h.

References edm::ValueMap< T >::swap().

263  {
264  lhs.swap(rhs);
265  }
template<typename KeyRefProd , typename CVal , typename KeyRef , typename SizeType , typename KeyReferenceHelper >
void edm::swap ( AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &  a,
AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &  b 
)
inline

Definition at line 269 of file AssociationVector.h.

References edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::swap().

270  {
271  a.swap(b);
272  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T , typename C >
void edm::swap ( DetSetRefVector< T, C > &  a,
DetSetRefVector< T, C > &  b 
)
inline

Definition at line 282 of file DetSetRefVector.h.

References edm::DetSetRefVector< T, C >::swap().

282  {
283  a.swap(b);
284  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename C >
void edm::swap ( MultiAssociation< C > &  lhs,
MultiAssociation< C > &  rhs 
)
inline

Definition at line 292 of file MultiAssociation.h.

292 { lhs.swap(rhs); }
void edm::swap ( ParameterSet a,
ParameterSet b 
)
inline

Definition at line 321 of file ParameterSet.h.

References a, b, isTransientEqual(), cms::operator==(), and edm::ParameterSet::swap().

321  {
322  a.swap(b);
323  }
template<typename T >
void edm::swap ( View< T > &  lhs,
View< T > &  rhs 
)
inline

Definition at line 395 of file View.h.

395  {
396  lhs.swap(rhs);
397  }
template<class T >
void edm::swap ( RefToBase< T > &  a,
RefToBase< T > &  b 
)
inline

Definition at line 400 of file RefToBase.h.

References edm::RefToBase< T >::swap().

401  {
402  a.swap(b);
403  }
template<typename T , typename SORT >
void edm::swap ( SortedCollection< T, SORT > &  a,
SortedCollection< T, SORT > &  b 
)
inline

Definition at line 403 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::swap().

403  {
404  a.swap(b);
405  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T , unsigned int M, typename P >
void edm::swap ( OwnArray< T, M, P > &  a,
OwnArray< T, M, P > &  b 
)
inline

Definition at line 430 of file OwnArray.h.

References edm::OwnArray< T, MAX_SIZE, P >::swap().

430  {
431  a.swap(b);
432  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<class T >
void edm::swap ( DetSetVector< T > &  a,
DetSetVector< T > &  b 
)
inline

Definition at line 441 of file DetSetVector.h.

References edm::DetSetVector< T >::swap().

442  {
443  a.swap(b);
444  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
template<typename T , typename P >
void edm::swap ( OwnVector< T, P > &  a,
OwnVector< T, P > &  b 
)
inline

Definition at line 505 of file OwnVector.h.

References a, and b.

505  {
506  a.swap(b);
507  }
double b
Definition: hdecay.h:120
double a
Definition: hdecay.h:121
static void edm::throwAmbiguousException ( const char *  where,
TypeID const &  productType,
std::string const &  label,
std::string const &  instance,
std::string const &  process 
)
static

Definition at line 74 of file Principal.cc.

References cppFunctionSkipper::exception, modifiedElectrons_cfi::processName, PRODUCT_TYPE, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::Principal::findProductByLabel().

74  {
75  cms::Exception exception("AmbiguousProduct");
76  exception << "Principal::" << where << ": More than 1 product matches all criteria\nLooking for type: " << productType << "\n"
77  << "Looking for module label: " << label << "\n" << "Looking for productInstanceName: " << instance << "\n"
78  << (process.empty() ? "" : "Looking for process: ") << process << "\n"
79  << "This can only occur with get function calls using a Handle<View> argument.\n"
80  << "Try a get not using a View or change the instance name of one of the products";
81  throw exception;
82 
83  }
static PFTauRenderPlugin instance
void edm::throwExceptionWithText ( char const *  txt)

Definition at line 250 of file BranchDescription.cc.

References MillePedeFileConverter_cfg::e, and edm::errors::LogicError.

Referenced by edm::BranchDescription::throwIfInvalid_().

250  {
252  e << "Problem using an incomplete BranchDescription\n"
253  << txt
254  << "\nPlease report this error to the FWCore developers";
255  throw e;
256  }
void edm::throwMissingDictionariesException ( std::vector< std::string > &  missingDictionaries,
std::string const &  context 
)
void edm::throwMissingDictionariesException ( std::vector< std::string > &  missingDictionaries,
std::string const &  context,
std::vector< std::string > &  producedTypes 
)

Definition at line 209 of file DictionaryTools.cc.

References addToMissingDictionariesException(), edm::errors::DictionaryNotFound, cppFunctionSkipper::exception, and tier0::unique().

211  {
212 
214  addToMissingDictionariesException(exception, missingDictionaries, context);
215 
216  if (!producedTypes.empty()) {
217  std::sort(producedTypes.begin(), producedTypes.end());
218  producedTypes.erase(std::unique(producedTypes.begin(), producedTypes.end()), producedTypes.end());
219 
220  std::ostringstream ostr;
221  for(auto const& item : producedTypes) {
222  ostr << " " << item << "\n";
223  }
224  exception << "\nA type listed above might or might not be the same as a\n"
225  << "type declared by a producer module with the function \'produces\'.\n"
226  << "Instead it might be the type of a data member, base class,\n"
227  << "wrapped type, or other object needed by a produced type. Below\n"
228  << "is some additional information which lists the types declared\n"
229  << "to be produced by a producer module that are associated with\n"
230  << "the types whose dictionaries were not found:\n\n"
231  << ostr.str() << "\n";
232  }
233  throw exception;
234  }
def unique(seq, keepstr=True)
Definition: tier0.py:24
void addToMissingDictionariesException(edm::Exception &exception, std::vector< std::string > &missingDictionaries, std::string const &context)
void edm::throwMissingDictionariesException ( std::vector< std::string > &  missingDictionaries,
std::string const &  context,
std::vector< std::string > &  producedTypes,
std::vector< std::string > &  branchNames,
bool  fromStreamerSource = false 
)

Definition at line 237 of file DictionaryTools.cc.

References addToMissingDictionariesException(), edm::errors::DictionaryNotFound, cppFunctionSkipper::exception, and tier0::unique().

241  {
242 
243 
245  addToMissingDictionariesException(exception, missingDictionaries, context);
246 
247  if (!producedTypes.empty()) {
248  std::sort(producedTypes.begin(), producedTypes.end());
249  producedTypes.erase(std::unique(producedTypes.begin(), producedTypes.end()), producedTypes.end());
250 
251  std::ostringstream ostr;
252  for(auto const& item : producedTypes) {
253  ostr << " " << item << "\n";
254  }
255  if (fromStreamerSource) {
256  exception << "\nA type listed above might or might not be the same as a\n"
257  << "type stored in the Event. Instead it might be the type of\n"
258  << "a data member, base class, wrapped type, or other object\n"
259  << "needed by a stored type. Below is some additional information\n"
260  << "which lists the stored types associated with the types whose\n"
261  << "dictionaries were not found:\n\n"
262  << ostr.str() << "\n";
263  } else {
264  exception << "\nA type listed above might or might not be the same as a\n"
265  << "type stored in the Event (or Lumi or Run). Instead it might\n"
266  << "be the type of a data member, base class, wrapped type, or\n"
267  << "other object needed by a stored type. Below is some additional\n"
268  << "information which lists the stored types associated with the\n"
269  << "types whose dictionaries were not found:\n\n"
270  << ostr.str() << "\n";
271  }
272  }
273 
274  if (!branchNames.empty()) {
275 
276  std::sort(branchNames.begin(), branchNames.end());
277  branchNames.erase(std::unique(branchNames.begin(), branchNames.end()), branchNames.end());
278 
279  std::ostringstream ostr;
280  for(auto const& item : branchNames) {
281  ostr << " " << item << "\n";
282  }
283  if (fromStreamerSource) {
284  exception << "Missing dictionaries are associated with these branch names:\n\n"
285  << ostr.str() << "\n";
286  } else {
287  exception << "Missing dictionaries are associated with these branch names:\n\n"
288  << ostr.str() << "\n"
289  << "If you do not need these branches and they are not produced\n"
290  << "in the current process, an alternate solution to adding\n"
291  << "dictionaries is to drop these branches on input using the\n"
292  << "inputCommands parameter of the PoolSource.";
293  }
294  }
295  throw exception;
296  }
def unique(seq, keepstr=True)
Definition: tier0.py:24
void addToMissingDictionariesException(edm::Exception &exception, std::vector< std::string > &missingDictionaries, std::string const &context)
void edm::throwMissingDictionariesException ( std::vector< std::string > &  missingDictionaries,
std::string const &  context,
std::set< std::string > &  producedTypes,
bool  consumedWithView 
)

Definition at line 298 of file DictionaryTools.cc.

References addToMissingDictionariesException(), edm::errors::DictionaryNotFound, and cppFunctionSkipper::exception.

301  {
302 
304  addToMissingDictionariesException(exception, missingDictionaries, context);
305 
306  if (!producedTypes.empty()) {
307 
308  std::ostringstream ostr;
309  for(auto const& item : producedTypes) {
310  ostr << " " << item << "\n";
311  }
312  if (consumedWithView) {
313  exception << "\nThe list of types above was generated while checking for\n"
314  << "dictionaries related to products declared to be consumed\n"
315  << "using a View. They will be either the type or a base class\n"
316  << "of the type declared in a consumes declaration as the template\n"
317  << "parameter of a View. Below is some additional information\n"
318  << "which lists the type of the template parameter of the View.\n"
319  << "(It will be the same type unless the missing dictionary is\n"
320  << "for a base type):\n\n"
321  << ostr.str() << "\n";
322  } else {
323  exception << "\nThe list of types above was generated while checking for\n"
324  << "dictionaries related to products declared to be consumed.\n"
325  << "A type listed above might or might not be a type declared\n"
326  << "to be consumed. Instead it might be the type of a data member,\n"
327  << "base class, wrapped type or other object needed by a consumed\n"
328  << "type. Below is some additional information which lists\n"
329  << "the types declared to be consumed by a module and which\n"
330  << "are associated with the types whose dictionaries were not\n"
331  << "found:\n\n"
332  << ostr.str() << "\n";
333  }
334  }
335  throw exception;
336  }
void addToMissingDictionariesException(edm::Exception &exception, std::vector< std::string > &missingDictionaries, std::string const &context)
static void edm::throwProductDeletedException ( ProductID const &  pid,
edm::EventPrincipal::ConstProductResolverPtr const  phb 
)
static

Definition at line 250 of file EventPrincipal.cc.

References cppFunctionSkipper::exception.

Referenced by edm::EventPrincipal::getByProductID().

250  {
252  exception<<"get by product ID: The product with given id: "<<pid
253  <<"\ntype: "<<phb->productType()
254  <<"\nproduct instance name: "<<phb->productInstanceName()
255  <<"\nprocess name: "<<phb->processName()
256  <<"\nwas already deleted. This is a configuration error. Please change the configuration of the module which caused this exception to state it reads this data.";
257  throw exception;
258  }
static void edm::throwProductNotFoundException ( char const *  where,
errors::ErrorCodes  error,
BranchID const &  bid 
)
static

Definition at line 50 of file Principal.cc.

References Exception.

Referenced by fwlite::ChainEvent::event(), fwlite::Run::getBranchDescriptions(), fwlite::LuminosityBlock::getBranchDescriptions(), edm::Principal::getProvenance(), fwlite::Event::processHistory(), and fwlite::MultiChainEvent::secondaryFileIndex().

50  {
51  throw Exception(error, "InvalidID")
52  << "Principal::" << where << ": no product with given branch id: "<< bid << "\n";
53  }
static void edm::throwTypeException ( std::string const &  function,
std::string const &  typeName 
)
static

Definition at line 51 of file TypeWithDict.cc.

References edm::errors::DictionaryNotFound, and Exception.

Referenced by edm::TypeWithDict::TypeWithDict().

51  {
53  << "Function " << function << ",\n"
54  << "no data dictionary found for type:\n\n"
55  << typeName
56  << "\nMost likely the dictionary was never generated,\n"
57  << "but it may be that it was generated in the wrong package.\n"
58  << "Please add (or move) the specification\n"
59  << "<class name=\"whatever\"/>\n"
60  << "to the appropriate classes_def.xml file.\n"
61  << "If the class is a template instance, you may need\n"
62  << "to define a dummy variable of this type in classes.h.\n"
63  << "Also, if this class has any transient members,\n"
64  << "you need to specify them in classes_def.xml.";
65 
66  }
std::vector<std::string> edm::tokenize ( std::string const &  input,
std::string const &  separator 
)
std::vector<std::string> edm::tokenize ( const std::string &  input,
const std::string &  separator 
)

Definition at line 57 of file Parse.cc.

References copy_all(), and mps_fire::result.

57  {
58  typedef boost::char_separator<char> separator_t;
59  typedef boost::tokenizer<separator_t> tokenizer_t;
60 
61  std::vector<std::string> result;
62  separator_t sep(separator.c_str(), "", boost::keep_empty_tokens); // separator for elements in path
63  tokenizer_t tokens(input, sep);
64  copy_all(tokens, std::back_inserter<std::vector<std::string> >(result));
65  return result;
66  }
string separator
Definition: mps_merge.py:77
static std::string const input
Definition: EdmProvDump.cc:44
Func copy_all(ForwardSequence &s, Func f)
wrappers for copy
Definition: Algorithms.h:24
template<typename T >
boost::python::list edm::toPythonList ( const std::vector< T > &  v)

Definition at line 16 of file PythonWrapper.h.

References mps_fire::i, list(), and mps_fire::result.

Referenced by PythonParameterSet::getParameters().

16  {
18  for(unsigned i = 0; i < v.size(); ++i) {
19  result.append(v[i]);
20  }
21  return result;
22  }
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger list("!*","!HLTx*"if it matches 2 triggers or more) will accept the event if all the matching triggers are FAIL.It will reject the event if any of the triggers are PASS or EXCEPTION(this matches the behavior of"!*"before the partial wildcard feature was incorporated).Triggers which are in the READY state are completely ignored.(READY should never be returned since the trigger paths have been run
template<typename T >
std::vector<T> edm::toVector ( boost::python::list l)

Definition at line 28 of file PythonWrapper.h.

References mps_fire::i, gen::n, GetRecoTauVFromDQM_MC_cff::obj, resolutioncreator_cfi::object, and mps_fire::result.

29  {
30  std::vector<T> result;
31  unsigned n = PyList_Size(l.ptr());
32  boost::python::object iter_obj(boost::python::handle<>(PyObject_GetIter(l.ptr())));
33  for(unsigned i = 0; i < n; ++i)
34  {
35  boost::python::object obj = boost::python::extract<boost::python::object>(iter_obj.attr("next")());
36  result.push_back(boost::python::extract<T>(obj));
37  }
38  return result;
39  }
static std::string const edm::triggerResults ( "TriggerResults"  )
static
static std::string const edm::triggerResultsInserter ( "TriggerResultsInserter"  )
static

Referenced by moduleName().

template<typename T >
T const* edm::tryToGetProductWithCoreFromRef ( RefCore const &  ref,
EDProductGetter const *  prodGetter 
)
inline

Definition at line 108 of file RefCoreGet.h.

References edm::RefCore::isTransient(), and edm::RefCore::nullPointerForTransientException().

108  {
109  if (ref.isTransient()) {
110  ref.nullPointerForTransientException(typeid(T));
111  }
112  return refcore::tryToGetProductWithCoreFromRef_<T>(ref, prodGetter);
113  }
long double T
std::string edm::typeDemangle ( char const *  mangledName)

Definition at line 98 of file TypeDemangler.cc.

References mixOne_premix_on_sim_cfi::comparator, symbols::demangled, Exception, replaceString(), mps_update::status, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PhysicsTools::VarProcessor::deriv(), PhysicsTools::MVAComputer::evalInternal(), edm::TypeID::print(), and edm::serviceregistry::ServicesManager::ServicesManager().

98  {
99  int status = 0;
100  size_t* const nullSize = nullptr;
101  char* const null = nullptr;
102 
103  // The demangled C style string is allocated with malloc, so it must be deleted with free().
104  char* demangled = abi::__cxa_demangle(mangledName, null, nullSize, &status);
105  if (status != 0) {
106  throw cms::Exception("Demangling error") << " '" << mangledName << "'\n";
107  }
108  std::string demangledName(demangled);
109  free(demangled);
110  // We must use the same conventions previously used by REFLEX.
111  // The order of these is important.
112  // No space after comma
113  replaceString(demangledName, ", ", ",");
114  // No space before opening square bracket
115  replaceString(demangledName, " [", "[");
116  // clang libc++ uses __1:: namespace
117  replaceString(demangledName, "std::__1::", "std::");
118  // new gcc abi uses __cxx11:: namespace
119  replaceString(demangledName, "std::__cxx11::", "std::");
120  // Strip default allocator
121  std::string const allocator(",std::allocator<");
122  removeParameter(demangledName, allocator);
123  // Strip default comparator
124  std::string const comparator(",std::less<");
125  removeParameter(demangledName, comparator);
126  // Put const qualifier before identifier.
127  constBeforeIdentifier(demangledName);
128  // No two consecutive '>'
129  replaceString(demangledName, ">>", "> >");
130  // No u or l qualifiers for integers.
131  reformatter(demangledName, "(.*[<,][0-9]+)[ul]l*([,>].*)", "$1$2");
132  // For ROOT 6 and beyond, replace 'unsigned long long' with 'ULong64_t'
133  replaceString(demangledName, "unsigned long long", "ULong64_t");
134  // For ROOT 6 and beyond, replace 'long long' with 'Long64_t'
135  replaceString(demangledName, "long long", "Long64_t");
136  return demangledName;
137  }
void replaceString(std::string &demangledName, std::string const &from, std::string const &to)
demangled
Definition: symbols.py:61
std::string edm::uniqueSharedResourceName ( )

Definition at line 18 of file SharedResourceNames.cc.

Referenced by edm::GeneratorFilter< HAD, DEC >::GeneratorFilter(), and edm::HadronizerFilter< HAD, DEC >::HadronizerFilter().

18  {
19  std::stringstream ss;
20  ss << "uniqueSharedResourceName" << counter.fetch_add(1);
21  return ss.str();
22 }
bool edm::untaintString ( char const *  pattern,
char const *  regexp 
)

Definition at line 13 of file RegexMatch.cc.

Referenced by do_work().

13  {
14  std::regex rexp(regexp);
15  return std::regex_match(pattern, rexp);
16  }
void edm::validateTopLevelParameterSets ( ParameterSet processParameterSet)

Definition at line 77 of file validateTopLevelParameterSets.cc.

References cms::Exception::addContext(), edm::ParameterSet::addUntrackedParameter(), edm::errors::Configuration, heppy_report::description, Exception, fillMaxEventsDescription(), fillMaxLuminosityBlocksDescription(), fillMaxSecondsUntilRampdownDescription(), fillOptionsDescription(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), modifiedElectrons_cfi::processName, muonDTDigis_cfi::pset, AlCaHLTBitMon_QueryRunRegistry::string, and edm::ParameterSetDescription::validate().

Referenced by edm::EventProcessor::init(), edm::SubProcess::SubProcess(), and edm::test::TestProcessor::TestProcessor().

77  {
78 
79  std::string processName = processParameterSet->getParameter<std::string>("@process_name");
80 
81  std::vector<std::string> psetNames {"options", "maxEvents", "maxLuminosityBlocks", "maxSecondsUntilRampdown"};
82 
83  for (auto const& psetName : psetNames) {
84 
85  bool isTracked {false};
86  ParameterSet* pset = processParameterSet->getPSetForUpdate(psetName, isTracked);
87  if (pset == nullptr) {
88  ParameterSet emptyPset;
89  processParameterSet->addUntrackedParameter<ParameterSet>(psetName, emptyPset);
90  pset = processParameterSet->getPSetForUpdate(psetName, isTracked);
91  }
92  if (isTracked) {
94  << "In the configuration the top level parameter set named \'" << psetName << "\' in process \'" << processName << "\' is tracked.\n"
95  << "It must be untracked";
96  }
97 
99  if (psetName == "options") {
100  fillOptionsDescription(description);
101  } else if (psetName == "maxEvents") {
102  fillMaxEventsDescription(description);
103  } else if (psetName == "maxLuminosityBlocks") {
105  } else if (psetName == "maxSecondsUntilRampdown") {
107  }
108 
109  try {
110  description.validate(*pset);
111  } catch(cms::Exception& ex) {
112  std::ostringstream ost;
113  ost << "Validating top level \'" << psetName << "\' ParameterSet for process \'" << processName << "\'";
114  ex.addContext(ost.str());
115  throw;
116  }
117  }
118 }
void fillOptionsDescription(ParameterSetDescription &description)
void fillMaxEventsDescription(ParameterSetDescription &description)
void fillMaxLuminosityBlocksDescription(ParameterSetDescription &description)
void addContext(std::string const &context)
Definition: Exception.cc:227
void fillMaxSecondsUntilRampdownDescription(ParameterSetDescription &description)
template<typename InputType , typename Function >
auto edm::vector_transform ( std::vector< InputType > const &  input,
Function  predicate 
) -> std::vector<typename std::remove_cv<typename std::remove_reference<decltype(predicate(input.front()))>::type>::type>

Definition at line 11 of file transform.h.

References input, and convertSQLitetoXML_cfg::output.

Referenced by CaloTauSelectorDefinition::CaloTauSelectorDefinition(), reco::modules::CandCombinerBase::CandCombinerBase(), EGammaCutBasedEleIdAnalyzer::EGammaCutBasedEleIdAnalyzer(), GenWeightsTableProducer::GenWeightsTableProducer(), HLTBTagPerformanceAnalyzer::HLTBTagPerformanceAnalyzer(), HLTVertexPerformanceAnalyzer::HLTVertexPerformanceAnalyzer(), pf2pat::IsolatedPFCandidateSelectorDefinition::IsolatedPFCandidateSelectorDefinition(), JetSubstructurePacker::JetSubstructurePacker(), MultiTrackValidator::MultiTrackValidator(), reco::modules::NamedCandCombinerBase::NamedCandCombinerBase(), OccupancyPlots::OccupancyPlots(), pat::PATElectronProducer::PATElectronProducer(), pat::PATGenericParticleProducer::PATGenericParticleProducer(), pat::PATJetProducer::PATJetProducer(), pat::PATJetUpdater::PATJetUpdater(), pat::PATMuonProducer::PATMuonProducer(), pat::PATPFParticleProducer::PATPFParticleProducer(), pat::PATPhotonProducer::PATPhotonProducer(), pat::PATSingleVertexSelector::PATSingleVertexSelector(), PATTauIDEmbedder::PATTauIDEmbedder(), pat::PATTauProducer::PATTauProducer(), pat::PATTriggerEventProducer::PATTriggerEventProducer(), PixelInactiveAreaFinder::PixelInactiveAreaFinder(), pat::PATMuonProducer::readIsolationLabels(), pat::PATPhotonProducer::readIsolationLabels(), pat::PATElectronProducer::readIsolationLabels(), ReducedESRecHitCollectionProducer::ReducedESRecHitCollectionProducer(), ReducedRecHitCollectionProducer::ReducedRecHitCollectionProducer(), SeedCombiner::SeedCombiner(), SiStripClusterizer::SiStripClusterizer(), SiStripProcessedRawDigiProducer::SiStripProcessedRawDigiProducer(), TrackerDpgAnalysis::TrackerDpgAnalysis(), TrackingMonitor::TrackingMonitor(), TrackingNtuple::TrackingNtuple(), and TtEvtBuilder< C >::TtEvtBuilder().

12  {
13  using ReturnType = typename std::remove_cv<typename std::remove_reference<decltype(predicate(input.front()))>::type>::type;
14  std::vector<ReturnType> output;
15  output.reserve( input.size() );
16  for (auto const & element : input)
17  output.push_back(predicate(element));
18  return output;
19  }
type
Definition: HCALResponse.h:21
static std::string const input
Definition: EdmProvDump.cc:44
std::map< DetId, double > ReturnType
template<typename V , typename T >
void edm::walkTrie ( V &  v,
TrieNode< T > const &  n,
std::string const &  label = "" 
)

visit each node of the trie

Definition at line 284 of file Trie.h.

References MillePedeFileConverter_cfg::e, diffTwoXMLs::label, AlCaHLTBitMon_ParallelJobs::p, and findQualityFiles::v.

284  {
285  typedef TrieNodeIter<T> node_iterator;
286  node_iterator e;
287  for (node_iterator p(&n); p!=e; ++p) {
288  v((*p).value(),label+(char)p.label());
289  walkTrie(v,*p,label+(char)p.label());
290  }
291  }
void walkTrie(V &v, TrieNode< T > const &n, std::string const &label="")
visit each node of the trie
Definition: Trie.h:284
std::string edm::withoutQuotes ( std::string const &  from)
std::string edm::withoutQuotes ( const std::string &  from)

Definition at line 36 of file Parse.cc.

References mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

36  {
37  std::string result = from;
38  if(!result.empty()) {
39  // get rid of leading quotes
40  if(result[0] == '"' || result[0] == '\'') {
41  result.erase(0,1);
42  }
43  }
44 
45  if(!result.empty()) {
46  // and trailing quotes
47  int lastpos = result.size()-1;
48  if(result[lastpos] == '"' || result[lastpos] == '\'') {
49  result.erase(lastpos, 1);
50  }
51  }
52  return result;
53  }
std::string edm::wrappedClassName ( std::string const &  iFullName)

Definition at line 5 of file WrappedClassName.cc.

References className(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::StreamerInputSource::buildClassCache(), edm::ProductRegistry::checkDictionariesOfConsumedTypes(), checkDictionaryOfWrappedType(), BareRootProductGetter::createNewBuffer(), edm::StreamerInputSource::declareStreamers(), FWFileEntry::getBranchName(), fwlite::DataGetterHelper::getByBranchDescription(), edm::productholderindexhelper::getContainedType(), edm::root::FWLiteDelayedReader::getTheProduct(), edm::BranchDescription::initFromDictionary(), and FWFileEntry::runFilter().

5  {
6  std::string const wrapperBegin("edm::Wrapper<");
7  std::string const wrapperEnd1(">");
8  std::string const wrapperEnd2(" >");
9  std::string const& wrapperEnd = (className[className.size()-1] == '>' ? wrapperEnd2 : wrapperEnd1);
10  std::string wrapped;
11  wrapped.reserve(wrapperBegin.size() + className.size() + wrapperEnd.size());
12  wrapped += wrapperBegin;
13  wrapped += className;
14  wrapped += wrapperEnd;
15  return wrapped;
16  }
std::string className(const T &t)
Definition: ClassName.h:30

Variable Documentation

int const edm::bufSize = 128
static
debugvalue edm::debugit
ELslProxy< ELdebugGen > const edm::ELdebug
ELslGen edm::ELdebugGen
ELslProxy< ELerrorGen > const edm::ELerror

Definition at line 273 of file ELseverityLevel.cc.

Referenced by loadMap(), and LoggedErrorsOnlySummary().

ELslGen edm::ELerrorGen
ELslProxy< ELhighestSeverityGen > const edm::ELhighestSeverity
ELslGen edm::ELhighestSeverityGen
ELslProxy< ELinfoGen > const edm::ELinfo

Definition at line 261 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslGen edm::ELinfoGen
ELslProxy< ELsevereGen > const edm::ELsevere
ELslGen edm::ELsevereGen
ELslProxy< ELunspecifiedGen > const edm::ELunspecified

Definition at line 279 of file ELseverityLevel.cc.

Referenced by edm::ELextendedID::clear(), and loadMap().

ELslGen edm::ELunspecifiedGen
ELslProxy< ELwarningGen > const edm::ELwarning
ELslGen edm::ELwarningGen
ELslProxy< ELzeroSeverityGen > const edm::ELzeroSeverity
ELslGen edm::ELzeroSeverityGen
char const* edm::fmt_Guid
static
Initial value:
=
"%08lX-%04hX-%04hX-%02hhX%02hhX-%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX"

Definition at line 21 of file Guid.cc.

MallocOptionSetter edm::global_malloc_options

Definition at line 219 of file MallocOpts.cc.

Referenced by getGlobalOptionSetter().

EventNumber_t const edm::invalidEventNumber = 0U
LuminosityBlockNumber_t const edm::invalidLuminosityBlockNumber = 0U

Definition at line 17 of file RunLumiEventNumber.h.

Referenced by FWGUIManager::lumiIdChanged().

RunNumber_t const edm::invalidRunNumber = 0U

Definition at line 18 of file RunLumiEventNumber.h.

Referenced by FWGUIManager::runIdChanged().

unsigned long long const edm::kAveEventPerSec = 200ULL
static

Definition at line 22 of file ProducerSourceBase.cc.

Referenced by edm::ProducerSourceBase::fillDescription().

unsigned long long const edm::kNanoSecPerSec = 1000000000ULL
static

Definition at line 21 of file ProducerSourceBase.cc.

const unsigned char edm::MLSCRIBE_RUNNING_INDICATOR = 29
static
constexpr const char* edm::module_type_desc[]
Initial value:
{
"Unknown",
"Source",
"ESSource",
"ESProducer",
"EDAnalyzer",
"EDProducer",
"EDFilter",
"OutputModule"
}

Definition at line 20 of file EDMModuleType.h.

Referenced by edmModuleType(), DependencyGraph::edmModuleType(), edmModuleTypeEnum(), and DependencyGraph::edmModuleTypeEnum().

constexpr unsigned int edm::s_defaultNumberOfThreads = 1

Definition at line 9 of file validateTopLevelParameterSets.h.

Referenced by fillOptionsDescription().

const std::vector<void const*> edm::s_emptyCache {}
static

Definition at line 196 of file PtrVectorBase.cc.

Referenced by edm::PtrVectorBase::emptyCache().

ProcessHistory const edm::s_emptyProcessHistory
static

Definition at line 34 of file Principal.cc.

Referenced by edm::Principal::fillPrincipal().

std::atomic<Principal::CacheIdentifier_t> edm::s_nextIdentifier {1}
static

Definition at line 109 of file Principal.cc.

Referenced by nextIdentifier().

thread_local EDProductGetter const* edm::s_productGetter = 0
unsigned int const edm::shift = 8 * sizeof(unsigned int)
static

Definition at line 9 of file LuminosityBlockID.cc.

Referenced by algorithm(), EcalTPGParamBuilder::analyze(), L1TCSCTF::analyze(), HcalTriggerPrimitiveAlgo::analyze(), HcalTriggerPrimitiveAlgo::analyzeHF(), HcalTriggerPrimitiveAlgo::analyzeHFQIE10(), HcalTriggerPrimitiveAlgo::analyzeQIE11(), BeamSpotAlignmentParameters::apply(), RigidBodyAlignmentParameters::apply(), TwoBowedSurfacesAlignmentParameters::apply(), MuScleFitUtils::applyScale(), CSCTFTrackBuilder::buildTracks(), barrelUtil::calculatePhiWindow(), HGCalDDDConstants::cellHex(), DEutils< T >::DEDigi(), InitialState::Evolve(), DDCutTubsFromPoints::execute(), PFPhotonClusters::FillClusterShape(), Py8toJetInput::fillJetAlgoInput(), MiniFloatConverter::float32to16round(), l1t::GtRecordDump::formatHMB(), RPCTBMuon::PACOut::fromBits(), RPCTBMuon::TBOut::fromBits(), RPCTBMuon::TCOut::fromBits(), RPCTBMuon::HSBOut::fromBits(), RPCTBMuon::FSBOut::fromBits(), PtAssignmentEngineAux2016::getEtaFromEtaInt(), PtAssignmentEngineAux2016::getEtaInt(), UCTCTP7RawData::getHFFeatureBits(), popcon::EcalLaser_weekly_Linearization_Check::getNewObjects(), popcon::EcalLaser_weekly_Linearization::getNewObjects(), popcon::EcalTPGLinPed::getNewObjects(), popcon::EcalTPGPedfromFile::getNewObjects(), OptOModifiedRhomboidPrism::getRotatedPlate(), HcalDDDSimConstants::getShift(), HIPplots::GetSubDet(), RigidBodyAlignmentParameters::globalParameters(), BeamSpotAlignmentParameters::globalParameters(), HcalDDDSimConstants::HcalCellTypes(), PixelTripletNoTipGenerator::hitTriplets(), SiPixelDigitizerAlgorithm::PixelEfficiencies::init_from_db(), FFTJetPFPileupCleaner::isRemovable(), L1TTwinMuxRawToDigi::L1TTwinMuxRawToDigi(), npstat::ArrayND< Numeric, StackLen, StackDim >::linearFill(), npstat::ArrayND< Numeric, StackLen, StackDim >::linearFillLoop(), fftjetcms::LinInterpolatedTable1D::LinInterpolatedTable1D(), L1MuDTPtaLut::load(), L1TMuonBarrelParamsHelper::load_pt(), phase1PixelTopology::localX(), phase1PixelTopology::localY(), HcalPulseShapes::normalizeShift(), pat::MET::Vector2::phi(), HcalTTPDigiProducer::produce(), DistortedMuonProducerFromDB::produce(), ShiftedMETcorrInputProducer::produce(), ShiftedJetProducerByMatchedObjectT< T >::produce(), ShiftedPFCandidateProducerByMatchedObject::produce(), ShiftedPFCandidateProducerForPFMVAMEt::produce(), ShiftedParticleProducer::produce(), ShiftedPFCandidateProducerForNoPileUpPFMEt::produce(), ShiftedPFCandidateProducerForPFNoPUMEt::produce(), ShiftedParticleProducerT< T >::produce(), ShiftedJetProducerT< T, Textractor >::produce(), HFPreRecAlgo::reconstruct(), CSCTFSectorProcessor::run(), CSCTFSPCoreLogic::run(), HFRecHitAuxSetter::setAux(), reco::PFCandidate::setHcalDepthEnergyFractions(), UCTCTP7RawData::setHFFeatureBits(), HcalTriggerPrimitiveAlgo::setNCTScaleShift(), BackgroundHandler::setParameters(), HcalTriggerPrimitiveAlgo::setRCTScaleShift(), FFTJetPFPileupCleaner::setRemovalBit(), pat::MET::setUncShift(), pat::MET::shiftedP2_74x(), pat::MET::shiftedP4_74x(), pat::MET::shiftedSumEt_74x(), DTTracoChip::storeCorr(), DTTracoChip::storeUncorr(), RPCTBMuon::PACOut::toBits(), RPCTBMuon::TBOut::toBits(), RPCTBMuon::TCOut::toBits(), RPCTBMuon::HSBOut::toBits(), RPCTBMuon::FSBOut::toBits(), BeamSpotAlignmentParameters::translation(), RigidBodyAlignmentParameters::translation(), DCCEEEventBlock::unpack(), DCCEBEventBlock::unpack(), CSCTFEvent::unpack(), pat::PackedGenParticle::unpack(), pat::PackedCandidate::unpack(), LatencyHistosUsingDb::update(), Alignable::update(), edm::LuminosityBlockID::value(), CastorCORData::wasMarkAndPassZS(), and HcalPulseShapes::Y11206().

volatile std::atomic< bool > edm::shutdown_flag {false}
pset::TypeTrans const edm::sTypeTranslations
static

Definition at line 78 of file Entry.cc.