confdb.HLTProcess Class Reference

Inheritance diagram for confdb.HLTProcess:

Public Member Functions
def	__init__ (self, configuration)
def	addEras (self)
def	addGlobalOptions (self)
def	append_filenames (self, name, filenames)
def	build_source (self)
def	buildOptions (self)
def	buildPathList (self)
def	customize (self)
def	dump (self)
def	expand_filenames (self, input)
def	fixPrescales (self)
def	getPathList (self)
def	getRawConfigurationFromDB (self)
def	getSetupConfigurationFromDB (self)
def	instrumentDQM (self)
def	instrumentErrorEventType (self)
def	instrumentOpenMode (self)
def	instrumentTiming (self)
def	loadAdditionalConditions (self, comment, *conditions)
def	loadCff (self, module)
def	loadCffCommand (self, module)
def	loadSetupCff (self)
def	overrideGlobalTag (self)
def	overrideL1MenuXml (self)
def	overrideOutput (self)
def	overrideParameters (self, module, parameters)
def	overrideProcessName (self)
def	runL1Emulator (self)
def	specificCustomize (self)
def	updateMessageLogger (self)

Static Public Member Functions
def	consolidateNegativeList (elements)
def	consolidatePositiveList (elements)
def	dumppaths (paths)
def	expandWildcards (globs, collection)

Public Attributes
	all_paths
	config
	converter
	data
	labels
	options
	parent
	source

Private Member Functions
def	_fix_parameter (self, **args)

Detailed Description

Definition at line 21 of file confdb.py.

Constructor & Destructor Documentation

__init__()

def confdb.HLTProcess.__init__	(		self,
			configuration
	)

Definition at line 23 of file confdb.py.

  def __init__(self, configuration):
    self.config = configuration
    self.data   = None
    self.source = []
    self.parent = []
 
    self.options = {
      'essources' : [],
      'esmodules' : [],
      'modules'   : [],
      'sequences' : [],
      'services'  : [],
      'paths'     : [],
      'psets'     : [],
      'blocks'    : [],
    }
 
    self.labels = {}
    if self.config.fragment:
      self.labels['process'] = 'fragment'
      self.labels['dict']    = 'fragment.__dict__'
    else:
      self.labels['process'] = 'process'
      self.labels['dict']    = 'process.__dict__'
 
    if self.config.prescale and (self.config.prescale.lower() != 'none'):
      self.labels['prescale'] = self.config.prescale
 
    # get the configuration from ConfdB
    from .confdbOfflineConverter import OfflineConverter
    self.converter = OfflineConverter(version = self.config.menu.version, database = self.config.menu.database)
    self.buildPathList()
    self.buildOptions()
    self.getSetupConfigurationFromDB()
    self.getRawConfigurationFromDB()
    self.customize()
 

Member Function Documentation

_fix_parameter()

def confdb.HLTProcess._fix_parameter (   self, **  args  )

private

arguments:
name:     parameter name (optional)
type:     parameter type (look for tracked and untracked variants)
value:    original value
replace:  replacement value

Definition at line 337 of file confdb.py.

  def _fix_parameter(self, **args):
    """arguments:
        name:     parameter name (optional)
        type:     parameter type (look for tracked and untracked variants)
        value:    original value
        replace:  replacement value
    """
    if 'name' in args:
      self.data = re.sub(
          r'%(name)s = cms(?P<tracked>(?:\.untracked)?)\.%(type)s\( (?P<quote>["\']?)%(value)s(?P=quote)' % args,
          r'%(name)s = cms\g<tracked>.%(type)s( \g<quote>%(replace)s\g<quote>' % args,
          self.data)
    else:
      self.data = re.sub(
          r'cms(?P<tracked>(?:\.untracked)?)\.%(type)s\( (?P<quote>["\']?)%(value)s(?P=quote)' % args,
          r'cms\g<tracked>.%(type)s( \g<quote>%(replace)s\g<quote>' % args,
          self.data)
 
 

References mat4.data, CombinedTauTagCalibration.data, CombinedSVCalibration.data, ecal::DigisCollection< StoragePolicy >.data, TrackProbabilityCalibration.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, LASModuleProfile.data, dqmTnP::AbstractFitter.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, calo::multifit::MapMForPM< T >.data, GeometryComparisonPlotter.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, and edmStreamStallGrapher.Stack.data.

Referenced by confdb.HLTProcess.customize(), and confdb.HLTProcess.instrumentErrorEventType().

addEras()

def confdb.HLTProcess.addEras

(

self

)

Definition at line 517 of file confdb.py.

  def addEras(self):
    if self.config.eras is None:
      return
    from Configuration.StandardSequences.Eras import eras
    erasSplit = self.config.eras.split(',')
    self.data = re.sub(r'process = cms.Process\( *"\w+"', '\n'.join(eras.pythonCfgLines[era] for era in erasSplit)+'\n\g<0>, '+', '.join(era for era in erasSplit), self.data)
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, KDTreeNodeInfo< DATA, DIM >.data, calo::multifit::MapSymM< T, Stride, Order >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, and join().

Referenced by confdb.HLTProcess.customize().

addGlobalOptions()

def confdb.HLTProcess.addGlobalOptions

(

self

)

Definition at line 319 of file confdb.py.

  def addGlobalOptions(self):
    # add global options
    self.data += """
# limit the number of events to be processed
%%(process)s.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32( %d )
)
""" % self.config.events
 
    self.data += """
# enable TrigReport, TimeReport and MultiThreading
%(process)s.options = cms.untracked.PSet(
    wantSummary = cms.untracked.bool( True ),
    numberOfThreads = cms.untracked.uint32( 4 ),
    numberOfStreams = cms.untracked.uint32( 0 ),
)
"""
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedTauTagCalibration.data, CombinedSVCalibration.data, ecal::DigisCollection< StoragePolicy >.data, TrackProbabilityCalibration.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, LASModuleProfile.data, dqmTnP::AbstractFitter.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, calo::multifit::MapMForPM< T >.data, GeometryComparisonPlotter.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, and edmStreamStallGrapher.Stack.data.

Referenced by confdb.HLTProcess.customize().

append_filenames()

def confdb.HLTProcess.append_filenames	(		self,
			name,
			filenames
	)

Definition at line 850 of file confdb.py.

  def append_filenames(self, name, filenames):
    if len(filenames) > 255:
      token_open  = "( *("
      token_close = ") )"
    else:
      token_open  = "("
      token_close = ")"
 
    self.data += "    %s = cms.untracked.vstring%s\n" % (name, token_open)
    for line in filenames:
      self.data += "        '%s',\n" % line
    self.data += "    %s,\n" % (token_close)
 
 

References mat4.data, CombinedTauTagCalibration.data, CombinedSVCalibration.data, ecal::DigisCollection< StoragePolicy >.data, TrackProbabilityCalibration.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, LASModuleProfile.data, dqmTnP::AbstractFitter.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, calo::multifit::MapMForPM< T >.data, GeometryComparisonPlotter.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, and edmStreamStallGrapher.Stack.data.

Referenced by confdb.HLTProcess.build_source().

build_source()

def confdb.HLTProcess.build_source

(

self

)

Definition at line 876 of file confdb.py.

  def build_source(self):
    if self.config.hilton:
      # use the DAQ source
      return
 
    if self.config.input:
      # if a dataset or a list of input files was given, use it
      self.source = self.expand_filenames(self.config.input)
    elif self.config.data:
      # offline we can run on data...
      self.source = [ "file:RelVal_Raw_%s_DATA.root" % self.config.type ]
    else:
      # ...or on mc
      self.source = [ "file:RelVal_Raw_%s_MC.root" % self.config.type ]
 
    if self.config.parent:
      # if a dataset or a list of input files was given for the parent data, use it
      self.parent = self.expand_filenames(self.config.parent)
 
    self.data += """
%(process)s.source = cms.Source( "PoolSource",
"""
    self.append_filenames("fileNames", self.source)
    if (self.parent):
      self.append_filenames("secondaryFileNames", self.parent)
    self.data += """\
    inputCommands = cms.untracked.vstring(
        'keep *'
    )
)
"""

References confdb.HLTProcess.append_filenames(), geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, KDTreeNodeInfo< DATA, DIM >.data, calo::multifit::MapSymM< T, Stride, Order >.data, hcal::raw::InputDataCPU.data, LASModuleProfile.data, dqmTnP::AbstractFitter.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, edm::MapOfVectors< K, T >::Iter.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, confdb.HLTProcess.expand_filenames(), confdb.HLTProcess.parent, FWPSetTableManager::PSetData.parent, SlimmedCount.parent, BeautifulSoup.PageElement.parent, dqm::implementation::IBooker::UseScope< SCOPE >.parent, confdb.HLTProcess.source, lhef::XMLDocument.source, DQMNet::Peer.source, Config.Process.source, gen::Hydjet2Hadronizer.source, and BeautifulSoup.ResultSet.source.

Referenced by confdb.HLTProcess.customize().

buildOptions()

def confdb.HLTProcess.buildOptions

(

self

)

Definition at line 753 of file confdb.py.

  def buildOptions(self):
    # common configuration for all scenarios
    self.options['services'].append( "-DQM" )
    self.options['services'].append( "-FUShmDQMOutputService" )
    self.options['services'].append( "-MicroStateService" )
    self.options['services'].append( "-ModuleWebRegistry" )
    self.options['services'].append( "-TimeProfilerService" )
 
    # remove the DAQ modules and the online definition of the DQMStore and DQMFileSaver
    # unless a hilton-like configuration has been requested
    if not self.config.hilton:
      self.options['services'].append( "-EvFDaqDirector" )
      self.options['services'].append( "-FastMonitoringService" )
      self.options['services'].append( "-DQMStore" )
      self.options['modules'].append( "-hltDQMFileSaver" )
      self.options['modules'].append( "-hltDQMFileSaverPB" )
 
    if self.config.fragment:
      # extract a configuration file fragment
      self.options['essources'].append( "-GlobalTag" )
      self.options['essources'].append( "-HepPDTESSource" )
      self.options['essources'].append( "-XMLIdealGeometryESSource" )
      self.options['essources'].append( "-eegeom" )
      self.options['essources'].append( "-es_hardcode" )
      self.options['essources'].append( "-magfield" )
 
      self.options['esmodules'].append( "-SlaveField0" )
      self.options['esmodules'].append( "-SlaveField20" )
      self.options['esmodules'].append( "-SlaveField30" )
      self.options['esmodules'].append( "-SlaveField35" )
      self.options['esmodules'].append( "-SlaveField38" )
      self.options['esmodules'].append( "-SlaveField40" )
      self.options['esmodules'].append( "-VBF0" )
      self.options['esmodules'].append( "-VBF20" )
      self.options['esmodules'].append( "-VBF30" )
      self.options['esmodules'].append( "-VBF35" )
      self.options['esmodules'].append( "-VBF38" )
      self.options['esmodules'].append( "-VBF40" )
      self.options['esmodules'].append( "-CSCGeometryESModule" )
      self.options['esmodules'].append( "-CaloGeometryBuilder" )
      self.options['esmodules'].append( "-CaloTowerHardcodeGeometryEP" )
      self.options['esmodules'].append( "-CastorHardcodeGeometryEP" )
      self.options['esmodules'].append( "-DTGeometryESModule" )
      self.options['esmodules'].append( "-EcalBarrelGeometryEP" )
      self.options['esmodules'].append( "-EcalElectronicsMappingBuilder" )
      self.options['esmodules'].append( "-EcalEndcapGeometryEP" )
      self.options['esmodules'].append( "-EcalLaserCorrectionService" )
      self.options['esmodules'].append( "-EcalPreshowerGeometryEP" )
      self.options['esmodules'].append( "-HcalHardcodeGeometryEP" )
      self.options['esmodules'].append( "-HcalTopologyIdealEP" )
      self.options['esmodules'].append( "-MuonNumberingInitialization" )
      self.options['esmodules'].append( "-ParametrizedMagneticFieldProducer" )
      self.options['esmodules'].append( "-RPCGeometryESModule" )
      self.options['esmodules'].append( "-SiStripGainESProducer" )
      self.options['esmodules'].append( "-SiStripRecHitMatcherESProducer" )
      self.options['esmodules'].append( "-SiStripQualityESProducer" )
      self.options['esmodules'].append( "-StripCPEfromTrackAngleESProducer" )
      self.options['esmodules'].append( "-TrackerAdditionalParametersPerDetESModule" )
      self.options['esmodules'].append( "-TrackerDigiGeometryESModule" )
      self.options['esmodules'].append( "-TrackerGeometricDetESModule" )
      self.options['esmodules'].append( "-VolumeBasedMagneticFieldESProducer" )
      self.options['esmodules'].append( "-ZdcHardcodeGeometryEP" )
      self.options['esmodules'].append( "-hcal_db_producer" )
      self.options['esmodules'].append( "-L1GtTriggerMaskAlgoTrigTrivialProducer" )
      self.options['esmodules'].append( "-L1GtTriggerMaskTechTrigTrivialProducer" )
      self.options['esmodules'].append( "-hltESPEcalTrigTowerConstituentsMapBuilder" )
      self.options['esmodules'].append( "-hltESPGlobalTrackingGeometryESProducer" )
      self.options['esmodules'].append( "-hltESPMuonDetLayerGeometryESProducer" )
      self.options['esmodules'].append( "-hltESPTrackerRecoGeometryESProducer" )
      self.options['esmodules'].append( "-trackerTopology" )
 
      self.options['esmodules'].append( "-CaloTowerGeometryFromDBEP" )
      self.options['esmodules'].append( "-CastorGeometryFromDBEP" )
      self.options['esmodules'].append( "-EcalBarrelGeometryFromDBEP" )
      self.options['esmodules'].append( "-EcalEndcapGeometryFromDBEP" )
      self.options['esmodules'].append( "-EcalPreshowerGeometryFromDBEP" )
      self.options['esmodules'].append( "-HcalGeometryFromDBEP" )
      self.options['esmodules'].append( "-ZdcGeometryFromDBEP" )
      self.options['esmodules'].append( "-XMLFromDBSource" )
      self.options['esmodules'].append( "-sistripconn" )
 
      self.options['services'].append( "-MessageLogger" )
 
      self.options['psets'].append( "-maxEvents" )
      self.options['psets'].append( "-options" )
 
      # remove Scouting OutputModules even though the EndPaths are kept
      self.options['modules'].append( "-hltOutputScoutingCaloMuon" )
      self.options['modules'].append( "-hltOutputScoutingPF" )
 
    if self.config.fragment or (self.config.prescale and (self.config.prescale.lower() == 'none')):
      self.options['services'].append( "-PrescaleService" )
 
    if self.config.fragment or self.config.timing:
      self.options['services'].append( "-FastTimerService" )
 
 

References mps_setup.append, geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, TestProcess.TestProcess.options, confdb.HLTProcess.options, Config.Process.options, and validateAlignments.ValidationJobMultiIOV.options.

buildPathList()

def confdb.HLTProcess.buildPathList

(

self

)

Definition at line 688 of file confdb.py.

  def buildPathList(self):
    self.all_paths = self.getPathList()
 
    if self.config.paths:
      # no path list was requested, dump the full table, minus unsupported / unwanted paths
      paths = self.config.paths.split(',')
    else:
      # dump only the requested paths, plus the eventual output endpaths
      paths = []
 
    # 'none'    should remove all outputs
    # 'dqm'     should remove all outputs but DQMHistograms
    # 'minimal' should remove all outputs but DQMHistograms, and add a single output module to keep the TriggerResults and TriggerEvent
    # 'full'    should remove all outputs but DQMHistograms, and add a single output module to "keep *"
    # See also the `overrideOutput` method
    if self.config.fragment or self.config.output in ('none', ):
      if self.config.paths:
        # keep only the Paths and EndPaths requested explicitly
        pass
      else:
        # drop all output EndPaths but the Scouting ones, and drop the RatesMonitoring and DQMHistograms
        paths.append( "-*Output" )
        paths.append( "-RatesMonitoring")
        paths.append( "-DQMHistograms")
        if self.config.fragment: paths.append( "Scouting*Output" )
 
    elif self.config.output in ('dqm', 'minimal', 'full'):
      if self.config.paths:
        # keep only the Paths and EndPaths requested explicitly, and the DQMHistograms
        paths.append( "DQMHistograms" )
      else:
        # drop all output EndPaths but the Scouting ones, and drop the RatesMonitoring
        paths.append( "-*Output" )
        paths.append( "-RatesMonitoring")
        if self.config.fragment: paths.append( "Scouting*Output" )
 
    else:
      if self.config.paths:
        # keep all output EndPaths, including the DQMHistograms
        paths.append( "*Output" )
        paths.append( "DQMHistograms" )
      else:
        # keep all Paths and EndPaths
        pass
 
    # drop unwanted paths for profiling (and timing studies)
    if self.config.profiling:
      paths.append( "-HLTAnalyzerEndpath" )
 
    # this should never be in any dump (nor online menu)
    paths.append( "-OfflineOutput" )
 
    # expand all wildcards
    paths = self.expandWildcards(paths, self.all_paths)
 
    if self.config.paths:
      # do an "additive" consolidation
      paths = self.consolidatePositiveList(paths)
      if not paths:
        raise RuntimeError('Error: option "--paths %s" does not select any valid paths' % self.config.paths)
    else:
      # do a "subtractive" consolidation
      paths = self.consolidateNegativeList(paths)
    self.options['paths'] = paths
 

consolidateNegativeList()

def confdb.HLTProcess.consolidateNegativeList (   elements )

static

Definition at line 143 of file confdb.py.

  def consolidateNegativeList(elements):
    # consolidate a list of path exclusions and re-inclusions
    # the result is the list of paths to be removed from the dump
    result = set()
    for element in elements:
      if element[0] == '-':
        result.add( element )
      else:
        result.discard( '-' + element )
    return sorted( element for element in result )
 

consolidatePositiveList()

def confdb.HLTProcess.consolidatePositiveList (   elements )

static

Definition at line 155 of file confdb.py.

  def consolidatePositiveList(elements):
    # consolidate a list of path selection and re-exclusions
    # the result is the list of paths to be included in the dump
    result = set()
    for element in elements:
      if element[0] == '-':
        result.discard( element[1:] )
      else:
        result.add( element )
    return sorted( element for element in result )
 
 

customize()

def confdb.HLTProcess.customize

(

self

)

Definition at line 241 of file confdb.py.

  def customize(self):
 
    # adapt the source to the current scenario
    if not self.config.fragment:
      self.build_source()
 
    # manual override some parameters
    if self.config.type in ('HIon', ):
      if self.config.data:
        if not self.config.fragment:
          self._fix_parameter( type = 'InputTag', value = 'rawDataCollector',  replace = 'rawDataRepacker')
 
    # if requested, remove the HLT prescales
    self.fixPrescales()
 
    # if requested, override all ED/HLTfilters to always pass ("open" mode)
    self.instrumentOpenMode()
 
    # if requested, change all HLTTriggerTypeFilter EDFilters to accept only error events (SelectedTriggerType = 0)
    self.instrumentErrorEventType()
 
    # if requested, instrument the self with the modules and EndPath needed for timing studies
    self.instrumentTiming()
 
    # if requested, override the L1 self from the GlobalTag (Xml)
    self.overrideL1MenuXml()
 
    # if requested, run the L1 emulator
    self.runL1Emulator()
 
    # add process.load("setup_cff")
    self.loadSetupCff()
 
    if self.config.fragment:
      self.data += """
# dummify hltGetConditions in cff's
if 'hltGetConditions' in %(dict)s and 'HLTriggerFirstPath' in %(dict)s :
    %(process)s.hltDummyConditions = cms.EDFilter( "HLTBool",
        result = cms.bool( True )
    )
    %(process)s.HLTriggerFirstPath.replace(%(process)s.hltGetConditions,%(process)s.hltDummyConditions)
"""
 
      # fix the Scouting EndPaths
      for path in self.all_paths:
        match = re.match(r'(Scouting\w+)Output$', path)
        if match:
          module = 'hltOutput' + match.group(1)
          self.data = self.data.replace(path+' = cms.EndPath', path+' = cms.Path')
          self.data = self.data.replace(' + process.'+module, '')
 
    else:
 
      # override the process name and adapt the relevant filters
      self.overrideProcessName()
 
      # select specific Eras
      self.addEras()
 
      # override the output modules to output root files
      self.overrideOutput()
 
      # add global options
      self.addGlobalOptions()
 
      # if requested or necessary, override the GlobalTag and connection strings (incl. L1!)
      self.overrideGlobalTag()
 
      # request summary informations from the MessageLogger
      self.updateMessageLogger()
 
      # replace DQMStore and DQMRootOutputModule with a configuration suitable for running offline
      self.instrumentDQM()
 
    # add specific customisations
    self.specificCustomize()
 
 

References confdb.HLTProcess._fix_parameter(), confdb.HLTProcess.addEras(), confdb.HLTProcess.addGlobalOptions(), confdb.HLTProcess.all_paths, confdb.HLTProcess.build_source(), geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedTauTagCalibration.data, CombinedSVCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, edm::MapOfVectors< K, T >::Iter.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, confdb.HLTProcess.fixPrescales(), confdb.HLTProcess.instrumentDQM(), confdb.HLTProcess.instrumentErrorEventType(), confdb.HLTProcess.instrumentOpenMode(), confdb.HLTProcess.instrumentTiming(), confdb.HLTProcess.loadSetupCff(), confdb.HLTProcess.overrideGlobalTag(), confdb.HLTProcess.overrideL1MenuXml(), confdb.HLTProcess.overrideOutput(), confdb.HLTProcess.overrideProcessName(), python.rootplot.root2matplotlib.replace(), confdb.HLTProcess.runL1Emulator(), confdb.HLTProcess.specificCustomize(), and confdb.HLTProcess.updateMessageLogger().

dump()

def confdb.HLTProcess.dump

(

self

)

Definition at line 168 of file confdb.py.

  def dump(self):
    self.data = self.data % self.labels
    if self.config.fragment:
      self.data = re.sub( r'\bprocess\b', 'fragment', self.data )
      self.data = re.sub( r'\bProcess\b', 'ProcessFragment', self.data )
    return self.data
 
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedTauTagCalibration.data, CombinedSVCalibration.data, ecal::DigisCollection< StoragePolicy >.data, TrackProbabilityCalibration.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, LASModuleProfile.data, dqmTnP::AbstractFitter.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, calo::multifit::MapMForPM< T >.data, GeometryComparisonPlotter.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, data, EcalShowerContainmentCorrections::Coefficients.data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, confdb.HLTProcess.labels, ecaldqm::binning::AxisSpecs.labels, uploads.output.labels, and svgfig.Ticks.labels.

dumppaths()

def confdb.HLTProcess.dumppaths (   paths )

static

Definition at line 682 of file confdb.py.

  def dumppaths(paths):
    sys.stderr.write('Path selection:\n')
    for path in paths:
      sys.stderr.write('\t%s\n' % path)
    sys.stderr.write('\n\n')
 

expand_filenames()

def confdb.HLTProcess.expand_filenames	(		self,
			input
	)

Definition at line 864 of file confdb.py.

  def expand_filenames(self, input):
    # check if the input is a dataset or a list of files
    if input[0:8] == 'dataset:':
      from .dasFileQuery import dasFileQuery
      # extract the dataset name, and use DAS to fine the list of LFNs
      dataset = input[8:]
      files = dasFileQuery(dataset)
    else:
      # assume a comma-separated list of input files
      files = input.split(',')
    return files
 

Referenced by confdb.HLTProcess.build_source().

expandWildcards()

def confdb.HLTProcess.expandWildcards (   globs,   collection  )

static

Definition at line 127 of file confdb.py.

  def expandWildcards(globs, collection):
    # expand a list of unix-style wildcards matching a given collection
    # wildcards with no matches are silently discarded
    matches = []
    for glob in globs:
      negate = ''
      if glob[0] == '-':
        negate = '-'
        glob   = glob[1:]
      # translate a unix-style glob expression into a regular expression
      filter = re.compile(r'^' + glob.replace('?', '.').replace('*', '.*').replace('[!', '[^') + r'$')
      matches.extend( negate + element for element in collection if filter.match(element) )
    return matches
 
 

References python.rootplot.root2matplotlib.replace().

fixPrescales()

def confdb.HLTProcess.fixPrescales

(

self

)

Definition at line 356 of file confdb.py.

  def fixPrescales(self):
    # update the PrescaleService to match the new list of paths
    if self.options['paths']:
      if self.options['paths'][0][0] == '-':
        # drop requested paths
        for minuspath in self.options['paths']:
          path = minuspath[1:]
          self.data = re.sub(r'      cms.PSet\(  pathName = cms.string\( "%s" \),\n        prescales = cms.vuint32\( .* \)\n      \),?\n' % path, '', self.data)
      else:
        # keep requested paths
        for path in self.all_paths:
          if path not in self.options['paths']:
            self.data = re.sub(r'      cms.PSet\(  pathName = cms.string\( "%s" \),\n        prescales = cms.vuint32\( .* \)\n      \),?\n' % path, '', self.data)
 
    if self.config.prescale and (self.config.prescale.lower() != 'none'):
      # TO DO: check that the requested prescale column is valid
      self.data += """
# force the use of a specific HLT prescale column
if 'PrescaleService' in %(dict)s:
    %(process)s.PrescaleService.forceDefault     = True
    %(process)s.PrescaleService.lvl1DefaultLabel = '%(prescale)s'
"""
 
 

References confdb.HLTProcess.all_paths, geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, ecal::DigisCollection< StoragePolicy >.data, TrackProbabilityCalibration.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, LASModuleProfile.data, dqmTnP::AbstractFitter.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, edm::MapOfVectors< K, T >::Iter.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, TestProcess.TestProcess.options, confdb.HLTProcess.options, Config.Process.options, and validateAlignments.ValidationJobMultiIOV.options.

Referenced by confdb.HLTProcess.customize().

getPathList()

def confdb.HLTProcess.getPathList

(

self

)

Definition at line 102 of file confdb.py.

  def getPathList(self):
    if self.config.menu.run:
      args = ['--runNumber', self.config.menu.run]
    else:
      args = ['--configName', self.config.menu.name]
    args.extend( (
      '--cff',
      '--noedsources',
      '--noes',
      '--noservices',
      '--nosequences',
      '--nomodules'
    ) )
 
    data, err = self.converter.query( *args )
    if 'ERROR' in err or 'Exhausted Resultset' in err or 'CONFIG_NOT_FOUND' in err:
        sys.stderr.write("%s: error while retrieving the list of paths from the HLT menu\n\n" % os.path.basename(sys.argv[0]))
        sys.stderr.write(err + "\n\n")
        sys.exit(1)
    filter = re.compile(r' *= *cms.(End)?Path.*')
    paths  = [ filter.sub('', line) for line in data.splitlines() if filter.search(line) ]
    return paths
 
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, and confdb.HLTProcess.converter.

getRawConfigurationFromDB()

def confdb.HLTProcess.getRawConfigurationFromDB

(

self

)

Definition at line 83 of file confdb.py.

  def getRawConfigurationFromDB(self):
    if self.config.menu.run:
      args = ['--runNumber', self.config.menu.run]
    else:
      args = ['--configName', self.config.menu.name ]
    if not self.config.hilton:
        # keep the original Source when running on Hilton
        args.append('--noedsources')
    for key, vals in self.options.items():
      if vals:
        args.extend(('--'+key, ','.join(vals)))
 
    data, err = self.converter.query( *args )
    if 'ERROR' in err or 'Exhausted Resultset' in err or 'CONFIG_NOT_FOUND' in err:
        sys.stderr.write("%s: error while retrieving the HLT menu\n\n" % os.path.basename(sys.argv[0]))
        sys.stderr.write(err + "\n\n")
        sys.exit(1)
    self.data = data
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, confdb.HLTProcess.converter, mat4.data, CombinedTauTagCalibration.data, CombinedSVCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, LASModuleProfile.data, dqmTnP::AbstractFitter.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, edm::MapOfVectors< K, T >::Iter.data, hcal::raw::InputDataGPU.data, data, EcalShowerContainmentCorrections::Coefficients.data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, mps_monitormerge.items, join(), DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, TestProcess.TestProcess.options, confdb.HLTProcess.options, Config.Process.options, and validateAlignments.ValidationJobMultiIOV.options.

getSetupConfigurationFromDB()

def confdb.HLTProcess.getSetupConfigurationFromDB

(

self

)

Definition at line 60 of file confdb.py.

  def getSetupConfigurationFromDB(self):
    if not self.config.setup:
        return
    
    if ".py" in self.config.setup:
        self.config.setupFile = self.config.setup.split(".py")[0]
        return
    args = ['--configName', self.config.setup ]
    args.append('--noedsources')
    args.append('--nopaths')
    for key, vals in self.options.items():
      if vals:
        args.extend(('--'+key, ','.join(vals)))
    args.append('--cff')
    data, err = self.converter.query( *args )
    if 'ERROR' in err or 'Exhausted Resultset' in err or 'CONFIG_NOT_FOUND' in err:
        sys.stderr.write("%s: error while retrieving the HLT setup menu\n\n" % os.path.basename(sys.argv[0]))
        sys.stderr.write(err + "\n\n")
        sys.exit(1)
    self.config.setupFile = "setup_"+self.config.setup[1:].replace("/","_")+"_cff"
    outfile = open(self.config.setupFile+".py","w+")
    outfile.write("# This file is automatically generated by hltGetConfiguration.\n" + data)
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, confdb.HLTProcess.converter, mps_monitormerge.items, join(), DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, TestProcess.TestProcess.options, confdb.HLTProcess.options, Config.Process.options, validateAlignments.ValidationJobMultiIOV.options, and python.rootplot.root2matplotlib.replace().

instrumentDQM()

def confdb.HLTProcess.instrumentDQM

(

self

)

Definition at line 643 of file confdb.py.

  def instrumentDQM(self):
    if not self.config.hilton:
      # remove any reference to the hltDQMFileSaver and hltDQMFileSaverPB
      # note the convert options remove the module itself, 
      # here we are just removing the references in paths,sequences etc
      if 'hltDQMFileSaverPB' in self.data:      
        self.data = re.sub(r'\b(process\.)?hltDQMFileSaverPB \+ ', '', self.data)
        self.data = re.sub(r' \+ \b(process\.)?hltDQMFileSaverPB', '', self.data)
        self.data = re.sub(r'\b(process\.)?hltDQMFileSaverPB',     '', self.data)
 
      if 'hltDQMFileSaver' in self.data:
        self.data = re.sub(r'\b(process\.)?hltDQMFileSaver \+ ', '', self.data)
        self.data = re.sub(r' \+ \b(process\.)?hltDQMFileSaver', '', self.data)
        self.data = re.sub(r'\b(process\.)?hltDQMFileSaver',     '', self.data)
 
      # instrument the HLT menu with DQMStore and DQMRootOutputModule suitable for running offline
      dqmstore  = "\n# load the DQMStore and DQMRootOutputModule\n"
      dqmstore += self.loadCffCommand('DQMServices.Core.DQMStore_cfi')
      dqmstore += """
%(process)s.dqmOutput = cms.OutputModule("DQMRootOutputModule",
    fileName = cms.untracked.string("DQMIO.root")
)
"""
 
      empty_path = re.compile(r'.*\b(process\.)?DQMOutput = cms\.EndPath\( *\).*')
      other_path = re.compile(r'(.*\b(process\.)?DQMOutput = cms\.EndPath\()(.*)')
      if empty_path.search(self.data):
        # replace an empty DQMOutput path
        self.data = empty_path.sub(dqmstore + '\n%(process)s.DQMOutput = cms.EndPath( %(process)s.dqmOutput )\n', self.data)
      elif other_path.search(self.data):
        # prepend the dqmOutput to the DQMOutput path
        self.data = other_path.sub(dqmstore + r'\g<1> %(process)s.dqmOutput +\g<3>', self.data)
      else:
        # ceate a new DQMOutput path with the dqmOutput module
        self.data += dqmstore
        self.data += '\n%(process)s.DQMOutput = cms.EndPath( %(process)s.dqmOutput )\n'
 
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, KDTreeNodeInfo< DATA, DIM >.data, calo::multifit::MapSymM< T, Stride, Order >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, and confdb.HLTProcess.loadCffCommand().

Referenced by confdb.HLTProcess.customize().

instrumentErrorEventType()

def confdb.HLTProcess.instrumentErrorEventType

(

self

)

Definition at line 394 of file confdb.py.

  def instrumentErrorEventType(self):
    if self.config.errortype:
      # change all HLTTriggerTypeFilter EDFilters to accept only error events (SelectedTriggerType = 0)
      self._fix_parameter(name = 'SelectedTriggerType', type ='int32', value = '1', replace = '0')
      self._fix_parameter(name = 'SelectedTriggerType', type ='int32', value = '2', replace = '0')
      self._fix_parameter(name = 'SelectedTriggerType', type ='int32', value = '3', replace = '0')
 
 

References confdb.HLTProcess._fix_parameter(), geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, and validateAlignments.ValidationJobMultiIOV.config.

Referenced by confdb.HLTProcess.customize().

instrumentOpenMode()

def confdb.HLTProcess.instrumentOpenMode

(

self

)

Definition at line 380 of file confdb.py.

  def instrumentOpenMode(self):
    if self.config.open:
      # find all EDfilters
      filters = [ match[1] for match in re.findall(r'(process\.)?\b(\w+) = cms.EDFilter', self.data) ]
      re_sequence = re.compile( r'cms\.(Path|Sequence)\((.*)\)' )
      # remove existing 'cms.ignore' and '~' modifiers
      self.data = re_sequence.sub( lambda line: re.sub( r'cms\.ignore *\( *((process\.)?\b(\w+)) *\)', r'\1', line.group(0) ), self.data )
      self.data = re_sequence.sub( lambda line: re.sub( r'~', '', line.group(0) ), self.data )
      # wrap all EDfilters with "cms.ignore( ... )", 1000 at a time (python 2.6 complains for too-big regular expressions)
      for some in splitter(filters, 1000):
        re_filters  = re.compile( r'\b((process\.)?(' + r'|'.join(some) + r'))\b' )
        self.data = re_sequence.sub( lambda line: re_filters.sub( r'cms.ignore( \1 )', line.group(0) ), self.data )
 
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, KDTreeNodeInfo< DATA, DIM >.data, calo::multifit::MapSymM< T, Stride, Order >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, and join().

Referenced by confdb.HLTProcess.customize().

instrumentTiming()

def confdb.HLTProcess.instrumentTiming

(

self

)

Definition at line 601 of file confdb.py.

  def instrumentTiming(self):
 
    if self.config.timing:
      self.data += """
# instrument the menu with the modules and EndPath needed for timing studies
"""
 
      self.data += '\n# configure the FastTimerService\n'
      self.loadCff('HLTrigger.Timer.FastTimerService_cfi')
 
      self.data += """# print a text summary at the end of the job
%(process)s.FastTimerService.printEventSummary         = False
%(process)s.FastTimerService.printRunSummary           = False
%(process)s.FastTimerService.printJobSummary           = True
 
# enable DQM plots
%(process)s.FastTimerService.enableDQM                 = True
 
# enable per-path DQM plots (starting with CMSSW 9.2.3-patch2)
%(process)s.FastTimerService.enableDQMbyPath           = True
 
# enable per-module DQM plots
%(process)s.FastTimerService.enableDQMbyModule         = True
 
# enable per-event DQM plots vs lumisection
%(process)s.FastTimerService.enableDQMbyLumiSection    = True
%(process)s.FastTimerService.dqmLumiSectionsRange      = 2500
 
# set the time resolution of the DQM plots
%(process)s.FastTimerService.dqmTimeRange              = 2000.
%(process)s.FastTimerService.dqmTimeResolution         =   10.
%(process)s.FastTimerService.dqmPathTimeRange          = 1000.
%(process)s.FastTimerService.dqmPathTimeResolution     =    5.
%(process)s.FastTimerService.dqmModuleTimeRange        =  200.
%(process)s.FastTimerService.dqmModuleTimeResolution   =    1.
 
# set the base DQM folder for the plots
%(process)s.FastTimerService.dqmPath                   = 'HLT/TimerService'
%(process)s.FastTimerService.enableDQMbyProcesses      = False
"""
 
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, KDTreeNodeInfo< DATA, DIM >.data, calo::multifit::MapSymM< T, Stride, Order >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, and confdb.HLTProcess.loadCff().

Referenced by confdb.HLTProcess.customize().

loadAdditionalConditions()

def confdb.HLTProcess.loadAdditionalConditions	(		self,
			comment,
		*	conditions
	)

Definition at line 565 of file confdb.py.

  def loadAdditionalConditions(self, comment, *conditions):
    # load additional conditions
    self.data += """
# %s
if 'GlobalTag' in %%(dict)s:
""" % comment
    for condition in conditions:
      self.data += """    %%(process)s.GlobalTag.toGet.append(
        cms.PSet(
            record  = cms.string( '%(record)s' ),
            tag     = cms.string( '%(tag)s' ),
            label   = cms.untracked.string( '%(label)s' ),
        )
    )
""" % condition
 
 

References mat4.data, CombinedTauTagCalibration.data, CombinedSVCalibration.data, ecal::DigisCollection< StoragePolicy >.data, TrackProbabilityCalibration.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, LASModuleProfile.data, dqmTnP::AbstractFitter.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, calo::multifit::MapMForPM< T >.data, GeometryComparisonPlotter.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, and edmStreamStallGrapher.Stack.data.

loadCff()

def confdb.HLTProcess.loadCff	(		self,
			module
	)

Definition at line 589 of file confdb.py.

  def loadCff(self, module):
    self.data += self.loadCffCommand(module)
 
 

References mat4.data, CombinedTauTagCalibration.data, CombinedSVCalibration.data, ecal::DigisCollection< StoragePolicy >.data, TrackProbabilityCalibration.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, LASModuleProfile.data, dqmTnP::AbstractFitter.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, calo::multifit::MapMForPM< T >.data, GeometryComparisonPlotter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, edm::MapOfVectors< K, T >::Iter.data, hcal::raw::InputDataGPU.data, data, EcalShowerContainmentCorrections::Coefficients.data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, and confdb.HLTProcess.loadCffCommand().

Referenced by confdb.HLTProcess.instrumentTiming().

loadCffCommand()

def confdb.HLTProcess.loadCffCommand	(		self,
			module
	)

Definition at line 582 of file confdb.py.

  def loadCffCommand(self, module):
    # load a cfi or cff module
    if self.config.fragment:
      return 'from %s import *\n' % module
    else:
      return 'process.load( "%s" )\n' % module
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, and validateAlignments.ValidationJobMultiIOV.config.

Referenced by confdb.HLTProcess.instrumentDQM(), and confdb.HLTProcess.loadCff().

loadSetupCff()

def confdb.HLTProcess.loadSetupCff

(

self

)

Definition at line 525 of file confdb.py.

  def loadSetupCff(self):
    if self.config.setup is None:
      return
    processLine = self.data.find("\n",self.data.find("cms.Process"))
    self.data = self.data[:processLine]+'\nprocess.load("%s")'%self.config.setupFile+self.data[processLine:]
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, KDTreeNodeInfo< DATA, DIM >.data, calo::multifit::MapSymM< T, Stride, Order >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, and spr.find().

Referenced by confdb.HLTProcess.customize().

overrideGlobalTag()

def confdb.HLTProcess.overrideGlobalTag

(

self

)

Definition at line 402 of file confdb.py.

  def overrideGlobalTag(self):
    # overwrite GlobalTag
    # the logic is:
    #   - if a GlobalTag is specified on the command line:
    #      - override the global tag
    #      - if the GT is "auto:...", insert the code to read it from Configuration.AlCa.autoCond
    #   - if a GlobalTag is NOT  specified on the command line:
    #      - when running on data, do nothing, and keep the global tag in the menu
    #      - when running on mc, take the GT from the configuration.type
 
    # override the GlobalTag connection string and pfnPrefix
 
    # when running on MC, override the global tag even if not specified on the command line
    if not self.config.data and not self.config.globaltag:
      if self.config.type in globalTag:
        self.config.globaltag = globalTag[self.config.type]
      else:
        self.config.globaltag = globalTag['GRun']
 
    # if requested, override the L1 menu from the GlobalTag
    if self.config.l1.override:
      self.config.l1.tag    = self.config.l1.override
      self.config.l1.record = 'L1TUtmTriggerMenuRcd'
      self.config.l1.connect = ''
      self.config.l1.label  = ''
      if not self.config.l1.snapshotTime:
        self.config.l1.snapshotTime = '9999-12-31 23:59:59.000'
      self.config.l1cond = '%(tag)s,%(record)s,%(connect)s,%(label)s,%(snapshotTime)s' % self.config.l1.__dict__
    else:
      self.config.l1cond = None
 
    if self.config.globaltag or self.config.l1cond:
      text = """
# override the GlobalTag, connection string and pfnPrefix
if 'GlobalTag' in %(dict)s:
    from Configuration.AlCa.GlobalTag import GlobalTag as customiseGlobalTag
    %(process)s.GlobalTag = customiseGlobalTag(%(process)s.GlobalTag"""
      if self.config.globaltag:
        text += ", globaltag = %s"  % repr(self.config.globaltag)
      if self.config.l1cond:
        text += ", conditions = %s" % repr(self.config.l1cond)
      text += ")\n"
      self.data += text
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, data, EcalShowerContainmentCorrections::Coefficients.data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, and edmStreamStallGrapher.Stack.data.

Referenced by confdb.HLTProcess.customize().

overrideL1MenuXml()

def confdb.HLTProcess.overrideL1MenuXml

(

self

)

Definition at line 446 of file confdb.py.

  def overrideL1MenuXml(self):
    # if requested, override the GlobalTag's L1T menu from an Xml file
    if self.config.l1Xml.XmlFile:
      text = """
# override the GlobalTag's L1T menu from an Xml file
from HLTrigger.Configuration.CustomConfigs import L1XML
%%(process)s = L1XML(%%(process)s,"%s")
""" % (self.config.l1Xml.XmlFile)
      self.data += text
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, data, EcalShowerContainmentCorrections::Coefficients.data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, and edmStreamStallGrapher.Stack.data.

Referenced by confdb.HLTProcess.customize().

overrideOutput()

def confdb.HLTProcess.overrideOutput

(

self

)

Definition at line 466 of file confdb.py.

  def overrideOutput(self):
    # if not runnign on Hilton, override the "online" ShmStreamConsumer output modules with "offline" PoolOutputModule's
    # note for Run3 ShmStreamConsumer has been replaced with EvFOutputModule
    # so we also do a replace there
    if not self.config.hilton:
      self.data = re.sub(
        r'\b(process\.)?hltOutput(\w+) *= *cms\.OutputModule\( *"(ShmStreamConsumer)" *,',
        r'%(process)s.hltOutput\2 = cms.OutputModule( "PoolOutputModule",\n    fileName = cms.untracked.string( "output\2.root" ),\n    fastCloning = cms.untracked.bool( False ),\n    dataset = cms.untracked.PSet(\n        filterName = cms.untracked.string( "" ),\n        dataTier = cms.untracked.string( "RAW" )\n    ),',
        self.data
      )
      self.data = re.sub(
        r'\b(process\.)?hltOutput(\w+) *= *cms\.OutputModule\( *"EvFOutputModule" *,\n    use_compression = cms.untracked.bool\( True \),\n    compression_algorithm = cms.untracked.string\( "ZLIB" \),\n    compression_level = cms.untracked.int32\( 1 \),\n    lumiSection_interval = cms.untracked.int32\( 0 \),\n(.+?),\n    psetMap = cms.untracked.InputTag\( "hltPSetMap" \)\n',
        r'\1hltOutput\2 = cms.OutputModule( "PoolOutputModule",\n    fileName = cms.untracked.string( "output\2.root" ),\n    fastCloning = cms.untracked.bool( False ),\n    dataset = cms.untracked.PSet(\n        filterName = cms.untracked.string( "" ),\n        dataTier = cms.untracked.string( "RAW" )\n    ),\n\3\n',
        self.data,0,re.DOTALL
      )
 
    if not self.config.fragment and self.config.output == 'minimal':
      # add a single output to keep the TriggerResults and TriggerEvent
      self.data += """
# add a single "keep *" output
%(process)s.hltOutputMinimal = cms.OutputModule( "PoolOutputModule",
    fileName = cms.untracked.string( "output.root" ),
    fastCloning = cms.untracked.bool( False ),
    dataset = cms.untracked.PSet(
        dataTier = cms.untracked.string( 'AOD' ),
        filterName = cms.untracked.string( '' )
    ),
    outputCommands = cms.untracked.vstring( 'drop *',
        'keep edmTriggerResults_*_*_*',
        'keep triggerTriggerEvent_*_*_*'
    )
)
%(process)s.MinimalOutput = cms.EndPath( %(process)s.hltOutputMinimal )
"""
    elif not self.config.fragment and self.config.output == 'full':
      # add a single "keep *" output
      self.data += """
# add a single "keep *" output
%(process)s.hltOutputFull = cms.OutputModule( "PoolOutputModule",
    fileName = cms.untracked.string( "output.root" ),
    fastCloning = cms.untracked.bool( False ),
    dataset = cms.untracked.PSet(
        dataTier = cms.untracked.string( 'RECO' ),
        filterName = cms.untracked.string( '' )
    ),
    outputCommands = cms.untracked.vstring( 'keep *' )
)
%(process)s.FullOutput = cms.EndPath( %(process)s.hltOutputFull )
"""
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, data, EcalShowerContainmentCorrections::Coefficients.data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, and edmStreamStallGrapher.Stack.data.

Referenced by confdb.HLTProcess.customize().

overrideParameters()

def confdb.HLTProcess.overrideParameters	(		self,
			module,
			parameters
	)

Definition at line 593 of file confdb.py.

  def overrideParameters(self, module, parameters):
    # override a module's parameter if the module is present in the configuration
    self.data += "if '%s' in %%(dict)s:\n" % module
    for (parameter, value) in parameters:
      self.data += "    %%(process)s.%s.%s = %s\n" % (module, parameter, value)
    self.data += "\n"
 
 

References mat4.data, CombinedTauTagCalibration.data, CombinedSVCalibration.data, ecal::DigisCollection< StoragePolicy >.data, TrackProbabilityCalibration.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, LASModuleProfile.data, dqmTnP::AbstractFitter.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, calo::multifit::MapMForPM< T >.data, GeometryComparisonPlotter.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, and edmStreamStallGrapher.Stack.data.

overrideProcessName()

def confdb.HLTProcess.overrideProcessName

(

self

)

Definition at line 532 of file confdb.py.

  def overrideProcessName(self):
    if self.config.name is None:
      return
 
    # sanitise process name
    self.config.name = self.config.name.replace("_","")
    # override the process name
    quote = '[\'\"]'
    self.data = re.compile(r'^(process\s*=\s*cms\.Process\(\s*' + quote + r')\w+(' + quote + r'\s*\).*)$', re.MULTILINE).sub(r'\1%s\2' % self.config.name, self.data, 1)
 
    # when --setup option is used, remove possible errors from PrescaleService due to missing HLT paths.
    if self.config.setup: self.data += """
# avoid PrescaleService error due to missing HLT paths
if 'PrescaleService' in process.__dict__:
    for pset in reversed(process.PrescaleService.prescaleTable):
        if not hasattr(process,pset.pathName.value()):
            process.PrescaleService.prescaleTable.remove(pset)
"""
    
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, data, EcalShowerContainmentCorrections::Coefficients.data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, and edmStreamStallGrapher.Stack.data.

Referenced by confdb.HLTProcess.customize().

runL1Emulator()

def confdb.HLTProcess.runL1Emulator

(

self

)

Definition at line 456 of file confdb.py.

  def runL1Emulator(self):
    # if requested, run the Full L1T emulator, then repack the data into a new RAW collection, to be used by the HLT
    if self.config.emulator:
      text = """
# run the Full L1T emulator, then repack the data into a new RAW collection, to be used by the HLT
from HLTrigger.Configuration.CustomConfigs import L1REPACK
%%(process)s = L1REPACK(%%(process)s,"%s")
""" % (self.config.emulator)
      self.data += text
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, data, EcalShowerContainmentCorrections::Coefficients.data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, and edmStreamStallGrapher.Stack.data.

Referenced by confdb.HLTProcess.customize().

specificCustomize()

def confdb.HLTProcess.specificCustomize

(

self

)

Definition at line 177 of file confdb.py.

  def specificCustomize(self):
    # specific customizations now live in HLTrigger.Configuration.customizeHLTforALL.customizeHLTforAll(.,.)
    if self.config.fragment:
      self.data += """
# add specific customizations
from HLTrigger.Configuration.customizeHLTforALL import customizeHLTforAll
fragment = customizeHLTforAll(fragment,"%s")
""" % (self.config.type)
    elif self.config.hilton:
      # do not apply the STORM-specific customisation
      pass
    else:
      if self.config.type=="Fake":
        prefix = "run1"
      elif self.config.type in ("Fake1","Fake2","2018"):
        prefix = "run2"
      else:
        prefix = "run3"
      _gtData = "auto:"+prefix+"_hlt_"+self.config.type
      _gtMc   = "auto:"+prefix+"_mc_" +self.config.type
      self.data += """
# add specific customizations
_customInfo = {}
_customInfo['menuType'  ]= "%s"
_customInfo['globalTags']= {}
_customInfo['globalTags'][True ] = "%s"
_customInfo['globalTags'][False] = "%s"
_customInfo['inputFiles']={}
_customInfo['inputFiles'][True]  = "file:RelVal_Raw_%s_DATA.root"
_customInfo['inputFiles'][False] = "file:RelVal_Raw_%s_MC.root"
_customInfo['maxEvents' ]=  %s
_customInfo['globalTag' ]= "%s"
_customInfo['inputFile' ]=  %s
_customInfo['realData'  ]=  %s
from HLTrigger.Configuration.customizeHLTforALL import customizeHLTforAll
%%(process)s = customizeHLTforAll(%%(process)s,"%s",_customInfo)
""" % (self.config.type,_gtData,_gtMc,self.config.type,self.config.type,self.config.events,self.config.globaltag,self.source,self.config.data,self.config.type)
 
    self.data += """
from HLTrigger.Configuration.customizeHLTforCMSSW import customizeHLTforCMSSW
%%(process)s = customizeHLTforCMSSW(%%(process)s,"%s")
""" % (self.config.type)
 
    # Eras-based customisations
    self.data += """
# Eras-based customisations
from HLTrigger.Configuration.Eras import modifyHLTforEras
modifyHLTforEras(%(process)s)
"""
    # add the user-defined customization functions, if any
    if self.config.customise:
        self.data += "\n"
        self.data += "#User-defined customization functions\n"
        for customise in self.config.customise.split(","):
            customiseValues = customise.split(".")
            if len(customiseValues)>=3: raise Exception("--customise option cannot contain more than one dot.")
            if len(customiseValues)==1:
                 customiseValues.append("customise")
            customiseValues[0] = customiseValues[0].replace("/",".")
            self.data += "from "+customiseValues[0]+" import "+customiseValues[1]+"\n"
            self.data += "process = "+customiseValues[1]+"(process)\n"
 
 

References geometry.Alignables.config, confdb.HLTProcess.config, preexistingValidation.PreexistingValidation.config, plottingOptions.BasePlottingOptions.config, pkg.AbstractPkg.config, cscdqm::EventProcessorMutex.config, genericValidation.GenericValidation.config, CSCOfflineClient.config, validateAlignments.ValidationBase.config, CSCMonitorModule.config, cscdqm::Collection.config, cscdqm::Dispatcher.config, cscdqm::EventProcessor.config, validateAlignments.ValidationJobMultiIOV.config, mat4.data, CombinedSVCalibration.data, CombinedTauTagCalibration.data, TrackProbabilityCalibration.data, ecal::DigisCollection< StoragePolicy >.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, dqmTnP::AbstractFitter.data, LASModuleProfile.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, GeometryComparisonPlotter.data, calo::multifit::MapMForPM< T >.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, data, EcalShowerContainmentCorrections::Coefficients.data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, edmStreamStallGrapher.Stack.data, python.rootplot.root2matplotlib.replace(), confdb.HLTProcess.source, lhef::XMLDocument.source, DQMNet::Peer.source, Config.Process.source, gen::Hydjet2Hadronizer.source, and BeautifulSoup.ResultSet.source.

Referenced by confdb.HLTProcess.customize().

updateMessageLogger()

def confdb.HLTProcess.updateMessageLogger

(

self

)

Definition at line 552 of file confdb.py.

  def updateMessageLogger(self):
    # request summary informations from the MessageLogger
    self.data += """
if 'MessageLogger' in %(dict)s:
    %(process)s.MessageLogger.TriggerSummaryProducerAOD = cms.untracked.PSet()
    %(process)s.MessageLogger.L1GtTrigReport = cms.untracked.PSet()
    %(process)s.MessageLogger.L1TGlobalSummary = cms.untracked.PSet()
    %(process)s.MessageLogger.HLTrigReport = cms.untracked.PSet()
    %(process)s.MessageLogger.FastReport = cms.untracked.PSet()
    %(process)s.MessageLogger.ThroughputService = cms.untracked.PSet()
"""
 
 

References mat4.data, CombinedTauTagCalibration.data, CombinedSVCalibration.data, ecal::DigisCollection< StoragePolicy >.data, TrackProbabilityCalibration.data, ElectronLikelihoodCalibration.data, CSCTMBScope.data, ecal::raw::InputDataCPU.data, confdb.HLTProcess.data, SimpleVFATFrameCollection.data, classes.PlotData.data, dqm::DQMFileSaverOnline::SnapshotFiles.data, QGLikelihoodObject.data, calo::multifit::MapSymM< T, Stride, Order >.data, KDTreeNodeInfo< DATA, DIM >.data, hcal::raw::InputDataCPU.data, LASModuleProfile.data, dqmTnP::AbstractFitter.data, QGLikelihoodSystematicsObject.data, TkLasBeam.data, KDTreeNodes< DATA, DIM >.data, ecal::raw::InputDataGPU.data, calo::multifit::MapMForPM< T >.data, GeometryComparisonPlotter.data, edm::MapOfVectors< K, T >::Iter.data, EcalGlobalShowerContainmentCorrectionsVsEta::Coefficients.data, hcal::raw::InputDataGPU.data, EcalShowerContainmentCorrections::Coefficients.data, data, edm::DetSet< T >.data, CTPPSCompositeESSource::BinData< T >.data, cscdqm::Cache.data, DQMNet::Bucket.data, hcal::DigiCollectionBase< StoragePolicy >.data, VFATFrame.data, submitPVValidationJobs.Job.data, and edmStreamStallGrapher.Stack.data.

Referenced by confdb.HLTProcess.customize().

Member Data Documentation

all_paths

confdb.HLTProcess.all_paths

Definition at line 689 of file confdb.py.

Referenced by confdb.HLTProcess.customize(), and confdb.HLTProcess.fixPrescales().

config

confdb.HLTProcess.config

Definition at line 24 of file confdb.py.

Referenced by confdb.HLTProcess.addEras(), confdb.HLTProcess.addGlobalOptions(), confdb.HLTProcess.build_source(), confdb.HLTProcess.buildOptions(), confdb.HLTProcess.customize(), confdb.HLTProcess.dump(), confdb.HLTProcess.fixPrescales(), confdb.HLTProcess.getPathList(), confdb.HLTProcess.getRawConfigurationFromDB(), confdb.HLTProcess.getSetupConfigurationFromDB(), confdb.HLTProcess.instrumentDQM(), confdb.HLTProcess.instrumentErrorEventType(), confdb.HLTProcess.instrumentOpenMode(), confdb.HLTProcess.instrumentTiming(), confdb.HLTProcess.loadCffCommand(), confdb.HLTProcess.loadSetupCff(), confdb.HLTProcess.overrideGlobalTag(), confdb.HLTProcess.overrideL1MenuXml(), confdb.HLTProcess.overrideOutput(), confdb.HLTProcess.overrideProcessName(), confdb.HLTProcess.runL1Emulator(), and confdb.HLTProcess.specificCustomize().

converter

confdb.HLTProcess.converter

Definition at line 53 of file confdb.py.

Referenced by confdb.HLTProcess.getPathList(), confdb.HLTProcess.getRawConfigurationFromDB(), and confdb.HLTProcess.getSetupConfigurationFromDB().

data

confdb.HLTProcess.data

Definition at line 25 of file confdb.py.

Referenced by data_sources.node.__str__(), confdb.HLTProcess._fix_parameter(), confdb.HLTProcess.addEras(), confdb.HLTProcess.addGlobalOptions(), confdb.HLTProcess.append_filenames(), data_sources.json_list.as_dicts(), data_sources.json_list.as_table(), confdb.HLTProcess.build_source(), confdb.HLTProcess.customize(), confdb.HLTProcess.dump(), confdb.HLTProcess.fixPrescales(), data_sources.json_list.get_members(), confdb.HLTProcess.getRawConfigurationFromDB(), confdb.HLTProcess.instrumentDQM(), confdb.HLTProcess.instrumentOpenMode(), confdb.HLTProcess.instrumentTiming(), data_sources.json_list.last(), confdb.HLTProcess.loadAdditionalConditions(), confdb.HLTProcess.loadCff(), confdb.HLTProcess.loadSetupCff(), confdb.HLTProcess.overrideGlobalTag(), confdb.HLTProcess.overrideL1MenuXml(), confdb.HLTProcess.overrideOutput(), confdb.HLTProcess.overrideParameters(), confdb.HLTProcess.overrideProcessName(), confdb.HLTProcess.runL1Emulator(), confdb.HLTProcess.specificCustomize(), cuy.FindIssue.startElement(), and confdb.HLTProcess.updateMessageLogger().

labels

confdb.HLTProcess.labels

Definition at line 40 of file confdb.py.

Referenced by confdb.HLTProcess.dump().

options

confdb.HLTProcess.options

Definition at line 29 of file confdb.py.

Referenced by betterConfigParser.BetterConfigParser.__updateDict(), submitPVValidationJobs.BetterConfigParser.__updateDict(), confdb.HLTProcess.buildOptions(), CrabHelper.CrabHelper.check_crabtask(), betterConfigParser.BetterConfigParser.checkInput(), CrabHelper.CrabHelper.crab_config_filename(), CrabHelper.CrabHelper.crab_config_filepath(), CrabHelper.CrabHelper.crab_taskname(), CrabHelper.CrabHelper.fill_options_from_crab_config(), confdb.HLTProcess.fixPrescales(), confdb.HLTProcess.getRawConfigurationFromDB(), confdb.HLTProcess.getSetupConfigurationFromDB(), edmIntegrityCheck.IntegrityCheck.listFiles(), production_tasks.MonitorJobs.monitor(), edmIntegrityCheck.IntegrityCheck.query(), production_tasks.BaseDataset.query(), edmIntegrityCheck.IntegrityCheck.report(), cmsswPreprocessor.CmsswPreprocessor.run(), production_tasks.CheckDatasetExists.run(), production_tasks.BaseDataset.run(), production_tasks.GenerateMask.run(), production_tasks.CreateJobDirectory.run(), production_tasks.SourceCFG.run(), production_tasks.FullCFG.run(), production_tasks.WriteToDatasets.run(), production_tasks.RunCMSBatch.run(), production_tasks.MonitorJobs.run(), production_tasks.CheckJobStatus.run(), production_tasks.WriteJobReport.run(), production_tasks.CleanJobFiles.run(), edmIntegrityCheck.IntegrityCheck.structured(), CrabHelper.CrabHelper.submit_crab_task(), edmIntegrityCheck.IntegrityCheck.test(), and CrabHelper.CrabHelper.write_crabConfig().

parent

confdb.HLTProcess.parent

Definition at line 27 of file confdb.py.

Referenced by confdb.HLTProcess.build_source(), edmIntegrityCheck.PublishToFileSystem.get(), and edmIntegrityCheck.PublishToFileSystem.publish().

source

confdb.HLTProcess.source

Definition at line 26 of file confdb.py.

Referenced by confdb.HLTProcess.build_source(), and confdb.HLTProcess.specificCustomize().