Inheritance diagram for ConfigBuilder.ConfigBuilder:

Classes
class	MassSearchReplaceProcessNameVisitor

class	PrintAllModules
	load the relevant part More...

Public Member Functions
def	__init__ (self, options, process=None, with_output=False, with_input=False)

def	addCommon (self)

def	addConditions (self)

def	addCustomise (self, unsch=0)

def	addCustomiseCmdLine (self)
	now for a useful command More...

def	addExtraStream (self, name, stream, workflow='full')

def	addMaxEvents (self)

def	addOutput (self)

def	addSource (self)

def	addStandardSequences (self)

def	build_production_info (self, evt_type, evtnumber)

def	completeInputCommand (self)
	add the corresponding input content More...

def	define_Configs (self)

def	doNotInlineEventContent (instance, label="cms.untracked.vstring(process."+theStreamType+"EventContent.outputCommands)")
	event content More...

def	doNotInlineEventContent (instance, label="process."+tmpstreamType+"EventContent.outputCommands")

def	executeAndRemember (self, command)

def	expandMapping (self, seqList, mapping, index=None)

def	filesFromOption (self)

def	finalizeFastSimHLT (self)

def	inGeometryKeys (opt)

def	load (self, includeFile)

def	loadAndRemember (self, includeFile)

def	loadDefaultOrSpecifiedCFF (self, sequence, defaultCFF)

def	prepare (self, doChecking=False)

def	prepare_ALCA (self, sequence=None, workflow='full')

def	prepare_ALCAHARVEST (self, sequence=None)

def	prepare_ALCAOUTPUT (self, sequence=None)

def	prepare_ALCAPRODUCER (self, sequence=None)

def	prepare_CFWRITER (self, sequence=None)

def	prepare_DATAMIX (self, sequence=None)

def	prepare_DIGI (self, sequence=None)

def	prepare_DIGI2RAW (self, sequence=None)

def	prepare_DIGIPREMIX (self, sequence=None)

def	prepare_DIGIPREMIX_S2 (self, sequence=None)

def	prepare_DQM (self, sequence='DQMOffline')

def	prepare_EI (self, sequence=None)

def	prepare_ENDJOB (self, sequence='endOfProcess')

def	prepare_FILTER (self, sequence=None)

def	prepare_GEN (self, sequence=None)

def	prepare_HARVESTING (self, sequence=None)

def	prepare_HLT (self, sequence=None)

def	prepare_L1 (self, sequence=None)

def	prepare_L1HwVal (self, sequence='L1HwVal')

def	prepare_L1Reco (self, sequence="L1Reco")

def	prepare_L1REPACK (self, sequence=None)

def	prepare_L1TrackTrigger (self, sequence="L1TrackTrigger")

def	prepare_LHE (self, sequence=None)

def	prepare_NANO (self, sequence="nanoAOD")

def	prepare_PAT (self, sequence="miniAOD")

def	prepare_PATFILTER (self, sequence=None)

def	prepare_PATGEN (self, sequence="miniGEN")

def	prepare_POSTRECO (self, sequence=None)

def	prepare_RAW2DIGI (self, sequence="RawToDigi")

def	prepare_RAW2RECO (self, sequence=None)

def	prepare_RECO (self, sequence="reconstruction")
	put the filtering path in the schedule More...

def	prepare_RECOBEFMIX (self, sequence="reconstruction")

def	prepare_RECOSIM (self, sequence="recosim")

def	prepare_REPACK (self, sequence=None)

def	prepare_SIM (self, sequence=None)

def	prepare_SKIM (self, sequence="all")

def	prepare_USER (self, sequence=None)

def	prepare_VALIDATION (self, sequence='validation')

def	profileOptions (self)

def	renameHLTprocessInSequence (self, sequence, proc=None, HLTprocess='HLT')

def	renameInputTagsInSequence (self, sequence, oldT="rawDataCollector", newT="rawDataRepacker")

def	scheduleSequence (self, seq, prefix, what='Path')

def	scheduleSequenceAtEnd (self, seq, prefix)

Public Attributes
	ALCADefaultCFF

	DIGI2RAWDefaultCFF

	DIGIDefaultCFF

	DQMSaverCFF

	GENDefaultCFF

	HLTDefaultCFF

	L1EMDefaultCFF

	L1MENUDefaultCFF

	L1RecoDefaultCFF

	L1TrackTriggerDefaultCFF

	NANODefaultCFF

	PATDefaultCFF

	RAW2DIGIDefaultCFF

	RECODefaultCFF

	RECOSIMDefaultCFF

	SIMDefaultCFF

Private Attributes
	_options

Detailed Description

The main building routines

Definition at line 189 of file ConfigBuilder.py.

Constructor & Destructor Documentation

def ConfigBuilder.ConfigBuilder.__init__	(	self,
		options,
		process = `None`,
		with_output = `False`,
		with_input = `False`
	)

options taken from old cmsDriver and optparse

Definition at line 192 of file ConfigBuilder.py.

     def __init__(self, options, process = None, with_output = False, with_input = False ):
         """options taken from old cmsDriver and optparse """
         
         options.outfile_name = options.dirout+options.fileout
 
         self._options = options
 
         if self._options.isData and options.isMC:
                 raise Exception("ERROR: You may specify only --data or --mc, not both")
         #if not self._options.conditions:
         #        raise Exception("ERROR: No conditions given!\nPlease specify conditions. E.g. via --conditions=IDEAL_30X::All")
 

Member Function Documentation

def ConfigBuilder.ConfigBuilder.addCommon ( self )

Definition at line 333 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.profileOptions().

Referenced by ConfigBuilder.ConfigBuilder.prepare().

     def addCommon(self):
             if 'HARVESTING' in self.stepMap.keys() or 'ALCAHARVEST' in self.stepMap.keys():
                     self.process.options = cms.untracked.PSet( Rethrow = cms.untracked.vstring('ProductNotFound'),fileMode = cms.untracked.string('FULLMERGE'))
             else:
                     self.process.options = cms.untracked.PSet( )
 
             self.addedObjects.append(("","options"))
 
             if self._options.lazy_download:
                     self.process.AdaptorConfig = cms.Service("AdaptorConfig",
                                                              stats = cms.untracked.bool(True),
                                                              enable = cms.untracked.bool(True),
                                                              cacheHint = cms.untracked.string("lazy-download"),
                                                              readHint = cms.untracked.string("read-ahead-buffered")
                                                              )
                     self.addedObjects.append(("Setup lazy download","AdaptorConfig"))
 
             #self.process.cmsDriverCommand = cms.untracked.PSet( command=cms.untracked.string('cmsDriver.py '+self._options.arguments) )
             #self.addedObjects.append(("what cmsDriver command was used","cmsDriverCommand"))
 
         if self._options.profile:
             (start, interval, eventFormat, jobFormat)=self.profileOptions()
             self.process.IgProfService = cms.Service("IgProfService",
                                  reportFirstEvent            = cms.untracked.int32(start),
                                  reportEventInterval         = cms.untracked.int32(interval),
                                  reportToFileAtPostEvent     = cms.untracked.string("| gzip -c > %s"%(eventFormat)),
                                  reportToFileAtPostEndJob    = cms.untracked.string("| gzip -c > %s"%(jobFormat)))
             self.addedObjects.append(("Setup IGProf Service for profiling","IgProfService"))
                                  

def ConfigBuilder.ConfigBuilder.addConditions ( self )

Add conditions to the process

Definition at line 805 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

805 def addConditions(self):

806 """Add conditions to the process"""

ConfigBuilder.ConfigBuilder.addConditions

def addConditions(self)

Definition: ConfigBuilder.py:805

def ConfigBuilder.ConfigBuilder.addCustomise	(	self,
		unsch = `0`
	)

Include the customise code

Definition at line 820 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

     def addCustomise(self,unsch=0):
         """Include the customise code """
 

def ConfigBuilder.ConfigBuilder.addCustomiseCmdLine ( self )

now for a useful command

Definition at line 893 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.executeAndRemember().

Referenced by ConfigBuilder.ConfigBuilder.prepare().

893 def addCustomiseCmdLine(self):

894 final_snippet='\n# Customisation from command line\n'

ConfigBuilder.ConfigBuilder.addCustomiseCmdLine

def addCustomiseCmdLine(self)

now for a useful command

Definition: ConfigBuilder.py:893

def ConfigBuilder.ConfigBuilder.addExtraStream	(	self,
		name,
		stream,
		workflow = `'full'`
	)

Definition at line 1133 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_ALCA(), and ConfigBuilder.ConfigBuilder.prepare_SKIM().

     def addExtraStream(self,name,stream,workflow='full'):
             # define output module and go from there
             output = cms.OutputModule("PoolOutputModule")
             if stream.selectEvents.parameters_().__len__()!=0:
                     output.SelectEvents = stream.selectEvents
             else:
                     output.SelectEvents = cms.untracked.PSet()
                     output.SelectEvents.SelectEvents=cms.vstring()
                     if isinstance(stream.paths,tuple):
                             for path in stream.paths:
                                     output.SelectEvents.SelectEvents.append(path.label())
                     else:
                             output.SelectEvents.SelectEvents.append(stream.paths.label())
 
 
 
             if isinstance(stream.content,str):
             evtPset=getattr(self.process,stream.content)
             for p in evtPset.parameters_():
                 setattr(output,p,getattr(evtPset,p))
                     if not self._options.inlineEventContent:
                             def doNotInlineEventContent(instance,label = "process."+stream.content+".outputCommands"):
                                     return label
                             output.outputCommands.__dict__["dumpPython"] = doNotInlineEventContent
             else:
                     output.outputCommands = stream.content
 
 
             output.fileName = cms.untracked.string(self._options.dirout+stream.name+'.root')
 
             output.dataset  = cms.untracked.PSet( dataTier = stream.dataTier,
                                                   filterName = cms.untracked.string(stream.name))
 
             if self._options.filtername:
                     output.dataset.filterName= cms.untracked.string(self._options.filtername+"_"+stream.name)
 
         #add an automatic flushing to limit memory consumption
         output.eventAutoFlushCompressedSize=cms.untracked.int32(5*1024*1024)
 
             if workflow in ("producers,full"):
                     if isinstance(stream.paths,tuple):
                             for path in stream.paths:
                                     self.schedule.append(path)
                     else:
                             self.schedule.append(stream.paths)
 
 
         # in case of relvals we don't want to have additional outputs
             if (not self._options.relval) and workflow in ("full","output"):
                     self.additionalOutputs[name] = output
             setattr(self.process,name,output)
         
             if workflow == 'output':
                     # adjust the select events to the proper trigger results from previous process
                     filterList = output.SelectEvents.SelectEvents
                     for i, filter in enumerate(filterList):
                             filterList[i] = filter+":"+self._options.triggerResultsProcess
 
         return output
     

def ConfigBuilder.ConfigBuilder.addMaxEvents ( self )

Here we decide how many evts will be processed

Definition at line 362 of file ConfigBuilder.py.

References createfilelist.int.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

     def addMaxEvents(self):
         """Here we decide how many evts will be processed"""
         self.process.maxEvents=cms.untracked.PSet(input=cms.untracked.int32(int(self._options.number)))

def ConfigBuilder.ConfigBuilder.addOutput ( self )

Add output module to the process

Definition at line 497 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

497 def addOutput(self):

498 """ Add output module to the process """

ConfigBuilder.ConfigBuilder.addOutput

def addOutput(self)

Definition: ConfigBuilder.py:497

def ConfigBuilder.ConfigBuilder.addSource ( self )

Here the source is built. Priority: file, generator

Definition at line 369 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

     def addSource(self):
         """Here the source is built. Priority: file, generator"""
         self.addedObjects.append(("Input source","source"))
 

def ConfigBuilder.ConfigBuilder.addStandardSequences ( self )

Add selected standard sequences to the process

Definition at line 679 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

     def addStandardSequences(self):
         """
         Add selected standard sequences to the process
         """
         # load the pile up file

def ConfigBuilder.ConfigBuilder.build_production_info	(	self,
		evt_type,
		evtnumber
	)

Add useful info for the production.

Definition at line 2081 of file ConfigBuilder.py.

References harvestTrackValidationPlots.str.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

     def build_production_info(self, evt_type, evtnumber):
         """ Add useful info for the production. """
         self.process.configurationMetadata=cms.untracked.PSet\
                                             (version=cms.untracked.string("$Revision: 1.19 $"),
                                              name=cms.untracked.string("Applications"),
                                              annotation=cms.untracked.string(evt_type+ " nevts:"+str(evtnumber))
                                              )
 
         self.addedObjects.append(("Production Info","configurationMetadata"))
 
 

def ConfigBuilder.ConfigBuilder.completeInputCommand ( self )

add the corresponding input content

Definition at line 774 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

     def completeInputCommand(self):
         if self._options.inputEventContent:
             import copy
             def dropSecondDropStar(iec):
                 #drop occurence of 'drop *' in the list
                 count=0
                 for item in iec:
                     if item=='drop *':
                         if count!=0:
                             iec.remove(item)
                         count+=1
 
 
             ## allow comma separated input eventcontent
             if not hasattr(self.process.source,'inputCommands'): self.process.source.inputCommands=cms.untracked.vstring()
             for evct in self._options.inputEventContent.split(','):
                 if evct=='': continue
                 theEventContent = getattr(self.process, evct+"EventContent")
                 if hasattr(theEventContent,'outputCommands'):
                     self.process.source.inputCommands.extend(copy.copy(theEventContent.outputCommands))
                 if hasattr(theEventContent,'inputCommands'):
                     self.process.source.inputCommands.extend(copy.copy(theEventContent.inputCommands))
 
             dropSecondDropStar(self.process.source.inputCommands)
             
             if not self._options.dropDescendant:
                 self.process.source.dropDescendantsOfDroppedBranches = cms.untracked.bool(False)
 
                 
         return 
 

def ConfigBuilder.ConfigBuilder.define_Configs ( self )

Definition at line 908 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadAndRemember().

     def define_Configs(self):
         if len(self.stepMap):
         self.loadAndRemember('Configuration/StandardSequences/Services_cff')
         if self._options.particleTable not in defaultOptions.particleTableList:
             print 'Invalid particle table provided. Options are:'
             print defaultOptions.particleTable
             sys.exit(-1)
         else:
         if len(self.stepMap):
             self.loadAndRemember('SimGeneral.HepPDTESSource.'+self._options.particleTable+'_cfi')
 
         self.loadAndRemember('FWCore/MessageService/MessageLogger_cfi')
 
         self.ALCADefaultCFF="Configuration/StandardSequences/AlCaRecoStreams_cff"
         self.GENDefaultCFF="Configuration/StandardSequences/Generator_cff"
         self.SIMDefaultCFF="Configuration/StandardSequences/Sim_cff"
         self.DIGIDefaultCFF="Configuration/StandardSequences/Digi_cff"
         self.DIGI2RAWDefaultCFF="Configuration/StandardSequences/DigiToRaw_cff"
         self.L1EMDefaultCFF='Configuration/StandardSequences/SimL1Emulator_cff'
         self.L1MENUDefaultCFF="Configuration/StandardSequences/L1TriggerDefaultMenu_cff"
         self.HLTDefaultCFF="Configuration/StandardSequences/HLTtable_cff"
         self.RAW2DIGIDefaultCFF="Configuration/StandardSequences/RawToDigi_Data_cff"
         self.L1RecoDefaultCFF="Configuration/StandardSequences/L1Reco_cff"
         self.L1TrackTriggerDefaultCFF="Configuration/StandardSequences/L1TrackTrigger_cff"
         self.RECODefaultCFF="Configuration/StandardSequences/Reconstruction_Data_cff"
         self.RECOSIMDefaultCFF="Configuration/StandardSequences/RecoSim_cff"
         self.PATDefaultCFF="Configuration/StandardSequences/PAT_cff"
         self.NANODefaultCFF="PhysicsTools/NanoAOD/nano_cff"

def ConfigBuilder.ConfigBuilder.doNotInlineEventContent	(	instance,
		label = `"cms.untracked.vstring(process."+theStreamType+"EventContent.outputCommands)"`
	)

event content

Definition at line 589 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addExtraStream(), and ConfigBuilder.ConfigBuilder.doNotInlineEventContent().

589 def doNotInlineEventContent(instance,label = "cms.untracked.vstring(process."+theStreamType+"EventContent.outputCommands)"):

590 return label

ConfigBuilder.ConfigBuilder.doNotInlineEventContent

def doNotInlineEventContent(instance, label="cms.untracked.vstring(process."+theStreamType+"EventContent.outputCommands)")

event content

Definition: ConfigBuilder.py:589

def ConfigBuilder.ConfigBuilder.doNotInlineEventContent	(	instance,
		label = `"process."+tmpstreamType+"EventContent.outputCommands"`
	)

Definition at line 671 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.doNotInlineEventContent().

             def doNotInlineEventContent(instance,label = "process."+tmpstreamType+"EventContent.outputCommands"):
                                 return label
                         outputModule.outputCommands.__dict__["dumpPython"] = doNotInlineEventContent
 
                 result+="\nprocess."+outputModuleName+" = "+outputModule.dumpPython()
 

def ConfigBuilder.ConfigBuilder.executeAndRemember	(	self,
		command
	)

helper routine to remember replace statements

Definition at line 324 of file ConfigBuilder.py.

     def executeAndRemember(self, command):
         """helper routine to remember replace statements"""
         self.additionalCommands.append(command)
         if not command.strip().startswith("#"):
             # substitute: process.foo = process.bar -> self.process.foo = self.process.bar
             import re
             exec(re.sub(r"([^a-zA-Z_0-9]|^)(process)([^a-zA-Z_0-9])",r"\1self.process\3",command))
             #exec(command.replace("process.","self.process."))
 

def ConfigBuilder.ConfigBuilder.expandMapping	(	self,
		seqList,
		mapping,
		index = `None`
	)

Definition at line 1949 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_ALCA(), ConfigBuilder.ConfigBuilder.prepare_ALCAHARVEST(), ConfigBuilder.ConfigBuilder.prepare_DQM(), ConfigBuilder.ConfigBuilder.prepare_SKIM(), and ConfigBuilder.ConfigBuilder.prepare_VALIDATION().

     def expandMapping(self,seqList,mapping,index=None):
         maxLevel=20
         level=0
         while '@' in repr(seqList) and level<maxLevel:
             level+=1
             for specifiedCommand in seqList:
                 if specifiedCommand.startswith('@'):
                     location=specifiedCommand[1:]
                     if not location in mapping:
                         raise Exception("Impossible to map "+location+" from "+repr(mapping))
                     mappedTo=mapping[location]
                     if index!=None:
                         mappedTo=mappedTo[index]
                     seqList.remove(specifiedCommand)
                     seqList.extend(mappedTo.split('+'))
                     break;
         if level==maxLevel:
             raise Exception("Could not fully expand "+repr(seqList)+" from "+repr(mapping))
         

def ConfigBuilder.ConfigBuilder.filesFromOption ( self )

Definition at line 373 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.filesFromDASQuery(), ConfigBuilder.filesFromList(), createfilelist.int, split, and ThrowAndSetRandomRun.throwAndSetRandomRun().

     def filesFromOption(self):
         for entry in self._options.filein.split(','):
             print "entry",entry
             if entry.startswith("filelist:"):
                 filesFromList(entry[9:],self.process.source)
             elif entry.startswith("dbs:") or entry.startswith("das:"):
                 filesFromDASQuery('file dataset = %s'%(entry[4:]),self._options.dasoption,self.process.source)
             else:
                 self.process.source.fileNames.append(self._options.dirin+entry)
         if self._options.secondfilein:
             if not hasattr(self.process.source,"secondaryFileNames"):
                 raise Exception("--secondfilein not compatible with "+self._options.filetype+"input type")
             for entry in self._options.secondfilein.split(','):
                 print "entry",entry
                 if entry.startswith("filelist:"):
                     self.process.source.secondaryFileNames.extend((filesFromList(entry[9:]))[0])
                 elif entry.startswith("dbs:") or entry.startswith("das:"):
                     self.process.source.secondaryFileNames.extend((filesFromDASQuery('file dataset = %s'%(entry[4:]),self._options.dasoption))[0])
                 else:
                     self.process.source.secondaryFileNames.append(self._options.dirin+entry)
 
         if self._options.filein or self._options.dasquery:
        if self._options.filetype == "EDM":
            self.process.source=cms.Source("PoolSource",
                           fileNames = cms.untracked.vstring(),
                           secondaryFileNames= cms.untracked.vstring())
            filesFromOption(self)
        elif self._options.filetype == "DAT":
            self.process.source=cms.Source("NewEventStreamFileReader",fileNames = cms.untracked.vstring())
            filesFromOption(self)
            elif self._options.filetype == "LHE":
            self.process.source=cms.Source("LHESource", fileNames = cms.untracked.vstring())
            if self._options.filein.startswith("lhe:"):
                #list the article directory automatically
                args=self._options.filein.split(':')
                article=args[1]
                print 'LHE input from article ',article
                location='/store/lhe/'
                import os
                textOfFiles=os.popen('cmsLHEtoEOSManager.py -l '+article)
                for line in textOfFiles:
                    for fileName in [x for x in line.split() if '.lhe' in x]:
                        self.process.source.fileNames.append(location+article+'/'+fileName)
                #check first if list of LHE files is loaded (not empty)
                if len(line)<2:
                    print 'Issue to load LHE files, please check and try again.'
                    sys.exit(-1)
                #Additional check to protect empty fileNames in process.source
                if len(self.process.source.fileNames)==0:
                    print 'Issue with empty filename, but can pass line check'
                    sys.exit(-1)
                if len(args)>2:
                    self.process.source.skipEvents = cms.untracked.uint32(int(args[2]))
            else:
                filesFromOption(self)
            
        elif self._options.filetype == "DQM":
            self.process.source=cms.Source("DQMRootSource",
                           fileNames = cms.untracked.vstring())
            filesFromOption(self)
 
        elif self._options.filetype == "DQMDAQ":
            # FIXME: how to configure it if there are no input files specified?
            self.process.source=cms.Source("DQMStreamerReader")
            
                
            if ('HARVESTING' in self.stepMap.keys() or 'ALCAHARVEST' in self.stepMap.keys()) and (not self._options.filetype == "DQM"):
                self.process.source.processingMode = cms.untracked.string("RunsAndLumis")
 

def ConfigBuilder.ConfigBuilder.finalizeFastSimHLT ( self )

Definition at line 2076 of file ConfigBuilder.py.

     def finalizeFastSimHLT(self):
             self.process.reconstruction = cms.Path(self.process.reconstructionWithFamos)
             self.schedule.append(self.process.reconstruction)
 
 

def ConfigBuilder.ConfigBuilder.inGeometryKeys ( opt )

Definition at line 1073 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.RECODefaultCFF, ConfigBuilder.ConfigBuilder.SIMDefaultCFF, and split.

         def inGeometryKeys(opt):
             from Configuration.StandardSequences.GeometryConf import GeometryConf
             if opt in GeometryConf:
                 return GeometryConf[opt]
             else:
                 return opt
 

def ConfigBuilder.ConfigBuilder.load	(	self,
		includeFile
	)

Definition at line 310 of file ConfigBuilder.py.

Referenced by MatrixToProcess.MatrixToProcess.getProcess(), and MatrixToProcess.MatrixToProcess.listAll().

     def load(self,includeFile):
         includeFile = includeFile.replace('/','.')
         self.process.load(includeFile)
         return sys.modules[includeFile]
 

def ConfigBuilder.ConfigBuilder.loadAndRemember	(	self,
		includeFile
	)

helper routine to load am memorize imports

Definition at line 315 of file ConfigBuilder.py.

     def loadAndRemember(self, includeFile):
         """helper routine to load am memorize imports"""
         # we could make the imports a on-the-fly data method of the process instance itself
         # not sure if the latter is a good idea
         includeFile = includeFile.replace('/','.')
         self.imports.append(includeFile)
         self.process.load(includeFile)
         return sys.modules[includeFile]
 

def ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF	(	self,
		sequence,
		defaultCFF
	)

Definition at line 1198 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadAndRemember().

     def loadDefaultOrSpecifiedCFF(self, sequence,defaultCFF):
             if ( len(sequence.split('.'))==1 ):
                     l=self.loadAndRemember(defaultCFF)
             elif ( len(sequence.split('.'))==2 ):
                     l=self.loadAndRemember(sequence.split('.')[0])
                     sequence=sequence.split('.')[1]
             else:
                     print "sub sequence configuration must be of the form dir/subdir/cff.a+b+c or cff.a"
                     print sequence,"not recognized"
                     raise
             return l
 

def ConfigBuilder.ConfigBuilder.prepare	(	self,
		doChecking = `False`
	)

Prepare the configuration string and add missing pieces.

Definition at line 2092 of file ConfigBuilder.py.

     def prepare(self, doChecking = False):
         """ Prepare the configuration string and add missing pieces."""
 
         self.loadAndRemember(self.EVTCONTDefaultCFF)  #load the event contents regardless
         self.addMaxEvents()
         if self.with_input:
            self.addSource()

def ConfigBuilder.ConfigBuilder.prepare_ALCA	(	self,
		sequence = `None`,
		workflow = `'full'`
	)

Enrich the process with alca streams

Definition at line 1245 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_ALCAOUTPUT(), and ConfigBuilder.ConfigBuilder.prepare_ALCAPRODUCER().

     def prepare_ALCA(self, sequence = None, workflow = 'full'):
         """ Enrich the process with alca streams """
         alcaConfig=self.loadDefaultOrSpecifiedCFF(sequence,self.ALCADefaultCFF)
         sequence = sequence.split('.')[-1]
 
         # decide which ALCA paths to use
         alcaList = sequence.split("+")

def ConfigBuilder.ConfigBuilder.prepare_ALCAHARVEST	(	self,
		sequence = `None`
	)

Enrich the process with AlCaHarvesting step

Definition at line 2041 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.ConfigBuilder.expandMapping(), ConfigBuilder.ConfigBuilder.loadAndRemember(), and harvestTrackValidationPlots.str.

     def prepare_ALCAHARVEST(self, sequence = None):
         """ Enrich the process with AlCaHarvesting step """
         harvestingConfig = self.loadAndRemember(self.ALCAHARVESTDefaultCFF)
         sequence=sequence.split(".")[-1]
 
         # decide which AlcaHARVESTING paths to use
         harvestingList = sequence.split("+")
 
 
 

def ConfigBuilder.ConfigBuilder.prepare_ALCAOUTPUT	(	self,
		sequence = `None`
	)

Definition at line 1242 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.prepare_ALCA().

     def prepare_ALCAOUTPUT(self, sequence = None):
         self.prepare_ALCA(sequence, workflow = "output")
 

def ConfigBuilder.ConfigBuilder.prepare_ALCAPRODUCER	(	self,
		sequence = `None`
	)

Definition at line 1239 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.prepare_ALCA().

     def prepare_ALCAPRODUCER(self, sequence = None):
         self.prepare_ALCA(sequence, workflow = "producers")
 

def ConfigBuilder.ConfigBuilder.prepare_CFWRITER	(	self,
		sequence = `None`
	)

Enrich the schedule with the crossing frame writer step

Definition at line 1467 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadAndRemember(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_CFWRITER(self, sequence = None):
         """ Enrich the schedule with the crossing frame writer step"""
         self.loadAndRemember(self.CFWRITERDefaultCFF)
         self.scheduleSequence('pcfw','cfwriter_step')
         return
 

def ConfigBuilder.ConfigBuilder.prepare_DATAMIX	(	self,
		sequence = `None`
	)

Enrich the schedule with the digitisation step

Definition at line 1473 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.filesFromDASQuery(), ConfigBuilder.filesFromList(), ConfigBuilder.ConfigBuilder.loadAndRemember(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_DATAMIX(self, sequence = None):
         """ Enrich the schedule with the digitisation step"""
         self.loadAndRemember(self.DATAMIXDefaultCFF)
         self.scheduleSequence('pdatamix','datamixing_step')
 
         if self._options.pileup_input:
             theFiles=''
             if self._options.pileup_input.startswith('dbs:') or self._options.pileup_input.startswith('das:'):
                 theFiles=filesFromDASQuery('file dataset = %s'%(self._options.pileup_input[4:],),self._options.pileup_dasoption)[0]
             elif self._options.pileup_input.startswith("filelist:"):
                 theFiles= (filesFromList(self._options.pileup_input[9:]))[0]
             else:
                 theFiles=self._options.pileup_input.split(',')
             #print theFiles
             self.executeAndRemember( "process.mixData.input.fileNames = cms.untracked.vstring(%s)"%(  theFiles ) )
 
         return
 

def ConfigBuilder.ConfigBuilder.prepare_DIGI	(	self,
		sequence = `None`
	)

Enrich the schedule with the digitisation step

Definition at line 1418 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.DIGIDefaultCFF, ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_DIGI(self, sequence = None):
         """ Enrich the schedule with the digitisation step"""
         self.loadDefaultOrSpecifiedCFF(sequence,self.DIGIDefaultCFF)
 
         if self._options.gflash==True:
                 self.loadAndRemember("Configuration/StandardSequences/GFlashDIGI_cff")
 
         if sequence == 'pdigi_valid' or sequence == 'pdigi_hi':
             self.executeAndRemember("process.mix.digitizers = cms.PSet(process.theDigitizersValid)")
 

def ConfigBuilder.ConfigBuilder.prepare_DIGI2RAW	(	self,
		sequence = `None`
	)

Definition at line 1491 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.DIGI2RAWDefaultCFF, ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_DIGI2RAW(self, sequence = None):
             self.loadDefaultOrSpecifiedCFF(sequence,self.DIGI2RAWDefaultCFF)
         self.scheduleSequence(sequence.split('.')[-1],'digi2raw_step')
         if "DIGIPREMIX" in self.stepMap.keys():
             self.executeAndRemember("process.esDigiToRaw.Label = cms.string('mix')")  ##terrible hack - bypass zero suppression
             self.executeAndRemember("process.SiStripDigiToRaw.FedReadoutMode = cms.string('PREMIX_RAW')") ##special readout mode for StripTracker
 
             return
 

def ConfigBuilder.ConfigBuilder.prepare_DIGIPREMIX	(	self,
		sequence = `None`
	)

Enrich the schedule with the digitisation step

Definition at line 1438 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.DIGIDefaultCFF, ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_DIGIPREMIX(self, sequence = None):
         """ Enrich the schedule with the digitisation step"""
         self.loadDefaultOrSpecifiedCFF(sequence,self.DIGIDefaultCFF)
 

def ConfigBuilder.ConfigBuilder.prepare_DIGIPREMIX_S2	(	self,
		sequence = `None`
	)

Enrich the schedule with the digitisation step

Definition at line 1452 of file ConfigBuilder.py.

1452 def prepare_DIGIPREMIX_S2(self, sequence = None):

1453 """ Enrich the schedule with the digitisation step"""

ConfigBuilder.ConfigBuilder.prepare_DIGIPREMIX_S2

def prepare_DIGIPREMIX_S2(self, sequence=None)

Definition: ConfigBuilder.py:1452

def ConfigBuilder.ConfigBuilder.prepare_DQM	(	self,
		sequence = `'DQMOffline'`
	)

Definition at line 1968 of file ConfigBuilder.py.

     def prepare_DQM(self, sequence = 'DQMOffline'):
         # this one needs replacement
 
         self.loadDefaultOrSpecifiedCFF(sequence,self.DQMOFFLINEDefaultCFF)
         sequenceList=sequence.split('.')[-1].split('+')
         postSequenceList=sequence.split('.')[-1].split('+')

def ConfigBuilder.ConfigBuilder.prepare_EI	(	self,
		sequence = `None`
	)

Enrich the schedule with event interpretation

Definition at line 1726 of file ConfigBuilder.py.

1726 def prepare_EI(self, sequence = None):

1727 ''' Enrich the schedule with event interpretation '''

ConfigBuilder.ConfigBuilder.prepare_EI

def prepare_EI(self, sequence=None)

Definition: ConfigBuilder.py:1726

def ConfigBuilder.ConfigBuilder.prepare_ENDJOB	(	self,
		sequence = `'endOfProcess'`
	)

Definition at line 2071 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), and ConfigBuilder.ConfigBuilder.scheduleSequenceAtEnd().

     def prepare_ENDJOB(self, sequence = 'endOfProcess'):
         self.loadDefaultOrSpecifiedCFF(sequence,self.ENDJOBDefaultCFF)
         self.scheduleSequenceAtEnd(sequence.split('.')[-1],'endjob_step')
         return
 

def ConfigBuilder.ConfigBuilder.prepare_FILTER	(	self,
		sequence = `None`
	)

Enrich the schedule with a user defined filter sequence

Definition at line 1623 of file ConfigBuilder.py.

1623 def prepare_FILTER(self, sequence = None):

1624 ''' Enrich the schedule with a user defined filter sequence '''

ConfigBuilder.ConfigBuilder.prepare_FILTER

def prepare_FILTER(self, sequence=None)

Definition: ConfigBuilder.py:1623

def ConfigBuilder.ConfigBuilder.prepare_GEN	(	self,
		sequence = `None`
	)

load the fragment of generator configuration

Definition at line 1320 of file ConfigBuilder.py.

1320 def prepare_GEN(self, sequence = None):

1321 """ load the fragment of generator configuration """

ConfigBuilder.ConfigBuilder.prepare_GEN

def prepare_GEN(self, sequence=None)

Definition: ConfigBuilder.py:1320

def ConfigBuilder.ConfigBuilder.prepare_HARVESTING	(	self,
		sequence = `None`
	)

Enrich the process with harvesting step

Definition at line 2005 of file ConfigBuilder.py.

     def prepare_HARVESTING(self, sequence = None):
         """ Enrich the process with harvesting step """
         self.DQMSaverCFF='Configuration/StandardSequences/DQMSaver'+self._options.harvesting+'_cff'
         self.loadAndRemember(self.DQMSaverCFF)
 
         harvestingConfig = self.loadDefaultOrSpecifiedCFF(sequence,self.HARVESTINGDefaultCFF)
         sequence = sequence.split('.')[-1]
 
         # decide which HARVESTING paths to use
         harvestingList = sequence.split("+")

def ConfigBuilder.ConfigBuilder.prepare_HLT	(	self,
		sequence = `None`
	)

Enrich the schedule with the HLT simulation step

Definition at line 1525 of file ConfigBuilder.py.

     def prepare_HLT(self, sequence = None):
         """ Enrich the schedule with the HLT simulation step"""
         if not sequence:
                 print "no specification of the hlt menu has been given, should never happen"
                 raise  Exception('no HLT sequence provided')
 
         if '@' in sequence:
                 # case where HLT:@something was provided
                 from Configuration.HLT.autoHLT import autoHLT
                 key = sequence[1:]
                 if key in autoHLT:
                   sequence = autoHLT[key]
                 else:
                   raise ValueError('no HLT mapping key "%s" found in autoHLT' % key)
 
         if ',' in sequence:
                 #case where HLT:something:something was provided
                 self.executeAndRemember('import HLTrigger.Configuration.Utilities')
                 optionsForHLT = {}
                 if self._options.scenario == 'HeavyIons':
                   optionsForHLT['type'] = 'HIon'
                 else:
                   optionsForHLT['type'] = 'GRun'
                 optionsForHLTConfig = ', '.join('%s=%s' % (key, repr(val)) for (key, val) in optionsForHLT.iteritems())
         if sequence == 'run,fromSource':
             if hasattr(self.process.source,'firstRun'):
                 self.executeAndRemember('process.loadHltConfiguration("run:%%d"%%(process.source.firstRun.value()),%s)'%(optionsForHLTConfig))
             elif hasattr(self.process.source,'setRunNumber'):
                 self.executeAndRemember('process.loadHltConfiguration("run:%%d"%%(process.source.setRunNumber.value()),%s)'%(optionsForHLTConfig))
             else:
                 raise Exception('Cannot replace menu to load %s'%(sequence))
         else:
             self.executeAndRemember('process.loadHltConfiguration("%s",%s)'%(sequence.replace(',',':'),optionsForHLTConfig))
         else:
         self.loadAndRemember('HLTrigger/Configuration/HLT_%s_cff'       % sequence)
 
         if self._options.isMC:
         self._options.customisation_file.append("HLTrigger/Configuration/customizeHLTforMC.customizeHLTforMC")
 

def ConfigBuilder.ConfigBuilder.prepare_L1	(	self,
		sequence = `None`
	)

Enrich the schedule with the L1 simulation step

Definition at line 1505 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.L1EMDefaultCFF, ConfigBuilder.ConfigBuilder.loadAndRemember(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_L1(self, sequence = None):
         """ Enrich the schedule with the L1 simulation step"""
             assert(sequence == None)
         self.loadAndRemember(self.L1EMDefaultCFF)
         self.scheduleSequence('SimL1Emulator','L1simulation_step')
         return
 

def ConfigBuilder.ConfigBuilder.prepare_L1HwVal	(	self,
		sequence = `'L1HwVal'`
	)

Enrich the schedule with L1 HW validation

Definition at line 1604 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF().

     def prepare_L1HwVal(self, sequence = 'L1HwVal'):
         ''' Enrich the schedule with L1 HW validation '''
         self.loadDefaultOrSpecifiedCFF(sequence,self.L1HwValDefaultCFF)

def ConfigBuilder.ConfigBuilder.prepare_L1Reco	(	self,
		sequence = `"L1Reco"`
	)

Enrich the schedule with L1 reconstruction

Definition at line 1611 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.L1RecoDefaultCFF, ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_L1Reco(self, sequence = "L1Reco"):
         ''' Enrich the schedule with L1 reconstruction '''
         self.loadDefaultOrSpecifiedCFF(sequence,self.L1RecoDefaultCFF)

def ConfigBuilder.ConfigBuilder.prepare_L1REPACK	(	self,
		sequence = `None`
	)

Enrich the schedule with the L1 simulation step, running the L1 emulator on data unpacked from the RAW collection, and repacking the result in a new RAW collection

Definition at line 1512 of file ConfigBuilder.py.

     def prepare_L1REPACK(self, sequence = None):
             """ Enrich the schedule with the L1 simulation step, running the L1 emulator on data unpacked from the RAW collection, and repacking the result in a new RAW collection"""
         supported = ['GT','GT1','GT2','GCTGT','Full','FullSimTP','FullMC','Full2015Data','uGT']
             if sequence in supported:
                 self.loadAndRemember('Configuration/StandardSequences/SimL1EmulatorRepack_%s_cff'%sequence)
         if self._options.scenario == 'HeavyIons':
             self.renameInputTagsInSequence("SimL1Emulator","rawDataCollector","rawDataRepacker")
         self.scheduleSequence('SimL1Emulator','L1RePack_step')
         else:
                 print "L1REPACK with '",sequence,"' is not supported! Supported choices are: ",supported
                 raise Exception('unsupported feature')
 
 

def ConfigBuilder.ConfigBuilder.prepare_L1TrackTrigger	(	self,
		sequence = `"L1TrackTrigger"`
	)

Enrich the schedule with L1 reconstruction

Definition at line 1617 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.L1TrackTriggerDefaultCFF, ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_L1TrackTrigger(self, sequence = "L1TrackTrigger"):
         ''' Enrich the schedule with L1 reconstruction '''
         self.loadDefaultOrSpecifiedCFF(sequence,self.L1TrackTriggerDefaultCFF)

def ConfigBuilder.ConfigBuilder.prepare_LHE	(	self,
		sequence = `None`
	)

Definition at line 1303 of file ConfigBuilder.py.

     def prepare_LHE(self, sequence = None):
         #load the fragment
         ##make it loadable
         loadFragment = self._options.evt_type.replace('.py','',).replace('.','_').replace('python/','').replace('/','.')
         print "Loading lhe fragment from",loadFragment
         __import__(loadFragment)
         self.process.load(loadFragment)
         ##inline the modules
         self._options.inlineObjets+=','+sequence
         
         getattr(self.process,sequence).nEvents = int(self._options.number)
         
         #schedule it
         self.process.lhe_step = cms.Path( getattr( self.process,sequence)  )
         self.excludedPaths.append("lhe_step")
         self.schedule.append( self.process.lhe_step )
 

def ConfigBuilder.ConfigBuilder.prepare_NANO	(	self,
		sequence = `"nanoAOD"`
	)

Enrich the schedule with NANO

Definition at line 1711 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.NANODefaultCFF, and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_NANO(self, sequence = "nanoAOD"):
         ''' Enrich the schedule with NANO '''
         self.loadDefaultOrSpecifiedCFF(sequence,self.NANODefaultCFF)

def ConfigBuilder.ConfigBuilder.prepare_PAT	(	self,
		sequence = `"miniAOD"`
	)

Enrich the schedule with PAT

Definition at line 1676 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.PATDefaultCFF, and ConfigBuilder.ConfigBuilder.prepare_PATFILTER().

     def prepare_PAT(self, sequence = "miniAOD"):
         ''' Enrich the schedule with PAT '''
         self.prepare_PATFILTER(self)
         self.loadDefaultOrSpecifiedCFF(sequence,self.PATDefaultCFF)
         self.labelsToAssociate.append('patTask')
         if not self._options.runUnscheduled:
                raise Exception("MiniAOD production can only run in unscheduled mode, please run cmsDriver with --runUnscheduled")
         if self._options.isData:
             self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllData")
         else:
             if self._options.fast:
                 self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllMCFastSim")
             else:
                 self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllMC")
 

def ConfigBuilder.ConfigBuilder.prepare_PATFILTER	(	self,
		sequence = `None`
	)

Definition at line 1598 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_PAT().

     def prepare_PATFILTER(self, sequence=None):
             self.loadAndRemember("PhysicsTools/PatAlgos/slimming/metFilterPaths_cff")
         from PhysicsTools.PatAlgos.slimming.metFilterPaths_cff import allMetFilterPaths
         for filt in allMetFilterPaths:
             self.schedule.append(getattr(self.process,'Flag_'+filt))
 

def ConfigBuilder.ConfigBuilder.prepare_PATGEN	(	self,
		sequence = `"miniGEN"`
	)

Enrich the schedule with PATGEN

Definition at line 1701 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF().

     def prepare_PATGEN(self, sequence = "miniGEN"):
         ''' Enrich the schedule with PATGEN '''
         self.loadDefaultOrSpecifiedCFF(sequence,self.PATGENDefaultCFF) #this is unscheduled
         self.labelsToAssociate.append('patGENTask')

def ConfigBuilder.ConfigBuilder.prepare_POSTRECO	(	self,
		sequence = `None`
	)

Enrich the schedule with the postreco step

Definition at line 1788 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadAndRemember(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_POSTRECO(self, sequence = None):
         """ Enrich the schedule with the postreco step """
         self.loadAndRemember(self.POSTRECODefaultCFF)

def ConfigBuilder.ConfigBuilder.prepare_RAW2DIGI	(	self,
		sequence = `"RawToDigi"`
	)

Definition at line 1591 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.RAW2DIGIDefaultCFF, and ConfigBuilder.ConfigBuilder.scheduleSequence().

Referenced by ConfigBuilder.ConfigBuilder.prepare_RAW2RECO().

     def prepare_RAW2DIGI(self, sequence = "RawToDigi"):
             self.loadDefaultOrSpecifiedCFF(sequence,self.RAW2DIGIDefaultCFF)
         self.scheduleSequence(sequence,'raw2digi_step')
         #       if self._options.isRepacked:
         #self.renameInputTagsInSequence(sequence)
             return
 

def ConfigBuilder.ConfigBuilder.prepare_RAW2RECO	(	self,
		sequence = `None`
	)

Definition at line 1580 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.prepare_RAW2DIGI(), and ConfigBuilder.ConfigBuilder.prepare_RECO().

     def prepare_RAW2RECO(self, sequence = None):
             if ','in sequence:
                     seqReco=sequence.split(',')[1]
                     seqDigi=sequence.split(',')[0]
             else:
                     print "RAW2RECO requires two specifications",sequence,"insufficient"
 
         self.prepare_RAW2DIGI(seqDigi)
         self.prepare_RECO(seqReco)
             return
 

def ConfigBuilder.ConfigBuilder.prepare_RECO	(	self,
		sequence = `"reconstruction"`
	)

put the filtering path in the schedule

put it before all the other paths

Enrich the schedule with reconstruction

Definition at line 1655 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.RECODefaultCFF, and ConfigBuilder.ConfigBuilder.scheduleSequence().

Referenced by ConfigBuilder.ConfigBuilder.prepare_RAW2RECO().

     def prepare_RECO(self, sequence = "reconstruction"):
         ''' Enrich the schedule with reconstruction '''
         self.loadDefaultOrSpecifiedCFF(sequence,self.RECODefaultCFF)

def ConfigBuilder.ConfigBuilder.prepare_RECOBEFMIX	(	self,
		sequence = `"reconstruction"`
	)

Enrich the schedule with the part of reconstruction that is done before mixing in FastSim

Definition at line 1667 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_RECOBEFMIX(self, sequence = "reconstruction"):
         ''' Enrich the schedule with the part of reconstruction that is done before mixing in FastSim'''
         if not self._options.fast:
                 print "ERROR: this step is only implemented for FastSim"
                 sys.exit()
         self.loadDefaultOrSpecifiedCFF(self.RECOBEFMIXDefaultSeq,self.RECOBEFMIXDefaultCFF)
         self.scheduleSequence(sequence.split('.')[-1],'reconstruction_befmix_step')
         return
 

def ConfigBuilder.ConfigBuilder.prepare_RECOSIM	(	self,
		sequence = `"recosim"`
	)

Enrich the schedule with reconstruction

Definition at line 1661 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.RECOSIMDefaultCFF, and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_RECOSIM(self, sequence = "recosim"):
         ''' Enrich the schedule with reconstruction '''
         self.loadDefaultOrSpecifiedCFF(sequence,self.RECOSIMDefaultCFF)

def ConfigBuilder.ConfigBuilder.prepare_REPACK	(	self,
		sequence = `None`
	)

Definition at line 1500 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_REPACK(self, sequence = None):
             self.loadDefaultOrSpecifiedCFF(sequence,self.REPACKDefaultCFF)
         self.scheduleSequence(sequence.split('.')[-1],'digi2repack_step')
             return
 

def ConfigBuilder.ConfigBuilder.prepare_SIM	(	self,
		sequence = `None`
	)

Enrich the schedule with the summary of the filter step

Enrich the schedule with the simulation step

Definition at line 1402 of file ConfigBuilder.py.

1402 def prepare_SIM(self, sequence = None):

1403 """ Enrich the schedule with the simulation step"""

ConfigBuilder.ConfigBuilder.prepare_SIM

def prepare_SIM(self, sequence=None)

Definition: ConfigBuilder.py:1402

def ConfigBuilder.ConfigBuilder.prepare_SKIM	(	self,
		sequence = `"all"`
	)

Enrich the schedule with skimming fragments

Definition at line 1738 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.addExtraStream(), ConfigBuilder.ConfigBuilder.expandMapping(), join(), and ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF().

     def prepare_SKIM(self, sequence = "all"):
         ''' Enrich the schedule with skimming fragments'''
         skimConfig = self.loadDefaultOrSpecifiedCFF(sequence,self.SKIMDefaultCFF)
         sequence = sequence.split('.')[-1]
 
         skimlist=sequence.split('+')
         ## support @Mu+DiJet+@Electron configuration via autoSkim.py

def ConfigBuilder.ConfigBuilder.prepare_USER	(	self,
		sequence = `None`
	)

Enrich the schedule with a user defined sequence

Definition at line 1782 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

     def prepare_USER(self, sequence = None):
         ''' Enrich the schedule with a user defined sequence '''
         self.loadDefaultOrSpecifiedCFF(sequence,self.USERDefaultCFF)

def ConfigBuilder.ConfigBuilder.prepare_VALIDATION	(	self,
		sequence = `'validation'`
	)

Definition at line 1795 of file ConfigBuilder.py.

     def prepare_VALIDATION(self, sequence = 'validation'):
         print sequence,"in preparing validation"
             self.loadDefaultOrSpecifiedCFF(sequence,self.VALIDATIONDefaultCFF)
         from Validation.Configuration.autoValidation import autoValidation
             #in case VALIDATION:something:somethingelse -> something,somethingelse
             sequence=sequence.split('.')[-1]
             if sequence.find(',')!=-1:
                     prevalSeqName=sequence.split(',')[0].split('+')
                     valSeqName=sequence.split(',')[1].split('+')
             self.expandMapping(prevalSeqName,autoValidation,index=0)
             self.expandMapping(valSeqName,autoValidation,index=1)
             else:
             if '@' in sequence:
                 prevalSeqName=sequence.split('+')
                 valSeqName=sequence.split('+')
                 self.expandMapping(prevalSeqName,autoValidation,index=0)
                 self.expandMapping(valSeqName,autoValidation,index=1)
             else:
                 postfix=''
                 if sequence:
                     postfix='_'+sequence
                 prevalSeqName=['prevalidation'+postfix]
                 valSeqName=['validation'+postfix]
                 if not hasattr(self.process,valSeqName[0]):
                     prevalSeqName=['']
                     valSeqName=[sequence]
 
         def NFI(index):
             ##name from index, required to keep backward compatibility
             if index==0:
                 return ''
             else:
                 return '%s'%index
 
 
             #rename the HLT process in validation steps
         if ('HLT' in self.stepMap and not self._options.fast) or self._options.hltProcess:
             for s in valSeqName+prevalSeqName:
                 if s:
                     self.renameHLTprocessInSequence(s)
         for (i,s) in enumerate(prevalSeqName):
             if s:
                 setattr(self.process,'prevalidation_step%s'%NFI(i),  cms.Path( getattr(self.process, s)) )
                 self.schedule.append(getattr(self.process,'prevalidation_step%s'%NFI(i)))
                 
         for (i,s) in enumerate(valSeqName):
             setattr(self.process,'validation_step%s'%NFI(i), cms.EndPath( getattr(self.process, s)))
             self.schedule.append(getattr(self.process,'validation_step%s'%NFI(i)))
 
             #needed in case the miniAODValidation sequence is run starting from AODSIM
         if 'PAT' in self.stepMap and not 'RECO' in self.stepMap:
             return
 
             if not 'DIGI' in self.stepMap and not self._options.fast and not any(map( lambda s : s.startswith('genvalid'), valSeqName)):
             if self._options.restoreRNDSeeds==False and not self._options.restoreRNDSeeds==True:
                 self._options.restoreRNDSeeds=True
 
         if not 'DIGI' in self.stepMap and not self._options.fast:
             self.executeAndRemember("process.mix.playback = True")
             self.executeAndRemember("process.mix.digitizers = cms.PSet()")
                     self.executeAndRemember("for a in process.aliases: delattr(process, a)")
                     self._options.customisation_file.append("SimGeneral/MixingModule/fullMixCustomize_cff.setCrossingFrameOn")
 
         if hasattr(self.process,"genstepfilter") and len(self.process.genstepfilter.triggerConditions):
             #will get in the schedule, smoothly
             for (i,s) in enumerate(valSeqName):
                 getattr(self.process,'validation_step%s'%NFI(i))._seq = self.process.genstepfilter * getattr(self.process,'validation_step%s'%NFI(i))._seq
 
             return
 
 

def ConfigBuilder.ConfigBuilder.profileOptions ( self )

addIgProfService
Function to add the igprof profile service so that you can dump in the middle
of the run.

Definition at line 267 of file ConfigBuilder.py.

References createfilelist.int.

Referenced by ConfigBuilder.ConfigBuilder.addCommon().

     def profileOptions(self):
         """
         addIgProfService
         Function to add the igprof profile service so that you can dump in the middle
         of the run.
         """
         profileOpts = self._options.profile.split(':')
         profilerStart = 1
         profilerInterval = 100
         profilerFormat = None
         profilerJobFormat = None
         
         if len(profileOpts):
             #type, given as first argument is unused here
             profileOpts.pop(0) 
         if len(profileOpts):   
             startEvent = profileOpts.pop(0)
             if not startEvent.isdigit():
                 raise Exception("%s is not a number" % startEvent)
             profilerStart = int(startEvent)
         if len(profileOpts):
             eventInterval = profileOpts.pop(0)
             if not eventInterval.isdigit():
                 raise Exception("%s is not a number" % eventInterval)
             profilerInterval = int(eventInterval)
         if len(profileOpts):
             profilerFormat = profileOpts.pop(0)
 
 
         if not profilerFormat:
             profilerFormat = "%s___%s___%s___%s___%s___%s___%%I.gz" % (self._options.evt_type.replace("_cfi", ""),
                                            self._options.step,
                                            self._options.pileup,
                                            self._options.conditions,
                                            self._options.datatier,
                                            self._options.profileTypeLabel)
         if not profilerJobFormat and profilerFormat.endswith(".gz"):
             profilerJobFormat = profilerFormat.replace(".gz", "_EndOfJob.gz")
         elif not profilerJobFormat:
             profilerJobFormat = profilerFormat + "_EndOfJob.gz"
 
         return (profilerStart,profilerInterval,profilerFormat,profilerJobFormat)
 

def ConfigBuilder.ConfigBuilder.renameHLTprocessInSequence	(	self,
		sequence,
		proc = `None`,
		HLTprocess = `'HLT'`
	)

Definition at line 1935 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_ALCA(), ConfigBuilder.ConfigBuilder.prepare_DQM(), and ConfigBuilder.ConfigBuilder.prepare_VALIDATION().

     def renameHLTprocessInSequence(self,sequence,proc=None,HLTprocess='HLT'):
         if self._options.hltProcess:
             proc=self._options.hltProcess
         else:
             proc=self.process.name_()
         if proc==HLTprocess:    return
             # look up all module in dqm sequence
             print "replacing %s process name - sequence %s will use '%s'" % (HLTprocess,sequence, proc)
             getattr(self.process,sequence).visit(ConfigBuilder.MassSearchReplaceProcessNameVisitor(HLTprocess,proc,whitelist = ("subSystemFolder",)))
             if 'from Configuration.Applications.ConfigBuilder import ConfigBuilder' not in self.additionalCommands:
                     self.additionalCommands.append('from Configuration.Applications.ConfigBuilder import ConfigBuilder')
             self.additionalCommands.append('process.%s.visit(ConfigBuilder.MassSearchReplaceProcessNameVisitor("%s", "%s", whitelist = ("subSystemFolder",)))'% (sequence,HLTprocess, proc))
 
 

def ConfigBuilder.ConfigBuilder.renameInputTagsInSequence	(	self,
		sequence,
		oldT = `"rawDataCollector"`,
		newT = `"rawDataRepacker"`
	)

Definition at line 1925 of file ConfigBuilder.py.

     def renameInputTagsInSequence(self,sequence,oldT="rawDataCollector",newT="rawDataRepacker"):
         print "Replacing all InputTag %s => %s"%(oldT,newT)
         from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag
         massSearchReplaceAnyInputTag(getattr(self.process,sequence),oldT,newT)
         loadMe='from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag'
         if not loadMe in self.additionalCommands:
             self.additionalCommands.append(loadMe)
         self.additionalCommands.append('massSearchReplaceAnyInputTag(process.%s,"%s","%s",False,True)'%(sequence,oldT,newT))
 

def ConfigBuilder.ConfigBuilder.scheduleSequence	(	self,
		seq,
		prefix,
		what = `'Path'`
	)

Definition at line 1210 of file ConfigBuilder.py.

     def scheduleSequence(self,seq,prefix,what='Path'):
         if '*' in seq:
             #create only one path with all sequences in it
             for i,s in enumerate(seq.split('*')):
                 if i==0:
                     setattr(self.process,prefix,getattr(cms,what)( getattr(self.process, s) ))
                 else:
                     p=getattr(self.process,prefix)
                     p+=getattr(self.process, s)
             self.schedule.append(getattr(self.process,prefix))
             return
         else:
             #create as many path as many sequences
             if not '+' in seq:
                 if self.nextScheduleIsConditional:
                     self.conditionalPaths.append(prefix)
                 setattr(self.process,prefix,getattr(cms,what)( getattr(self.process, seq) ))
                 self.schedule.append(getattr(self.process,prefix))
             else:
                 for i,s in enumerate(seq.split('+')):
                     sn=prefix+'%d'%(i)
                     setattr(self.process,sn,getattr(cms,what)( getattr(self.process, s) ))
                     self.schedule.append(getattr(self.process,sn))
             return
     

def ConfigBuilder.ConfigBuilder.scheduleSequenceAtEnd	(	self,
		seq,
		prefix
	)

Definition at line 1235 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.scheduleSequence().

Referenced by ConfigBuilder.ConfigBuilder.prepare_ENDJOB().

     def scheduleSequenceAtEnd(self,seq,prefix):
         self.scheduleSequence(seq,prefix,what='EndPath')
         return
         

Member Data Documentation

ConfigBuilder.ConfigBuilder._options

private

Definition at line 197 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.filesFromOption(), and ConfigBuilder.ConfigBuilder.prepare().

ConfigBuilder.ConfigBuilder.ALCADefaultCFF

Definition at line 921 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_ALCA().

ConfigBuilder.ConfigBuilder.DIGI2RAWDefaultCFF

Definition at line 925 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_DIGI2RAW().

ConfigBuilder.ConfigBuilder.DIGIDefaultCFF

Definition at line 924 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_DIGI(), and ConfigBuilder.ConfigBuilder.prepare_DIGIPREMIX().

ConfigBuilder.ConfigBuilder.DQMSaverCFF

Definition at line 2007 of file ConfigBuilder.py.

ConfigBuilder.ConfigBuilder.GENDefaultCFF

Definition at line 922 of file ConfigBuilder.py.

ConfigBuilder.ConfigBuilder.HLTDefaultCFF

Definition at line 928 of file ConfigBuilder.py.

ConfigBuilder.ConfigBuilder.L1EMDefaultCFF

Definition at line 926 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1().

ConfigBuilder.ConfigBuilder.L1MENUDefaultCFF

Definition at line 927 of file ConfigBuilder.py.

ConfigBuilder.ConfigBuilder.L1RecoDefaultCFF

Definition at line 930 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1Reco().

ConfigBuilder.ConfigBuilder.L1TrackTriggerDefaultCFF

Definition at line 931 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1TrackTrigger().

ConfigBuilder.ConfigBuilder.NANODefaultCFF

Definition at line 935 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_NANO().

ConfigBuilder.ConfigBuilder.PATDefaultCFF

Definition at line 934 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_PAT().

ConfigBuilder.ConfigBuilder.RAW2DIGIDefaultCFF

Definition at line 929 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_RAW2DIGI().

ConfigBuilder.ConfigBuilder.RECODefaultCFF

Definition at line 932 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.inGeometryKeys(), and ConfigBuilder.ConfigBuilder.prepare_RECO().

ConfigBuilder.ConfigBuilder.RECOSIMDefaultCFF

Definition at line 933 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_RECOSIM().

ConfigBuilder.ConfigBuilder.SIMDefaultCFF

Definition at line 923 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.inGeometryKeys().

Classes

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation