ConfigBuilder.ConfigBuilder Class Reference

Inheritance diagram for ConfigBuilder.ConfigBuilder:

Classes
class	MassSearchReplaceProcessNameVisitor

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)
def	addExtraStream (self, name, stream, workflow='full', cppType="PoolOutputModule")
def	addMaxEvents (self)
def	addOutput (self)
def	addSource (self)
def	addStandardSequences (self)
def	build_production_info (self, evt_type, evtnumber)
def	completeInputCommand (self)
def	create_process (self)
def	define_Configs (self)
def	executeAndRemember (self, command)
def	expandMapping (self, seqList, mapping, index=None)
def	finalizeFastSimHLT (self)
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_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_NANOGEN (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")
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
	addedObjects
	additionalCommands
	additionalOutputs
	ALCADefaultCFF
	ALCADefaultSeq
	ALCAHARVESTDefaultCFF
	ALCAHARVESTDefaultSeq
	AlCaPaths
	blacklist_paths
	CFWRITERDefaultCFF
	CFWRITERDefaultSeq
	conditionalPaths
	ConditionsDefaultCFF
	DATAMIXDefaultCFF
	DATAMIXDefaultSeq
	DIGI2RAWDefaultCFF
	DIGI2RAWDefaultSeq
	DIGIDefaultCFF
	DIGIDefaultSeq
	DQMDefaultSeq
	DQMOFFLINEDefaultCFF
	DQMSaverCFF
	EIDefaultCFF
	EIDefaultSeq
	ENDJOBDefaultCFF
	ENDJOBDefaultSeq
	EVTCONTDefaultCFF
	excludedPaths
	GENDefaultCFF
	GENDefaultSeq
	GeometryCFF
	geometryDBLabel
	HARVESTINGDefaultCFF
	HARVESTINGDefaultSeq
	HLTDefaultCFF
	HLTDefaultSeq
	imports
	inliner
	load the relevant part More...
	L1DefaultSeq
	L1EMDefaultCFF
	L1HwValDefaultCFF
	L1HwValDefaultSeq
	L1MENUDefaultCFF
	L1RecoDefaultCFF
	L1RecoDefaultSeq
	L1REPACKDefaultSeq
	L1TrackTriggerDefaultCFF
	L1TrackTriggerDefaultSeq
	labelsToAssociate
	LHEDefaultSeq
	magFieldCFF
	NANODefaultCFF
	NANODefaultSeq
	NANOGENDefaultCFF
	NANOGENDefaultSeq
	nextScheduleIsConditional
	put the filtering path in the schedule More...
	PATDefaultCFF
	PATDefaultSeq
	PATGENDefaultCFF
	PATGENDefaultSeq
	POSTRECODefaultCFF
	POSTRECODefaultSeq
	process
	adding standard sequences might change the inputEventContent option and therefore needs to be finalized after More...
	productionFilterSequence
	put it before all the other paths More...
	pythonCfgCode
	RAW2DIGIDefaultCFF
	RAW2DIGIDefaultSeq
	RAW2RECODefaultSeq
	RECOBEFMIXDefaultCFF
	RECOBEFMIXDefaultSeq
	RECODefaultCFF
	RECODefaultSeq
	RECOSIMDefaultCFF
	RECOSIMDefaultSeq
	REDIGIDefaultSeq
	REPACKDefaultCFF
	REPACKDefaultSeq
	runsAndWeights
	drop LHEXMLStringProduct on input to save memory if appropriate More...
	runsAndWeightsInt
	schedule
	SIMDefaultCFF
	SIMDefaultSeq
	SimGeometryCFF
	SKIMDefaultCFF
	stepKeys
	stepMap
	USERDefaultCFF
	USERDefaultSeq
	VALIDATIONDefaultCFF
	VALIDATIONDefaultSeq
	with_input
	with_output

Private Attributes
	_options

Detailed Description

The main building routines 

Definition at line 195 of file ConfigBuilder.py.

Constructor & Destructor Documentation

__init__()

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

options taken from old cmsDriver and optparse 

Definition at line 198 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")
 
        # check that MEtoEDMConverter (running in ENDJOB) and DQMIO don't run in the same job
        if 'ENDJOB' in self._options.step:
            if  (hasattr(self._options,"outputDefinition") and \
                self._options.outputDefinition != '' and \
                any(anyOf(['t','tier','dataTier'],outdic) == 'DQMIO' for outdic in eval(self._options.outputDefinition))) or \
                (hasattr(self._options,"datatier") and \
                self._options.datatier and \
                'DQMIO' in self._options.datatier):
                print("removing ENDJOB from steps since not compatible with DQMIO dataTier")
                self._options.step=self._options.step.replace(',ENDJOB','')
 
 
 
        # what steps are provided by this class?
        stepList = [re.sub(r'^prepare_', '', methodName) for methodName in ConfigBuilder.__dict__ if methodName.startswith('prepare_')]
        self.stepMap={}
        self.stepKeys=[]
        for step in self._options.step.split(","):
            if step=='': continue
            stepParts = step.split(":")
            stepName = stepParts[0]
            if stepName not in stepList and not stepName.startswith('re'):
                raise ValueError("Step "+stepName+" unknown")
            if len(stepParts)==1:
                self.stepMap[stepName]=""
            elif len(stepParts)==2:
                self.stepMap[stepName]=stepParts[1].split('+')
            elif len(stepParts)==3:
                self.stepMap[stepName]=(stepParts[2].split('+'),stepParts[1])
            else:
                raise ValueError("Step definition "+step+" invalid")
            self.stepKeys.append(stepName)
 
        #print "map of steps is:",self.stepMap
 
        self.with_output = with_output
        self.process=process
 
        if hasattr(self._options,"no_output_flag") and self._options.no_output_flag:
            self.with_output = False
        self.with_input = with_input
        self.imports = []
        self.create_process()
        self.define_Configs()
        self.schedule = list()
 
        # we are doing three things here:
        # creating a process to catch errors
        # building the code to re-create the process
 
        self.additionalCommands = []
        # TODO: maybe a list of to be dumped objects would help as well
        self.blacklist_paths = []
        self.addedObjects = []
        self.additionalOutputs = {}
 
        self.productionFilterSequence = None
        self.labelsToAssociate=[]
        self.nextScheduleIsConditional=False
        self.conditionalPaths=[]
        self.excludedPaths=[]
 

Referenced by ConfigBuilder.ConfigBuilder.prepare_FILTER().

Member Function Documentation

addCommon()

def ConfigBuilder.ConfigBuilder.addCommon

(

self

)

Definition at line 339 of file ConfigBuilder.py.

    def addCommon(self):
        if 'HARVESTING' in self.stepMap.keys() or 'ALCAHARVEST' in self.stepMap.keys():
            self.process.options.Rethrow = ['ProductNotFound']
            self.process.options.fileMode = 'FULLMERGE'
 
        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"))
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.addedObjects, mps_setup.append, relativeConstraints.keys, DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, ConfigBuilder.ConfigBuilder.profileOptions(), and ConfigBuilder.ConfigBuilder.stepMap.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

addConditions()

def ConfigBuilder.ConfigBuilder.addConditions

(

self

)

Add conditions to the process

Definition at line 835 of file ConfigBuilder.py.

    def addConditions(self):
        """Add conditions to the process"""
        if not self._options.conditions: return
 
        if 'FrontierConditions_GlobalTag' in self._options.conditions:
            print('using FrontierConditions_GlobalTag in --conditions is not necessary anymore and will be deprecated soon. please update your command line')
            self._options.conditions = self._options.conditions.replace("FrontierConditions_GlobalTag,",'')
 
        self.loadAndRemember(self.ConditionsDefaultCFF)
        from Configuration.AlCa.GlobalTag import GlobalTag
        self.process.GlobalTag = GlobalTag(self.process.GlobalTag, self._options.conditions, self._options.custom_conditions)
        self.additionalCommands.append('from Configuration.AlCa.GlobalTag import GlobalTag')
        self.additionalCommands.append('process.GlobalTag = GlobalTag(process.GlobalTag, %s, %s)' % (repr(self._options.conditions), repr(self._options.custom_conditions)))
 
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.addCustomise(), ConfigBuilder.ConfigBuilder.additionalCommands, mps_setup.append, ConfigBuilder.ConfigBuilder.ConditionsDefaultCFF, ConfigBuilder.ConfigBuilder.loadAndRemember(), print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, and ConfigBuilder.ConfigBuilder.process.

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

addCustomise()

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

Include the customise code 

Definition at line 850 of file ConfigBuilder.py.

    def addCustomise(self,unsch=0):
        """Include the customise code """
 
        custOpt=[]
        if unsch==0:
            for c in self._options.customisation_file:
                custOpt.extend(c.split(","))
        else:
            for c in self._options.customisation_file_unsch:
                custOpt.extend(c.split(","))
 
        custMap=DictTypes.SortedKeysDict()
        for opt in custOpt:
            if opt=='': continue
            if opt.count('.')>1:
                raise Exception("more than . in the specification:"+opt)
            fileName=opt.split('.')[0]
            if opt.count('.')==0:   rest='customise'
            else:
                rest=opt.split('.')[1]
                if rest=='py': rest='customise' #catch the case of --customise file.py
 
            if fileName in custMap:
                custMap[fileName].extend(rest.split('+'))
            else:
                custMap[fileName]=rest.split('+')
 
        if len(custMap)==0:
            final_snippet='\n'
        else:
            final_snippet='\n# customisation of the process.\n'
 
        allFcn=[]
        for opt in custMap:
            allFcn.extend(custMap[opt])
        for fcn in allFcn:
            if allFcn.count(fcn)!=1:
                raise Exception("cannot specify twice "+fcn+" as a customisation method")
 
        for f in custMap:
            # let python search for that package and do syntax checking at the same time
            packageName = f.replace(".py","").replace("/",".")
            __import__(packageName)
            package = sys.modules[packageName]
 
            # now ask the package for its definition and pick .py instead of .pyc
            customiseFile = re.sub(r'\.pyc$', '.py', package.__file__)
 
            final_snippet+='\n# Automatic addition of the customisation function from '+packageName+'\n'
            if self._options.inline_custom:
                for line in file(customiseFile,'r'):
                    if "import FWCore.ParameterSet.Config" in line:
                        continue
                    final_snippet += line
            else:
                final_snippet += 'from %s import %s \n'%(packageName,','.join(custMap[f]))
            for fcn in custMap[f]:
                print("customising the process with",fcn,"from",f)
                if not hasattr(package,fcn):
                    #bound to fail at run time
                    raise Exception("config "+f+" has no function "+fcn)
                #execute the command
                self.process=getattr(package,fcn)(self.process)
                #and print it in the configuration
                final_snippet += "\n#call to customisation function "+fcn+" imported from "+packageName
                final_snippet += "\nprocess = %s(process)\n"%(fcn,)
 
        if len(custMap)!=0:
            final_snippet += '\n# End of customisation functions\n'
 
        
        return final_snippet
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.addCustomiseCmdLine(), geometryDiff.file, join(), print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, and python.rootplot.root2matplotlib.replace().

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

addCustomiseCmdLine()

def ConfigBuilder.ConfigBuilder.addCustomiseCmdLine

(

self

)

Definition at line 923 of file ConfigBuilder.py.

    def addCustomiseCmdLine(self):
        final_snippet='\n# Customisation from command line\n'
        if self._options.customise_commands:
            import string
            for com in self._options.customise_commands.split('\\n'):
                com=com.lstrip()
                self.executeAndRemember(com)
                final_snippet +='\n'+com
 
        return final_snippet
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.define_Configs(), and ConfigBuilder.ConfigBuilder.executeAndRemember().

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

addExtraStream()

def ConfigBuilder.ConfigBuilder.addExtraStream	(		self,
			name,
			stream,
			workflow = 'full',
			cppType = "PoolOutputModule"
	)

Definition at line 1154 of file ConfigBuilder.py.

    def addExtraStream(self, name, stream, workflow='full', cppType="PoolOutputModule"):
            # define output module and go from there
        output = cms.OutputModule(cppType)
        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)
 
        if cppType == "PoolOutputModule":
            #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
 

Referenced by ConfigBuilder.ConfigBuilder.prepare_SKIM().

addMaxEvents()

def ConfigBuilder.ConfigBuilder.addMaxEvents

(

self

)

Here we decide how many evts will be processed

Definition at line 367 of file ConfigBuilder.py.

    def addMaxEvents(self):
        """Here we decide how many evts will be processed"""
        self.process.maxEvents.input = int(self._options.number)
        if self._options.number_out:
            self.process.maxEvents.output = int(self._options.number_out)
        self.addedObjects.append(("","maxEvents"))
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.addedObjects, mps_setup.append, createfilelist.int, DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, and ConfigBuilder.ConfigBuilder.process.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

addOutput()

def ConfigBuilder.ConfigBuilder.addOutput

(

self

)

Add output module to the process 

Definition at line 526 of file ConfigBuilder.py.

    def addOutput(self):
        """ Add output module to the process """
        result=""
        if self._options.outputDefinition:
            if self._options.datatier:
                print("--datatier & --eventcontent options ignored")
 
            #new output convention with a list of dict
            outList = eval(self._options.outputDefinition)
            for (id,outDefDict) in enumerate(outList):
                outDefDictStr=outDefDict.__str__()
                if not isinstance(outDefDict,dict):
                    raise Exception("--output needs to be passed a list of dict"+self._options.outputDefinition+" is invalid")
                #requires option: tier
                theTier=anyOf(['t','tier','dataTier'],outDefDict)
                #optional option: eventcontent, filtername, selectEvents, moduleLabel, filename
                
                theStreamType=anyOf(['e','ec','eventContent','streamType'],outDefDict,theTier)
                theFilterName=anyOf(['f','ftN','filterName'],outDefDict,'')
                theSelectEvent=anyOf(['s','sE','selectEvents'],outDefDict,'')
                theModuleLabel=anyOf(['l','mL','moduleLabel'],outDefDict,'')
                theExtraOutputCommands=anyOf(['o','oC','outputCommands'],outDefDict,'')
                # module label has a particular role
                if not theModuleLabel:
                    tryNames=[theStreamType.replace(theTier.replace('-',''),'')+theTier.replace('-','')+'output',
                              theStreamType.replace(theTier.replace('-',''),'')+theTier.replace('-','')+theFilterName+'output',
                              theStreamType.replace(theTier.replace('-',''),'')+theTier.replace('-','')+theFilterName+theSelectEvent.split(',')[0].replace(':','for').replace(' ','')+'output'
                              ]
                    for name in tryNames:
                        if not hasattr(self.process,name):
                            theModuleLabel=name
                            break
                if not theModuleLabel:
                    raise Exception("cannot find a module label for specification: "+outDefDictStr)
                if id==0:
                    defaultFileName=self._options.outfile_name
                else:
                    defaultFileName=self._options.outfile_name.replace('.root','_in'+theTier+'.root')
 
                theFileName=self._options.dirout+anyOf(['fn','fileName'],outDefDict,defaultFileName)
                if not theFileName.endswith('.root'):
                    theFileName+='.root'
 
                if len(outDefDict):
                    raise Exception("unused keys from --output options: "+','.join(outDefDict.keys()))
                if theStreamType=='DQMIO': theStreamType='DQM'
                if theStreamType=='ALL':
                    theEventContent = cms.PSet(outputCommands = cms.untracked.vstring('keep *'))
                else:
                    theEventContent = getattr(self.process, theStreamType+"EventContent")
 
 
                addAlCaSelects=False
                if theStreamType=='ALCARECO' and not theFilterName:
                    theFilterName='StreamALCACombined'
                    addAlCaSelects=True
 
                CppType='PoolOutputModule'
                if self._options.timeoutOutput:
                    CppType='TimeoutPoolOutputModule'
                if theStreamType=='DQM' and theTier=='DQMIO': CppType='DQMRootOutputModule'
                output = cms.OutputModule(CppType,
                                          theEventContent.clone(),
                                          fileName = cms.untracked.string(theFileName),
                                          dataset = cms.untracked.PSet(
                                             dataTier = cms.untracked.string(theTier),
                                             filterName = cms.untracked.string(theFilterName))
                                          )
                if not theSelectEvent and hasattr(self.process,'generation_step') and theStreamType!='LHE':
                    output.SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring('generation_step'))
                if not theSelectEvent and hasattr(self.process,'filtering_step'):
                    output.SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring('filtering_step'))
                if theSelectEvent:
                    output.SelectEvents =cms.untracked.PSet(SelectEvents = cms.vstring(theSelectEvent))
 
                if addAlCaSelects:
                    if not hasattr(output,'SelectEvents'):
                        output.SelectEvents=cms.untracked.PSet(SelectEvents=cms.vstring())
                    for alca in self.AlCaPaths:
                        output.SelectEvents.SelectEvents.extend(getattr(self.process,'OutALCARECO'+alca).SelectEvents.SelectEvents)
 
 
                if hasattr(self.process,theModuleLabel):
                    raise Exception("the current process already has a module "+theModuleLabel+" defined")
                #print "creating output module ",theModuleLabel
                setattr(self.process,theModuleLabel,output)
                outputModule=getattr(self.process,theModuleLabel)
                setattr(self.process,theModuleLabel+'_step',cms.EndPath(outputModule))
                path=getattr(self.process,theModuleLabel+'_step')
                self.schedule.append(path)
 
                if not self._options.inlineEventContent and hasattr(self.process,theStreamType+"EventContent"):
                    def doNotInlineEventContent(instance,label = "cms.untracked.vstring(process."+theStreamType+"EventContent.outputCommands)"):                        return label
                    outputModule.outputCommands.__dict__["dumpPython"] = doNotInlineEventContent
                if theExtraOutputCommands:
                    if not isinstance(theExtraOutputCommands,list):
                        raise Exception("extra ouput command in --option must be a list of strings")
                    if hasattr(self.process,theStreamType+"EventContent"):
                        self.executeAndRemember('process.%s.outputCommands.extend(%s)'%(theModuleLabel,theExtraOutputCommands))
                    else:
                        outputModule.outputCommands.extend(theExtraOutputCommands)
 
                result+="\nprocess."+theModuleLabel+" = "+outputModule.dumpPython()
 
            
            return result
 
        streamTypes=self._options.eventcontent.split(',')
        tiers=self._options.datatier.split(',')
        if not self._options.outputDefinition and len(streamTypes)!=len(tiers):
            raise Exception("number of event content arguments does not match number of datatier arguments")
 
        # if the only step is alca we don't need to put in an output
        if self._options.step.split(',')[0].split(':')[0] == 'ALCA':
            return "\n"
 
        for i,(streamType,tier) in enumerate(zip(streamTypes,tiers)):
            if streamType=='': continue
            if streamType == 'ALCARECO' and not 'ALCAPRODUCER' in self._options.step: continue
            if streamType=='DQMIO': streamType='DQM'
            eventContent=streamType
            
            if streamType == "NANOEDMAOD" :
                eventContent = "NANOAOD"
            elif streamType == "NANOEDMAODSIM" :
                eventContent = "NANOAODSIM"
            theEventContent = getattr(self.process, eventContent+"EventContent")
            if i==0:
                theFileName=self._options.outfile_name
                theFilterName=self._options.filtername
            else:
                theFileName=self._options.outfile_name.replace('.root','_in'+streamType+'.root')
                theFilterName=self._options.filtername
            CppType='PoolOutputModule'
            if self._options.timeoutOutput:
                CppType='TimeoutPoolOutputModule'
            if streamType=='DQM' and tier=='DQMIO': CppType='DQMRootOutputModule'
            if "NANOAOD" in streamType : CppType='NanoAODOutputModule'
            output = cms.OutputModule(CppType,
                                      theEventContent,
                                      fileName = cms.untracked.string(theFileName),
                                      dataset = cms.untracked.PSet(dataTier = cms.untracked.string(tier),
                                                                   filterName = cms.untracked.string(theFilterName)
                                                                   )
                                      )
            if hasattr(self.process,"generation_step") and streamType!='LHE':
                output.SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring('generation_step'))
            if hasattr(self.process,"filtering_step"):
                output.SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring('filtering_step'))
 
            if streamType=='ALCARECO':
                output.dataset.filterName = cms.untracked.string('StreamALCACombined')
 
            if "MINIAOD" in streamType:
                from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeOutput
                miniAOD_customizeOutput(output)
 
            outputModuleName=streamType+'output'
            setattr(self.process,outputModuleName,output)
            outputModule=getattr(self.process,outputModuleName)
            setattr(self.process,outputModuleName+'_step',cms.EndPath(outputModule))
            path=getattr(self.process,outputModuleName+'_step')
            self.schedule.append(path)
 
            if self._options.outputCommands and streamType!='DQM':
                for evct in self._options.outputCommands.split(','):
                    if not evct: continue
                    self.executeAndRemember("process.%s.outputCommands.append('%s')"%(outputModuleName,evct.strip()))
 
            if not self._options.inlineEventContent:
                tmpstreamType=streamType
                if "NANOEDM" in tmpstreamType :
                    tmpstreamType=tmpstreamType.replace("NANOEDM","NANO")
                def doNotInlineEventContent(instance,label = "process."+tmpstreamType+"EventContent.outputCommands"):
                    return label
                outputModule.outputCommands.__dict__["dumpPython"] = doNotInlineEventContent
 
            result+="\nprocess."+outputModuleName+" = "+outputModule.dumpPython()
 
        return result
 
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.addStandardSequences(), ConfigBuilder.ConfigBuilder.AlCaPaths, ConfigBuilder.anyOf(), mps_setup.append, ConfigBuilder.ConfigBuilder.executeAndRemember(), join(), miniAOD_tools.miniAOD_customizeOutput(), print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, python.rootplot.root2matplotlib.replace(), ConfigBuilder.ConfigBuilder.schedule, submitPVValidationJobs.split(), and ComparisonHelper.zip().

Referenced by ConfigBuilder.ConfigBuilder.prepare().

addSource()

def ConfigBuilder.ConfigBuilder.addSource

(

self

)

Here the source is built. Priority: file, generator

Definition at line 374 of file ConfigBuilder.py.

    def addSource(self):
        """Here the source is built. Priority: file, generator"""
        self.addedObjects.append(("Input source","source"))
 
        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")
 
        if self._options.dasquery!='':
            self.process.source=cms.Source("PoolSource", fileNames = cms.untracked.vstring(),secondaryFileNames = cms.untracked.vstring())
            filesFromDASQuery(self._options.dasquery,self._options.dasoption,self.process.source)
 
            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")
 
        
        if 'GEN' in self.stepMap.keys() and not self._options.filetype == "LHE":
            if self._options.inputCommands:
                self._options.inputCommands+=',drop LHEXMLStringProduct_*_*_*,'
            else:
                self._options.inputCommands='keep *, drop LHEXMLStringProduct_*_*_*,'
 
        if self.process.source and self._options.inputCommands and not self._options.filetype == "LHE":
            if not hasattr(self.process.source,'inputCommands'): self.process.source.inputCommands=cms.untracked.vstring()
            for command in self._options.inputCommands.split(','):
                # remove whitespace around the keep/drop statements
                command = command.strip()
                if command=='': continue
                self.process.source.inputCommands.append(command)
            if not self._options.dropDescendant:
                self.process.source.dropDescendantsOfDroppedBranches = cms.untracked.bool(False)
 
        if self._options.lumiToProcess:
            import FWCore.PythonUtilities.LumiList as LumiList
            self.process.source.lumisToProcess = cms.untracked.VLuminosityBlockRange( LumiList.LumiList(self._options.lumiToProcess).getCMSSWString().split(',') )
 
        if 'GEN' in self.stepMap.keys() or 'LHE' in self.stepMap or (not self._options.filein and hasattr(self._options, "evt_type")):
            if self.process.source is None:
                self.process.source=cms.Source("EmptySource")
 
        # modify source in case of run-dependent MC
        self.runsAndWeights=None
        if self._options.runsAndWeightsForMC or self._options.runsScenarioForMC :
            if not self._options.isMC :
                raise Exception("options --runsAndWeightsForMC and --runsScenarioForMC are only valid for MC")
            if self._options.runsAndWeightsForMC:
                self.runsAndWeights = eval(self._options.runsAndWeightsForMC)
            else:
                from Configuration.StandardSequences.RunsAndWeights import RunsAndWeights
                if isinstance(RunsAndWeights[self._options.runsScenarioForMC], str):
                    __import__(RunsAndWeights[self._options.runsScenarioForMC])
                    self.runsAndWeights = sys.modules[RunsAndWeights[self._options.runsScenarioForMC]].runProbabilityDistribution
                else:
                    self.runsAndWeights = RunsAndWeights[self._options.runsScenarioForMC]
 
        if self.runsAndWeights:
            import SimGeneral.Configuration.ThrowAndSetRandomRun as ThrowAndSetRandomRun
            ThrowAndSetRandomRun.throwAndSetRandomRun(self.process.source,self.runsAndWeights)
            self.additionalCommands.append('import SimGeneral.Configuration.ThrowAndSetRandomRun as ThrowAndSetRandomRun')
            self.additionalCommands.append('ThrowAndSetRandomRun.throwAndSetRandomRun(process.source,%s)'%(self.runsAndWeights))
 
        # modify source in case of run-dependent MC (Run-3 method)
        self.runsAndWeightsInt=None
        if self._options.runsAndWeightsForMCIntegerWeights or self._options.runsScenarioForMCIntegerWeights:
            if not self._options.isMC :
                raise Exception("options --runsAndWeightsForMCIntegerWeights and --runsScenarioForMCIntegerWeights are only valid for MC")
            if self._options.runsAndWeightsForMCIntegerWeights:
                self.runsAndWeightsInt = eval(self._options.runsAndWeightsForMCIntegerWeights)
            else:
                from Configuration.StandardSequences.RunsAndWeights import RunsAndWeights
                if isinstance(RunsAndWeights[self._options.runsScenarioForMCIntegerWeights], str):
                    __import__(RunsAndWeights[self._options.runsScenarioForMCIntegerWeights])
                    self.runsAndWeightsInt = sys.modules[RunsAndWeights[self._options.runsScenarioForMCIntegerWeights]].runProbabilityDistribution
                else:
                    self.runsAndWeightsInt = RunsAndWeights[self._options.runsScenarioForMCIntegerWeights]
 
        if self.runsAndWeightsInt:
            if not self._options.relval:
                raise Exception("--relval option required when using --runsAndWeightsInt")
            if 'DATAMIX' in self._options.step:
                from SimGeneral.Configuration.LumiToRun import lumi_to_run
                total_events, events_per_job  = self._options.relval.split(',')
                lumi_to_run_mapping = lumi_to_run(self.runsAndWeightsInt, int(total_events), int(events_per_job))
                self.additionalCommands.append("process.source.firstLuminosityBlockForEachRun = cms.untracked.VLuminosityBlockID(*[cms.LuminosityBlockID(x,y) for x,y in " + str(lumi_to_run_mapping) + "])")
 
        return
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.addedObjects, mps_setup.append, ConfigBuilder.filesFromDASQuery(), ConfigBuilder.filesFromList(), createfilelist.int, relativeConstraints.keys, print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, submitPVValidationJobs.split(), and ConfigBuilder.ConfigBuilder.stepMap.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

addStandardSequences()

def ConfigBuilder.ConfigBuilder.addStandardSequences

(

self

)

Add selected standard sequences to the process

Definition at line 708 of file ConfigBuilder.py.

    def addStandardSequences(self):
        """
        Add selected standard sequences to the process
        """
        # load the pile up file
        if self._options.pileup:
            pileupSpec=self._options.pileup.split(',')[0]
 
            # Does the requested pile-up scenario exist?
            from Configuration.StandardSequences.Mixing import Mixing,defineMixing
            if not pileupSpec in Mixing and '.' not in pileupSpec and 'file:' not in pileupSpec:
                message = pileupSpec+' is not a know mixing scenario:\n available are: '+'\n'.join(Mixing.keys())
                raise Exception(message)
 
            # Put mixing parameters in a dictionary
            if '.' in pileupSpec:
                mixingDict={'file':pileupSpec}
            elif pileupSpec.startswith('file:'):
                mixingDict={'file':pileupSpec[5:]}
            else:
                import copy
                mixingDict=copy.copy(Mixing[pileupSpec])
            if len(self._options.pileup.split(','))>1:
                mixingDict.update(eval(self._options.pileup[self._options.pileup.find(',')+1:]))
 
            # Load the pu cfg file corresponding to the requested pu scenario
            if 'file:' in pileupSpec:
                #the file is local
                self.process.load(mixingDict['file'])
                print("inlining mixing module configuration")
                self._options.inlineObjets+=',mix'
            else:
                self.loadAndRemember(mixingDict['file'])
 
            mixingDict.pop('file')
            if not "DATAMIX" in self.stepMap.keys(): # when DATAMIX is present, pileup_input refers to pre-mixed GEN-RAW
                if self._options.pileup_input:
                    if self._options.pileup_input.startswith('dbs:') or self._options.pileup_input.startswith('das:'):
                        mixingDict['F']=filesFromDASQuery('file dataset = %s'%(self._options.pileup_input[4:],),self._options.pileup_dasoption)[0]
                    elif self._options.pileup_input.startswith("filelist:"):
                        mixingDict['F']=(filesFromList(self._options.pileup_input[9:]))[0]
                    else:
                        mixingDict['F']=self._options.pileup_input.split(',')
                specialization=defineMixing(mixingDict)
                for command in specialization:
                    self.executeAndRemember(command)
                if len(mixingDict)!=0:
                    raise Exception('unused mixing specification: '+mixingDict.keys().__str__())
 
 
        # load the geometry file
        try:
            if len(self.stepMap):
                self.loadAndRemember(self.GeometryCFF)
                if ('SIM' in self.stepMap or 'reSIM' in self.stepMap) and not self._options.fast:
                    self.loadAndRemember(self.SimGeometryCFF)
                    if self.geometryDBLabel:
                        self.executeAndRemember('if hasattr(process, "XMLFromDBSource"): process.XMLFromDBSource.label="%s"'%(self.geometryDBLabel))
                        self.executeAndRemember('if hasattr(process, "DDDetectorESProducerFromDB"): process.DDDetectorESProducerFromDB.label="%s"'%(self.geometryDBLabel))
 
        except ImportError:
            print("Geometry option",self._options.geometry,"unknown.")
            raise
 
        if len(self.stepMap):
            self.loadAndRemember(self.magFieldCFF)
 
        for stepName in self.stepKeys:
            stepSpec = self.stepMap[stepName]
            print("Step:", stepName,"Spec:",stepSpec)
            if stepName.startswith('re'):
                
                if stepName[2:] not in self._options.donotDropOnInput:
                    self._options.inputEventContent='%s,%s'%(stepName.upper(),self._options.inputEventContent)
                stepName=stepName[2:]
            if stepSpec=="":
                getattr(self,"prepare_"+stepName)(sequence = getattr(self,stepName+"DefaultSeq"))
            elif isinstance(stepSpec, list):
                getattr(self,"prepare_"+stepName)(sequence = '+'.join(stepSpec))
            elif isinstance(stepSpec, tuple):
                getattr(self,"prepare_"+stepName)(sequence = ','.join([stepSpec[1],'+'.join(stepSpec[0])]))
            else:
                raise ValueError("Invalid step definition")
 
        if self._options.restoreRNDSeeds!=False:
            #it is either True, or a process name
            if self._options.restoreRNDSeeds==True:
                self.executeAndRemember('process.RandomNumberGeneratorService.restoreStateLabel=cms.untracked.string("randomEngineStateProducer")')
            else:
                self.executeAndRemember('process.RandomNumberGeneratorService.restoreStateTag=cms.untracked.InputTag("randomEngineStateProducer","","%s")'%(self._options.restoreRNDSeeds))
            if self._options.inputEventContent or self._options.inputCommands:
                if self._options.inputCommands:
                    self._options.inputCommands+='keep *_randomEngineStateProducer_*_*,'
                else:
                    self._options.inputCommands='keep *_randomEngineStateProducer_*_*,'
 
 

References TriggerAnalyzer.__str__(), ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.completeInputCommand(), Mixing.defineMixing(), ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.filesFromDASQuery(), ConfigBuilder.filesFromList(), ConfigBuilder.ConfigBuilder.GeometryCFF, ConfigBuilder.ConfigBuilder.geometryDBLabel, join(), relativeConstraints.keys, ConfigBuilder.ConfigBuilder.load(), ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.magFieldCFF, print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, ConfigBuilder.ConfigBuilder.SimGeometryCFF, ConfigBuilder.ConfigBuilder.stepKeys, and ConfigBuilder.ConfigBuilder.stepMap.

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

build_production_info()

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

Add useful info for the production. 

Definition at line 2096 of file ConfigBuilder.py.

    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"))
 
 

References ConfigBuilder.ConfigBuilder.addedObjects, mps_setup.append, ConfigBuilder.ConfigBuilder.create_process(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, and str.

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

completeInputCommand()

def ConfigBuilder.ConfigBuilder.completeInputCommand

(

self

)

Definition at line 805 of file ConfigBuilder.py.

    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
 
            
            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
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.addConditions(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, and ConfigBuilder.ConfigBuilder.process.

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

create_process()

def ConfigBuilder.ConfigBuilder.create_process

(

self

)

Definition at line 2107 of file ConfigBuilder.py.

    def create_process(self):
        self.pythonCfgCode =  "# Auto generated configuration file\n"
        self.pythonCfgCode += "# using: \n# "+__version__[1:-1]+"\n# "+__source__[1:-1]+'\n'
        self.pythonCfgCode += "# with command line options: "+self._options.arguments+'\n'
        self.pythonCfgCode += "import FWCore.ParameterSet.Config as cms\n\n"
 
        # now set up the modifies
        modifiers=[]
        modifierStrings=[]
        modifierImports=[]
 
        if hasattr(self._options,"era") and self._options.era :
        # Multiple eras can be specified in a comma seperated list
            from Configuration.StandardSequences.Eras import eras
            for requestedEra in self._options.era.split(",") :
                modifierStrings.append(requestedEra)
                modifierImports.append(eras.pythonCfgLines[requestedEra])
                modifiers.append(getattr(eras,requestedEra))
 
 
        if hasattr(self._options,"procModifiers") and self._options.procModifiers:
            import importlib
            thingsImported=[]
            for pm in self._options.procModifiers.split(','):
                modifierStrings.append(pm)
                modifierImports.append('from Configuration.ProcessModifiers.'+pm+'_cff import '+pm)
                modifiers.append(getattr(importlib.import_module('Configuration.ProcessModifiers.'+pm+'_cff'),pm))
 
        self.pythonCfgCode += '\n'.join(modifierImports)+'\n\n'
        self.pythonCfgCode += "process = cms.Process('"+self._options.name+"'" # Start of the line, finished after the loop
 
 
        if len(modifierStrings)>0:
            self.pythonCfgCode+= ','+','.join(modifierStrings)
        self.pythonCfgCode+=')\n\n'
 
        #yes, the cfg code gets out of sync here if a process is passed in. That could be fixed in the future
        #assuming there is some way for the fwk to get the list of modifiers (and their stringified name)
        if self.process == None:
            if len(modifiers)>0:
                self.process = cms.Process(self._options.name,*modifiers)
            else:
                self.process = cms.Process(self._options.name)
 
 
 
 

References ConfigBuilder.ConfigBuilder.pythonCfgCode.

Referenced by ConfigBuilder.ConfigBuilder.build_production_info().

define_Configs()

def ConfigBuilder.ConfigBuilder.define_Configs

(

self

)

Definition at line 938 of file ConfigBuilder.py.

    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"
        if self._options.isRepacked: self.RAW2DIGIDefaultCFF="Configuration/StandardSequences/RawToDigi_DataMapper_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"
        self.NANOGENDefaultCFF="PhysicsTools/NanoAOD/nanogen_cff"
        self.EIDefaultCFF=None
        self.SKIMDefaultCFF="Configuration/StandardSequences/Skims_cff"
        self.POSTRECODefaultCFF="Configuration/StandardSequences/PostRecoGenerator_cff"
        self.VALIDATIONDefaultCFF="Configuration/StandardSequences/Validation_cff"
        self.L1HwValDefaultCFF = "Configuration/StandardSequences/L1HwVal_cff"
        self.DQMOFFLINEDefaultCFF="DQMOffline/Configuration/DQMOffline_cff"
        self.HARVESTINGDefaultCFF="Configuration/StandardSequences/Harvesting_cff"
        self.ALCAHARVESTDefaultCFF="Configuration/StandardSequences/AlCaHarvesting_cff"
        self.ENDJOBDefaultCFF="Configuration/StandardSequences/EndOfProcess_cff"
        self.ConditionsDefaultCFF = "Configuration/StandardSequences/FrontierConditions_GlobalTag_cff"
        self.CFWRITERDefaultCFF = "Configuration/StandardSequences/CrossingFrameWriter_cff"
        self.REPACKDefaultCFF="Configuration/StandardSequences/DigiToRaw_Repack_cff"
 
        if "DATAMIX" in self.stepMap.keys():
            self.DATAMIXDefaultCFF="Configuration/StandardSequences/DataMixer"+self._options.datamix+"_cff"
            self.DIGIDefaultCFF="Configuration/StandardSequences/DigiDM_cff"
            self.DIGI2RAWDefaultCFF="Configuration/StandardSequences/DigiToRawDM_cff"
            self.L1EMDefaultCFF='Configuration/StandardSequences/SimL1EmulatorDM_cff'
 
        self.ALCADefaultSeq=None
        self.LHEDefaultSeq='externalLHEProducer'
        self.GENDefaultSeq='pgen'
        self.SIMDefaultSeq='psim'
        self.DIGIDefaultSeq='pdigi'
        self.DATAMIXDefaultSeq=None
        self.DIGI2RAWDefaultSeq='DigiToRaw'
        self.HLTDefaultSeq='GRun'
        self.L1DefaultSeq=None
        self.L1REPACKDefaultSeq='GT'
        self.HARVESTINGDefaultSeq=None
        self.ALCAHARVESTDefaultSeq=None
        self.CFWRITERDefaultSeq=None
        self.RAW2DIGIDefaultSeq='RawToDigi'
        self.L1RecoDefaultSeq='L1Reco'
        self.L1TrackTriggerDefaultSeq='L1TrackTrigger'
        if self._options.fast or ('RAW2DIGI' in self.stepMap and 'RECO' in self.stepMap):
            self.RECODefaultSeq='reconstruction'
        else:
            self.RECODefaultSeq='reconstruction_fromRECO'
        self.RECOSIMDefaultSeq='recosim'
        self.EIDefaultSeq='top'
        self.POSTRECODefaultSeq=None
        self.L1HwValDefaultSeq='L1HwVal'
        self.DQMDefaultSeq='DQMOffline'
        self.VALIDATIONDefaultSeq=''
        self.ENDJOBDefaultSeq='endOfProcess'
        self.REPACKDefaultSeq='DigiToRawRepack'
        self.PATDefaultSeq='miniAOD'
        self.PATGENDefaultSeq='miniGEN'
        #TODO: Check based of file input
        self.NANOGENDefaultSeq='nanogenSequence'
        self.NANODefaultSeq='nanoSequence'
 
        self.EVTCONTDefaultCFF="Configuration/EventContent/EventContent_cff"
 
        if not self._options.beamspot:
            self._options.beamspot=VtxSmearedDefaultKey
 
        # if its MC then change the raw2digi
        if self._options.isMC==True:
            self.RAW2DIGIDefaultCFF="Configuration/StandardSequences/RawToDigi_cff"
            self.RECODefaultCFF="Configuration/StandardSequences/Reconstruction_cff"
            self.PATDefaultCFF="Configuration/StandardSequences/PATMC_cff"
            self.PATGENDefaultCFF="Configuration/StandardSequences/PATGEN_cff"
            self.DQMOFFLINEDefaultCFF="DQMOffline/Configuration/DQMOfflineMC_cff"
            self.ALCADefaultCFF="Configuration/StandardSequences/AlCaRecoStreamsMC_cff"
            self.NANODefaultSeq='nanoSequenceMC'
        else:
            self._options.beamspot = None
 
        #patch for gen, due to backward incompatibility
        if 'reGEN' in self.stepMap:
            self.GENDefaultSeq='fixGenInfo'
 
        if self._options.scenario=='cosmics':
            self._options.pileup='Cosmics'
            self.DIGIDefaultCFF="Configuration/StandardSequences/DigiCosmics_cff"
            self.RECODefaultCFF="Configuration/StandardSequences/ReconstructionCosmics_cff"
            self.SKIMDefaultCFF="Configuration/StandardSequences/SkimsCosmics_cff"
            self.EVTCONTDefaultCFF="Configuration/EventContent/EventContentCosmics_cff"
            self.VALIDATIONDefaultCFF="Configuration/StandardSequences/ValidationCosmics_cff"
            self.DQMOFFLINEDefaultCFF="DQMOffline/Configuration/DQMOfflineCosmics_cff"
            if self._options.isMC==True:
                self.DQMOFFLINEDefaultCFF="DQMOffline/Configuration/DQMOfflineCosmicsMC_cff"
            self.HARVESTINGDefaultCFF="Configuration/StandardSequences/HarvestingCosmics_cff"
            self.RECODefaultSeq='reconstructionCosmics'
            self.DQMDefaultSeq='DQMOfflineCosmics'
 
        if self._options.scenario=='HeavyIons':
            if not self._options.beamspot:
                self._options.beamspot=VtxSmearedHIDefaultKey
            self.HLTDefaultSeq = 'HIon'
            self.VALIDATIONDefaultCFF="Configuration/StandardSequences/ValidationHeavyIons_cff"
            self.VALIDATIONDefaultSeq=''
            self.EVTCONTDefaultCFF="Configuration/EventContent/EventContentHeavyIons_cff"
            self.RECODefaultCFF="Configuration/StandardSequences/ReconstructionHeavyIons_cff"
            self.RECODefaultSeq='reconstructionHeavyIons'
            self.ALCADefaultCFF = "Configuration/StandardSequences/AlCaRecoStreamsHeavyIons_cff"
            self.DQMOFFLINEDefaultCFF="DQMOffline/Configuration/DQMOfflineHeavyIons_cff"
            self.DQMDefaultSeq='DQMOfflineHeavyIons'
            self.SKIMDefaultCFF="Configuration/StandardSequences/SkimsHeavyIons_cff"
            self.HARVESTINGDefaultCFF="Configuration/StandardSequences/HarvestingHeavyIons_cff"
            if self._options.isMC==True:
                self.DQMOFFLINEDefaultCFF="DQMOffline/Configuration/DQMOfflineHeavyIonsMC_cff"
 
 
        self.RAW2RECODefaultSeq=','.join([self.RAW2DIGIDefaultSeq,self.RECODefaultSeq])
 
        self.USERDefaultSeq='user'
        self.USERDefaultCFF=None
 
        # the magnetic field
        self.magFieldCFF = 'Configuration/StandardSequences/MagneticField_'+self._options.magField.replace('.','')+'_cff'
        self.magFieldCFF = self.magFieldCFF.replace("__",'_')
 
        # the geometry
        self.GeometryCFF='Configuration/StandardSequences/GeometryRecoDB_cff'
        self.geometryDBLabel=None
        simGeometry=''
        if self._options.fast:
            if 'start' in self._options.conditions.lower():
                self.GeometryCFF='FastSimulation/Configuration/Geometries_START_cff'
            else:
                self.GeometryCFF='FastSimulation/Configuration/Geometries_MC_cff'
        else:
            def inGeometryKeys(opt):
                from Configuration.StandardSequences.GeometryConf import GeometryConf
                if opt in GeometryConf:
                    return GeometryConf[opt]
                else:
                    return opt
 
            geoms=self._options.geometry.split(',')
            if len(geoms)==1: geoms=inGeometryKeys(geoms[0]).split(',')
            if len(geoms)==2:
                #may specify the reco geometry
                if '/' in geoms[1] or '_cff' in geoms[1]:
                    self.GeometryCFF=geoms[1]
                else:
                    self.GeometryCFF='Configuration/Geometry/Geometry'+geoms[1]+'_cff'
 
            if (geoms[0].startswith('DB:')):
                self.SimGeometryCFF='Configuration/StandardSequences/GeometrySimDB_cff'
                self.geometryDBLabel=geoms[0][3:]
                print("with DB:")
            else:
                if '/' in geoms[0] or '_cff' in geoms[0]:
                    self.SimGeometryCFF=geoms[0]
                else:
                    simGeometry=geoms[0]
                    if self._options.gflash==True:
                        self.SimGeometryCFF='Configuration/Geometry/Geometry'+geoms[0]+'GFlash_cff'
                    else:
                        self.SimGeometryCFF='Configuration/Geometry/Geometry'+geoms[0]+'_cff'
 
        # synchronize the geometry configuration and the FullSimulation sequence to be used
        if simGeometry not in defaultOptions.geometryExtendedOptions:
            self.SIMDefaultCFF="Configuration/StandardSequences/SimIdeal_cff"
 
        if self._options.scenario=='nocoll' or self._options.scenario=='cosmics':
            self.SIMDefaultCFF="Configuration/StandardSequences/SimNOBEAM_cff"
            self._options.beamspot='NoSmear'
 
        # fastsim requires some changes to the default cff files and sequences
        if self._options.fast:
            self.SIMDefaultCFF = 'FastSimulation.Configuration.SimIdeal_cff'
            self.RECODefaultCFF= 'FastSimulation.Configuration.Reconstruction_AftMix_cff'
            self.RECOBEFMIXDefaultCFF = 'FastSimulation.Configuration.Reconstruction_BefMix_cff'
            self.RECOBEFMIXDefaultSeq = 'reconstruction_befmix'
            self.NANODefaultSeq = 'nanoSequenceFS'
            self.DQMOFFLINEDefaultCFF="DQMOffline.Configuration.DQMOfflineFS_cff"
 
        # Mixing
        if self._options.pileup=='default':
            from Configuration.StandardSequences.Mixing import MixingDefaultKey
            self._options.pileup=MixingDefaultKey
 
 
        #not driven by a default cff anymore
        if self._options.isData:
            self._options.pileup=None
 
 
        self.REDIGIDefaultSeq=self.DIGIDefaultSeq
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.ALCADefaultCFF, ConfigBuilder.ConfigBuilder.loadAndRemember(), print(), and ConfigBuilder.ConfigBuilder.stepMap.

Referenced by ConfigBuilder.ConfigBuilder.addCustomiseCmdLine().

executeAndRemember()

def ConfigBuilder.ConfigBuilder.executeAndRemember	(		self,
			command
	)

helper routine to remember replace statements

Definition at line 330 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."))
 

References ConfigBuilder.ConfigBuilder.additionalCommands, and mps_setup.append.

Referenced by ConfigBuilder.ConfigBuilder.addCustomiseCmdLine(), ConfigBuilder.ConfigBuilder.addOutput(), ConfigBuilder.ConfigBuilder.addStandardSequences(), ConfigBuilder.ConfigBuilder.prepare_ALCAHARVEST(), ConfigBuilder.ConfigBuilder.prepare_DATAMIX(), ConfigBuilder.ConfigBuilder.prepare_DIGI(), ConfigBuilder.ConfigBuilder.prepare_GEN(), ConfigBuilder.ConfigBuilder.prepare_HLT(), ConfigBuilder.ConfigBuilder.prepare_SIM(), and ConfigBuilder.ConfigBuilder.prepare_VALIDATION().

expandMapping()

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

Definition at line 1951 of file ConfigBuilder.py.

    def expandMapping(self,seqList,mapping,index=None):
        maxLevel=30
        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))
 

References ConfigBuilder.ConfigBuilder.prepare_DQM().

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

finalizeFastSimHLT()

def ConfigBuilder.ConfigBuilder.finalizeFastSimHLT

(

self

)

Definition at line 2091 of file ConfigBuilder.py.

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

References mps_setup.append, ConfigBuilder.ConfigBuilder.build_production_info(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, and ConfigBuilder.ConfigBuilder.schedule.

Referenced by ConfigBuilder.ConfigBuilder.prepare_ENDJOB().

load()

def ConfigBuilder.ConfigBuilder.load	(		self,
			includeFile
	)

Definition at line 316 of file ConfigBuilder.py.

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

References DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, and ConfigBuilder.ConfigBuilder.process.

Referenced by ConfigBuilder.ConfigBuilder.addStandardSequences(), MatrixToProcess.MatrixToProcess.getProcess(), MatrixToProcess.MatrixToProcess.listAll(), ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.prepare_FILTER(), ConfigBuilder.ConfigBuilder.prepare_GEN(), and ConfigBuilder.ConfigBuilder.prepare_SKIM().

loadAndRemember()

def ConfigBuilder.ConfigBuilder.loadAndRemember	(		self,
			includeFile
	)

helper routine to load am memorize imports

Definition at line 321 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]
 

References mps_setup.append, ConfigBuilder.ConfigBuilder.imports, ConfigBuilder.ConfigBuilder.load(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, and ConfigBuilder.ConfigBuilder.process.

Referenced by ConfigBuilder.ConfigBuilder.addConditions(), ConfigBuilder.ConfigBuilder.addStandardSequences(), ConfigBuilder.ConfigBuilder.define_Configs(), ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.prepare(), ConfigBuilder.ConfigBuilder.prepare_ALCAHARVEST(), ConfigBuilder.ConfigBuilder.prepare_CFWRITER(), ConfigBuilder.ConfigBuilder.prepare_DATAMIX(), ConfigBuilder.ConfigBuilder.prepare_DIGI(), ConfigBuilder.ConfigBuilder.prepare_DQM(), ConfigBuilder.ConfigBuilder.prepare_GEN(), ConfigBuilder.ConfigBuilder.prepare_HLT(), ConfigBuilder.ConfigBuilder.prepare_L1(), ConfigBuilder.ConfigBuilder.prepare_L1REPACK(), ConfigBuilder.ConfigBuilder.prepare_PATFILTER(), ConfigBuilder.ConfigBuilder.prepare_POSTRECO(), and ConfigBuilder.ConfigBuilder.prepare_SIM().

loadDefaultOrSpecifiedCFF()

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

Definition at line 1220 of file ConfigBuilder.py.

    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
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_ALCA(), ConfigBuilder.ConfigBuilder.prepare_DIGI(), ConfigBuilder.ConfigBuilder.prepare_DIGI2RAW(), ConfigBuilder.ConfigBuilder.prepare_DQM(), ConfigBuilder.ConfigBuilder.prepare_EI(), ConfigBuilder.ConfigBuilder.prepare_ENDJOB(), ConfigBuilder.ConfigBuilder.prepare_GEN(), ConfigBuilder.ConfigBuilder.prepare_L1HwVal(), ConfigBuilder.ConfigBuilder.prepare_L1Reco(), ConfigBuilder.ConfigBuilder.prepare_L1TrackTrigger(), ConfigBuilder.ConfigBuilder.prepare_NANO(), ConfigBuilder.ConfigBuilder.prepare_NANOGEN(), ConfigBuilder.ConfigBuilder.prepare_PAT(), ConfigBuilder.ConfigBuilder.prepare_PATGEN(), ConfigBuilder.ConfigBuilder.prepare_RAW2DIGI(), ConfigBuilder.ConfigBuilder.prepare_RECO(), ConfigBuilder.ConfigBuilder.prepare_RECOBEFMIX(), ConfigBuilder.ConfigBuilder.prepare_RECOSIM(), ConfigBuilder.ConfigBuilder.prepare_REPACK(), ConfigBuilder.ConfigBuilder.prepare_SIM(), ConfigBuilder.ConfigBuilder.prepare_SKIM(), ConfigBuilder.ConfigBuilder.prepare_USER(), and ConfigBuilder.ConfigBuilder.prepare_VALIDATION().

prepare()

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

Prepare the configuration string and add missing pieces.

Definition at line 2154 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()
        self.addStandardSequences()
        
        self.completeInputCommand()
        self.addConditions()
 
 
        outputModuleCfgCode=""
        if not 'HARVESTING' in self.stepMap.keys() and not 'ALCAHARVEST' in self.stepMap.keys() and not 'ALCAOUTPUT' in self.stepMap.keys() and self.with_output:
            outputModuleCfgCode=self.addOutput()
 
        self.addCommon()
 
        self.pythonCfgCode += "# import of standard configurations\n"
        for module in self.imports:
            self.pythonCfgCode += ("process.load('"+module+"')\n")
 
        # production info
        if not hasattr(self.process,"configurationMetadata"):
            self.build_production_info(self._options.evt_type, self._options.number)
        else:
            #the PSet was added via a load
            self.addedObjects.append(("Production Info","configurationMetadata"))
 
        self.pythonCfgCode +="\n"
        for comment,object in self.addedObjects:
            if comment!="":
                self.pythonCfgCode += "\n# "+comment+"\n"
            self.pythonCfgCode += dumpPython(self.process,object)
 
        # dump the output definition
        self.pythonCfgCode += "\n# Output definition\n"
        self.pythonCfgCode += outputModuleCfgCode
 
        # dump all additional outputs (e.g. alca or skim streams)
        self.pythonCfgCode += "\n# Additional output definition\n"
        #I do not understand why the keys are not normally ordered.
        nl=sorted(self.additionalOutputs.keys())
        for name in nl:
            output = self.additionalOutputs[name]
            self.pythonCfgCode += "process.%s = %s" %(name, output.dumpPython())
            tmpOut = cms.EndPath(output)
            setattr(self.process,name+'OutPath',tmpOut)
            self.schedule.append(tmpOut)
 
        # dump all additional commands
        self.pythonCfgCode += "\n# Other statements\n"
        for command in self.additionalCommands:
            self.pythonCfgCode += command + "\n"
 
        #comma separated list of objects that deserve to be inlined in the configuration (typically from a modified config deep down)
        for object in self._options.inlineObjets.split(','):
            if not object:
                continue
            if not hasattr(self.process,object):
                print('cannot inline -'+object+'- : not known')
            else:
                self.pythonCfgCode +='\n'
                self.pythonCfgCode +=dumpPython(self.process,object)
 
        if self._options.pileup=='HiMixEmbGEN':
            self.pythonCfgCode += "\nprocess.generator.embeddingMode=cms.bool(True)\n"
 
        # dump all paths
        self.pythonCfgCode += "\n# Path and EndPath definitions\n"
        for path in self.process.paths:
            if getattr(self.process,path) not in self.blacklist_paths:
                self.pythonCfgCode += dumpPython(self.process,path)
 
        for endpath in self.process.endpaths:
            if getattr(self.process,endpath) not in self.blacklist_paths:
                self.pythonCfgCode += dumpPython(self.process,endpath)
 
        # dump the schedule
        self.pythonCfgCode += "\n# Schedule definition\n"
        result = "process.schedule = cms.Schedule("
 
        # handling of the schedule
        self.process.schedule = cms.Schedule()
        for item in self.schedule:
            if not isinstance(item, cms.Schedule):
                self.process.schedule.append(item)
            else:
                self.process.schedule.extend(item)
 
        if hasattr(self.process,"HLTSchedule"):
            beforeHLT = self.schedule[:self.schedule.index(self.process.HLTSchedule)]
            afterHLT = self.schedule[self.schedule.index(self.process.HLTSchedule)+1:]
            pathNames = ['process.'+p.label_() for p in beforeHLT]
            result += ','.join(pathNames)+')\n'
            result += 'process.schedule.extend(process.HLTSchedule)\n'
            pathNames = ['process.'+p.label_() for p in afterHLT]
            result += 'process.schedule.extend(['+','.join(pathNames)+'])\n'
        else:
            pathNames = ['process.'+p.label_() for p in self.schedule]
            result ='process.schedule = cms.Schedule('+','.join(pathNames)+')\n'
 
        self.pythonCfgCode += result
 
        for labelToAssociate in self.labelsToAssociate:
            self.process.schedule.associate(getattr(self.process, labelToAssociate))
            self.pythonCfgCode += 'process.schedule.associate(process.' + labelToAssociate + ')\n'
 
        from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask
        associatePatAlgosToolsTask(self.process)
        self.pythonCfgCode+="from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask\n"
        self.pythonCfgCode+="associatePatAlgosToolsTask(process)\n"
 
        if self._options.nThreads != "1":
            self.pythonCfgCode +="\n"
            self.pythonCfgCode +="#Setup FWK for multithreaded\n"
            self.pythonCfgCode +="process.options.numberOfThreads = "+self._options.nThreads+"\n"
            self.pythonCfgCode +="process.options.numberOfStreams = "+self._options.nStreams+"\n"
            self.pythonCfgCode +="process.options.numberOfConcurrentLuminosityBlocks = "+self._options.nConcurrentLumis+"\n"
            self.pythonCfgCode +="process.options.eventSetup.numberOfConcurrentIOVs = "+self._options.nConcurrentIOVs+"\n"
            if int(self._options.nConcurrentLumis) > 1:
              self.pythonCfgCode +="if hasattr(process, 'DQMStore'): process.DQMStore.assertLegacySafe=cms.untracked.bool(False)\n"
            self.process.options.numberOfThreads = int(self._options.nThreads)
            self.process.options.numberOfStreams = int(self._options.nStreams)
            self.process.options.numberOfConcurrentLuminosityBlocks = int(self._options.nConcurrentLumis)
            self.process.options.eventSetup.numberOfConcurrentIOVs = int(self._options.nConcurrentIOVs)
        #repacked version
        if self._options.isRepacked:
            self.pythonCfgCode +="\n"
            self.pythonCfgCode +="from Configuration.Applications.ConfigBuilder import MassReplaceInputTag\n"
            self.pythonCfgCode +="MassReplaceInputTag(process, new=\"rawDataMapperByLabel\", old=\"rawDataCollector\")\n"
            MassReplaceInputTag(self.process, new="rawDataMapperByLabel", old="rawDataCollector")
 
        # special treatment in case of production filter sequence 2/2
        if self.productionFilterSequence and not (self._options.pileup=='HiMixEmbGEN'):
            self.pythonCfgCode +='# filter all path with the production filter sequence\n'
            self.pythonCfgCode +='for path in process.paths:\n'
            if len(self.conditionalPaths):
                self.pythonCfgCode +='\tif not path in %s: continue\n'%str(self.conditionalPaths)
            if len(self.excludedPaths):
                self.pythonCfgCode +='\tif path in %s: continue\n'%str(self.excludedPaths)
            self.pythonCfgCode +='\tgetattr(process,path).insert(0, process.%s)\n'%(self.productionFilterSequence,)
            pfs = getattr(self.process,self.productionFilterSequence)
            for path in self.process.paths:
                if not path in self.conditionalPaths: continue
                if path in self.excludedPaths: continue
                getattr(self.process,path).insert(0, pfs)
 
 
        # dump customise fragment
        self.pythonCfgCode += self.addCustomise()
 
        if self._options.runUnscheduled:
            print("--runUnscheduled is deprecated and not necessary anymore, and will be removed soon. Please update your command line.")
        # Keep the "unscheduled customise functions" separate for now,
        # there are customize functions given by users (in our unit
        # tests) that need to be run before the "unscheduled customise
        # functions"
        self.pythonCfgCode += self.addCustomise(1)
 
        self.pythonCfgCode += self.addCustomiseCmdLine()
 
        if hasattr(self.process,"logErrorHarvester"):
            #configure logErrorHarvester to wait for same EDProducers to finish as the OutputModules
            self.pythonCfgCode +="\n#Have logErrorHarvester wait for the same EDProducers to finish as those providing data for the OutputModule\n"
            self.pythonCfgCode +="from FWCore.Modules.logErrorHarvester_cff import customiseLogErrorHarvesterUsingOutputCommands\n"
            self.pythonCfgCode +="process = customiseLogErrorHarvesterUsingOutputCommands(process)\n"
            from FWCore.Modules.logErrorHarvester_cff import customiseLogErrorHarvesterUsingOutputCommands
            self.process = customiseLogErrorHarvesterUsingOutputCommands(self.process)
 
        # Temporary hack to put the early delete customization after
        # everything else
        #
        # FIXME: remove when no longer needed
        self.pythonCfgCode += "\n# Add early deletion of temporary data products to reduce peak memory need\n"
        self.pythonCfgCode += "from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete\n"
        self.pythonCfgCode += "process = customiseEarlyDelete(process)\n"
        self.pythonCfgCode += "# End adding early deletion\n"
        from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete
        self.process = customiseEarlyDelete(self.process)
 
        imports = cms.specialImportRegistry.getSpecialImports()
        if len(imports) > 0:
            #need to inject this at the top
            index = self.pythonCfgCode.find("import FWCore.ParameterSet.Config")
            #now find the end of line
            index = self.pythonCfgCode.find("\n",index)
            self.pythonCfgCode = self.pythonCfgCode[:index]+ "\n" + "\n".join(imports)+"\n" +self.pythonCfgCode[index:]
 
 
        # make the .io file
 
        if self._options.io:
            #io=open(self._options.python_filename.replace('.py','.io'),'w')
            if not self._options.io.endswith('.io'): self._option.io+='.io'
            io=open(self._options.io,'w')
            ioJson={}
            if hasattr(self.process.source,"fileNames"):
                if len(self.process.source.fileNames.value()):
                    ioJson['primary']=self.process.source.fileNames.value()
            if hasattr(self.process.source,"secondaryFileNames"):
                if len(self.process.source.secondaryFileNames.value()):
                    ioJson['secondary']=self.process.source.secondaryFileNames.value()
            if self._options.pileup_input and (self._options.pileup_input.startswith('dbs:') or self._options.pileup_input.startswith('das:')):
                ioJson['pileup']=self._options.pileup_input[4:]
            for (o,om) in self.process.outputModules_().items():
                ioJson[o]=om.fileName.value()
            ioJson['GT']=self.process.GlobalTag.globaltag.value()
            if self.productionFilterSequence:
                ioJson['filter']=self.productionFilterSequence
            import json
            io.write(json.dumps(ioJson))
        return
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.addCommon(), ConfigBuilder.ConfigBuilder.addConditions(), ConfigBuilder.ConfigBuilder.addCustomise(), ConfigBuilder.ConfigBuilder.addCustomiseCmdLine(), ConfigBuilder.ConfigBuilder.addedObjects, ConfigBuilder.ConfigBuilder.additionalCommands, ConfigBuilder.ConfigBuilder.additionalOutputs, ConfigBuilder.ConfigBuilder.addMaxEvents(), ConfigBuilder.ConfigBuilder.addOutput(), ConfigBuilder.ConfigBuilder.addSource(), ConfigBuilder.ConfigBuilder.addStandardSequences(), mps_setup.append, helpers.associatePatAlgosToolsTask(), ConfigBuilder.ConfigBuilder.blacklist_paths, ConfigBuilder.ConfigBuilder.build_production_info(), ConfigBuilder.ConfigBuilder.completeInputCommand(), ConfigBuilder.ConfigBuilder.conditionalPaths, earlyDeleteSettings_cff.customiseEarlyDelete(), logErrorHarvester_cff.customiseLogErrorHarvesterUsingOutputCommands(), ConfigBuilder.dumpPython(), ConfigBuilder.ConfigBuilder.EVTCONTDefaultCFF, ConfigBuilder.ConfigBuilder.excludedPaths, spr.find(), ConfigBuilder.ConfigBuilder.imports, edm::eventsetup::heterocontainer.insert(), createfilelist.int, mps_monitormerge.items, join(), relativeConstraints.keys, ConfigBuilder.ConfigBuilder.labelsToAssociate, ConfigBuilder.ConfigBuilder.loadAndRemember(), print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, ConfigBuilder.ConfigBuilder.productionFilterSequence, ConfigBuilder.ConfigBuilder.pythonCfgCode, ConfigBuilder.ConfigBuilder.schedule, ConfigBuilder.ConfigBuilder.stepMap, str, ConfigBuilder.ConfigBuilder.with_input, and ConfigBuilder.ConfigBuilder.with_output.

prepare_ALCA()

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

Enrich the process with alca streams 

Definition at line 1271 of file ConfigBuilder.py.

    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("+")
        maxLevel=0
        from Configuration.AlCa.autoAlca import autoAlca
        # support @X from autoAlca.py, and recursion support: i.e T0:@Mu+@EG+...
        self.expandMapping(alcaList,autoAlca)
        self.AlCaPaths=[]
        for name in alcaConfig.__dict__:
            alcastream = getattr(alcaConfig,name)
            shortName = name.replace('ALCARECOStream','')
            if shortName in alcaList and isinstance(alcastream,cms.FilteredStream):
                isNano = (alcastream.dataTier == "NANOAOD")
                output = self.addExtraStream(name, alcastream, workflow=workflow,
                        cppType=("NanoAODOutputModule" if isNano else "PoolOutputModule"))
                self.executeAndRemember('process.ALCARECOEventContent.outputCommands.extend(process.OutALCARECO'+shortName+'_noDrop.outputCommands)')
                self.AlCaPaths.append(shortName)
                if 'DQM' in alcaList and not isNano:
                    if not self._options.inlineEventContent and hasattr(self.process,name):
                        self.executeAndRemember('process.' + name + '.outputCommands.append("keep *_MEtoEDMConverter_*_*")')
                    else:
                        output.outputCommands.append("keep *_MEtoEDMConverter_*_*")
 
                #rename the HLT process name in the alca modules
                if self._options.hltProcess or 'HLT' in self.stepMap:
                    if isinstance(alcastream.paths,tuple):
                        for path in alcastream.paths:
                            self.renameHLTprocessInSequence(path.label())
                    else:
                        self.renameHLTprocessInSequence(alcastream.paths.label())
 
                for i in range(alcaList.count(shortName)):
                    alcaList.remove(shortName)
 
            # DQM needs a special handling
            elif name == 'pathALCARECODQM' and 'DQM' in alcaList:
                path = getattr(alcaConfig,name)
                self.schedule.append(path)
                alcaList.remove('DQM')
 
            if isinstance(alcastream,cms.Path):
                #black list the alca path so that they do not appear in the cfg
                self.blacklist_paths.append(alcastream)
 
 
        if len(alcaList) != 0:
            available=[]
            for name in alcaConfig.__dict__:
                alcastream = getattr(alcaConfig,name)
                if isinstance(alcastream,cms.FilteredStream):
                    available.append(name.replace('ALCARECOStream',''))
            print("The following alcas could not be found "+str(alcaList))
            print("available ",available)
            #print "verify your configuration, ignoring for now"
            raise Exception("The following alcas could not be found "+str(alcaList))
 

References ConfigBuilder.ConfigBuilder.ALCADefaultCFF, ConfigBuilder.ConfigBuilder.AlCaPaths, ConfigBuilder.ConfigBuilder.expandMapping(), and ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF().

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

prepare_ALCAHARVEST()

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

Enrich the process with AlCaHarvesting step 

Definition at line 2051 of file ConfigBuilder.py.

    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("+")
 
 
 
        from Configuration.AlCa.autoPCL import autoPCL
        self.expandMapping(harvestingList,autoPCL)
 
        for name in harvestingConfig.__dict__:
            harvestingstream = getattr(harvestingConfig,name)
            if name in harvestingList and isinstance(harvestingstream,cms.Path):
                self.schedule.append(harvestingstream)
                if isinstance(getattr(harvestingConfig,"ALCAHARVEST" + name + "_dbOutput"), cms.VPSet) and \
                   isinstance(getattr(harvestingConfig,"ALCAHARVEST" + name + "_metadata"), cms.VPSet):
                    self.executeAndRemember("process.PoolDBOutputService.toPut.extend(process.ALCAHARVEST" + name + "_dbOutput)")
                    self.executeAndRemember("process.pclMetadataWriter.recordsToMap.extend(process.ALCAHARVEST" + name + "_metadata)")
                else:
                    self.executeAndRemember("process.PoolDBOutputService.toPut.append(process.ALCAHARVEST" + name + "_dbOutput)")
                    self.executeAndRemember("process.pclMetadataWriter.recordsToMap.append(process.ALCAHARVEST" + name + "_metadata)")
                harvestingList.remove(name)
        # append the common part at the end of the sequence
        lastStep = getattr(harvestingConfig,"ALCAHARVESTDQMSaveAndMetadataWriter")
        self.schedule.append(lastStep)
 
        if len(harvestingList) != 0 and 'dummyHarvesting' not in harvestingList :
            print("The following harvesting could not be found : ", harvestingList)
            raise Exception("The following harvesting could not be found : "+str(harvestingList))
 
 
 

References ConfigBuilder.ConfigBuilder.ALCAHARVESTDefaultCFF, mps_setup.append, ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.ConfigBuilder.expandMapping(), ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.prepare_ENDJOB(), print(), ConfigBuilder.ConfigBuilder.schedule, and str.

prepare_ALCAOUTPUT()

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

Definition at line 1268 of file ConfigBuilder.py.

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

References ConfigBuilder.ConfigBuilder.prepare_ALCA().

Referenced by ConfigBuilder.ConfigBuilder.prepare_ALCAPRODUCER().

prepare_ALCAPRODUCER()

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

Definition at line 1265 of file ConfigBuilder.py.

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

References ConfigBuilder.ConfigBuilder.prepare_ALCA(), and ConfigBuilder.ConfigBuilder.prepare_ALCAOUTPUT().

Referenced by ConfigBuilder.ConfigBuilder.scheduleSequenceAtEnd().

prepare_CFWRITER()

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

Enrich the schedule with the crossing frame writer step

Definition at line 1468 of file ConfigBuilder.py.

    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
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_DIGI().

prepare_DATAMIX()

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

Enrich the schedule with the digitisation step

Definition at line 1474 of file ConfigBuilder.py.

    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
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_CFWRITER().

prepare_DIGI()

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

Enrich the schedule with the digitisation step

Definition at line 1448 of file ConfigBuilder.py.

    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)")
 
        if sequence != 'pdigi_nogen' and sequence != 'pdigi_valid_nogen' and sequence != 'pdigi_hi_nogen' and not self.process.source.type_()=='EmptySource' and not self._options.filetype == "LHE":
            if self._options.inputEventContent=='':
                self._options.inputEventContent='REGEN'
            else:
                self._options.inputEventContent=self._options.inputEventContent+',REGEN'
 
 
        self.scheduleSequence(sequence.split('.')[-1],'digitisation_step')
        return
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.DIGIDefaultCFF, ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.prepare_CFWRITER(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, and ConfigBuilder.ConfigBuilder.scheduleSequence().

Referenced by ConfigBuilder.ConfigBuilder.prepare_SIM().

prepare_DIGI2RAW()

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

Definition at line 1492 of file ConfigBuilder.py.

    def prepare_DIGI2RAW(self, sequence = None):
        self.loadDefaultOrSpecifiedCFF(sequence,self.DIGI2RAWDefaultCFF)
        self.scheduleSequence(sequence.split('.')[-1],'digi2raw_step')
        return
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_DATAMIX().

prepare_DQM()

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

Definition at line 1970 of file ConfigBuilder.py.

    def prepare_DQM(self, sequence = 'DQMOffline'):
        # this one needs replacement
 
        # any 'DQM' job should use DQMStore in non-legacy mode (but not HARVESTING)
        self.loadAndRemember("DQMServices/Core/DQMStoreNonLegacy_cff")
        self.loadDefaultOrSpecifiedCFF(sequence,self.DQMOFFLINEDefaultCFF)
        sequenceList=sequence.split('.')[-1].split('+')
        postSequenceList=sequence.split('.')[-1].split('+')
        from DQMOffline.Configuration.autoDQM import autoDQM
        self.expandMapping(sequenceList,autoDQM,index=0)
        self.expandMapping(postSequenceList,autoDQM,index=1)
 
        if len(set(sequenceList))!=len(sequenceList):
            sequenceList=list(set(sequenceList))
            print("Duplicate entries for DQM:, using",sequenceList)
 
        pathName='dqmoffline_step'
        for (i,sequence) in enumerate(sequenceList):
            if (i!=0):
                pathName='dqmoffline_%d_step'%(i)
 
            if 'HLT' in self.stepMap.keys() or self._options.hltProcess:
                self.renameHLTprocessInSequence(sequence)
 
            setattr(self.process,pathName, cms.EndPath( getattr(self.process,sequence ) ) )
            self.schedule.append(getattr(self.process,pathName))
 
            if hasattr(self.process,"genstepfilter") and len(self.process.genstepfilter.triggerConditions):
                #will get in the schedule, smoothly
                getattr(self.process,pathName).insert(0,self.process.genstepfilter)
 
 
        pathName='dqmofflineOnPAT_step'
        for (i,sequence) in enumerate(postSequenceList):
        #Fix needed to avoid duplication of sequences not defined in autoDQM or without a PostDQM
            if (sequenceList[i]==postSequenceList[i]):
                      continue
            if (i!=0):
                pathName='dqmofflineOnPAT_%d_step'%(i)
 
            setattr(self.process,pathName, cms.EndPath( getattr(self.process, sequence ) ) )
            self.schedule.append(getattr(self.process,pathName))
 

References ConfigBuilder.ConfigBuilder._options, mps_setup.append, ConfigBuilder.ConfigBuilder.DQMOFFLINEDefaultCFF, ConfigBuilder.ConfigBuilder.expandMapping(), edm::eventsetup::heterocontainer.insert(), relativeConstraints.keys, ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.prepare_HARVESTING(), print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, ConfigBuilder.ConfigBuilder.renameHLTprocessInSequence(), ConfigBuilder.ConfigBuilder.schedule, submitPVValidationJobs.split(), and ConfigBuilder.ConfigBuilder.stepMap.

Referenced by ConfigBuilder.ConfigBuilder.expandMapping().

prepare_EI()

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

Enrich the schedule with event interpretation 

Definition at line 1728 of file ConfigBuilder.py.

    def prepare_EI(self, sequence = None):
        ''' Enrich the schedule with event interpretation '''
        from Configuration.StandardSequences.EventInterpretation import EventInterpretation
        if sequence in EventInterpretation:
            self.EIDefaultCFF = EventInterpretation[sequence]
            sequence = 'EIsequence'
        else:
            raise Exception('Cannot set %s event interpretation'%( sequence) )
        self.loadDefaultOrSpecifiedCFF(sequence,self.EIDefaultCFF)
        self.scheduleSequence(sequence.split('.')[-1],'eventinterpretaion_step')
        return
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_NANOGEN().

prepare_ENDJOB()

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

Definition at line 2086 of file ConfigBuilder.py.

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

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_ALCAHARVEST().

prepare_FILTER()

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

Enrich the schedule with a user defined filter sequence 

Definition at line 1620 of file ConfigBuilder.py.

    def prepare_FILTER(self, sequence = None):
        ''' Enrich the schedule with a user defined filter sequence '''
        
        filterConfig=self.load(sequence.split('.')[0])
        filterSeq=sequence.split('.')[-1]
        
        class PrintAllModules(object):
            def __init__(self):
                self.inliner=''
                pass
            def enter(self,visitee):
                try:
                    label=visitee.label()
                    
                    self.inliner=label+','+self.inliner
                except:
                    pass
            def leave(self,v): pass
 
        expander=PrintAllModules()
        getattr(self.process,filterSeq).visit( expander )
        self._options.inlineObjets+=','+expander.inliner
        self._options.inlineObjets+=','+filterSeq
 
        
        self.scheduleSequence(filterSeq,'filtering_step')
        self.nextScheduleIsConditional=True
        
        self.productionFilterSequence = filterSeq
 
        return
 

References ConfigBuilder.ConfigBuilder.__init__(), ConfigBuilder.ConfigBuilder.inliner, VisualizationOptions.load(), BTagCalibrationReader::BTagCalibrationReaderImpl.load(), BTagCalibrationReader.load(), cond::persistency::GTEditor.load(), L1MuDTPtaLut.load(), cond::persistency::IOVEditor.load(), L1MuDTPhiLut.load(), L1MuDTEtaPatternLut.load(), L1MuDTQualPatternLut.load(), PiecewiseScalingPolynomial.load(), L1MuDTExtLut.load(), HBHENegativeEFilter.load(), HBHEChannelGroups.load(), cond::persistency::RunInfoProxy.load(), HcalIndexLookup.load(), cond::persistency::GTProxy.load(), cond::persistency::IOVProxy.load(), OOTPileupCorrData.load(), TrackerMap.load(), ConfigBuilder.ConfigBuilder.load(), tkal_create_file_lists._DasCache.load(), and resolutioncreator_cfi.object.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1TrackTrigger().

prepare_GEN()

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

load the fragment of generator configuration 

Definition at line 1348 of file ConfigBuilder.py.

    def prepare_GEN(self, sequence = None):
        """ load the fragment of generator configuration """
        loadFailure=False
        #remove trailing .py
        #support old style .cfi by changing into something.cfi into something_cfi
        #remove python/ from the name
        loadFragment = self._options.evt_type.replace('.py','',).replace('.','_').replace('python/','')
        #standard location of fragments
        if not '/' in loadFragment:
            loadFragment='Configuration.Generator.'+loadFragment
        else:
            loadFragment=loadFragment.replace('/','.')
        try:
            print("Loading generator fragment from",loadFragment)
            __import__(loadFragment)
        except:
            loadFailure=True
            #if self.process.source and self.process.source.type_()=='EmptySource':
            if not (self._options.filein or self._options.dasquery):
                raise Exception("Neither gen fragment of input files provided: this is an inconsistent GEN step configuration")
 
        if not loadFailure:
            generatorModule=sys.modules[loadFragment]
            genModules=generatorModule.__dict__
            #remove lhe producer module since this should have been
            #imported instead in the LHE step
            if self.LHEDefaultSeq in genModules:
                del genModules[self.LHEDefaultSeq]
 
            if self._options.hideGen:
                self.loadAndRemember(loadFragment)
            else:
                self.process.load(loadFragment)
                # expose the objects from that fragment to the configuration
                import FWCore.ParameterSet.Modules as cmstypes
                for name in genModules:
                    theObject = getattr(generatorModule,name)
                    if isinstance(theObject, cmstypes._Module):
                        self._options.inlineObjets=name+','+self._options.inlineObjets
                    elif isinstance(theObject, cms.Sequence) or isinstance(theObject, cmstypes.ESProducer):
                        self._options.inlineObjets+=','+name
 
            if sequence == self.GENDefaultSeq or sequence == 'pgen_genonly':
                if 'ProductionFilterSequence' in genModules and ('generator' in genModules):
                    self.productionFilterSequence = 'ProductionFilterSequence'
                elif 'generator' in genModules:
                    self.productionFilterSequence = 'generator'
 
        """ Enrich the schedule with the rest of the generation step """
        self.loadDefaultOrSpecifiedCFF(sequence,self.GENDefaultCFF)
        genSeqName=sequence.split('.')[-1]
 
        if True:
            try:
                from Configuration.StandardSequences.VtxSmeared import VtxSmeared
                cffToBeLoaded=VtxSmeared[self._options.beamspot]
                self.loadAndRemember(cffToBeLoaded)
            except ImportError:
                raise Exception("VertexSmearing type or beamspot "+self._options.beamspot+" unknown.")
 
            if self._options.scenario == 'HeavyIons':
                if self._options.pileup=='HiMixGEN':
                    self.loadAndRemember("Configuration/StandardSequences/GeneratorMix_cff")
                elif self._options.pileup=='HiMixEmbGEN':
                    self.loadAndRemember("Configuration/StandardSequences/GeneratorEmbMix_cff")
                else:
                    self.loadAndRemember("Configuration/StandardSequences/GeneratorHI_cff")
 
        self.process.generation_step = cms.Path( getattr(self.process,genSeqName) )
        self.schedule.append(self.process.generation_step)
 
        #register to the genstepfilter the name of the path (static right now, but might evolve)
        self.executeAndRemember('process.genstepfilter.triggerConditions=cms.vstring("generation_step")')
 
        if 'reGEN' in self.stepMap:
            #stop here
            return
 
        """ Enrich the schedule with the summary of the filter step """
        #the gen filter in the endpath
        self.loadAndRemember("GeneratorInterface/Core/genFilterSummary_cff")
        self.scheduleSequenceAtEnd('genFilterSummary','genfiltersummary_step')
        return
 

References ConfigBuilder.ConfigBuilder._options, mps_setup.append, ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.ConfigBuilder.GENDefaultCFF, ConfigBuilder.ConfigBuilder.GENDefaultSeq, ConfigBuilder.ConfigBuilder.LHEDefaultSeq, ConfigBuilder.ConfigBuilder.load(), ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.prepare_SIM(), print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, ConfigBuilder.ConfigBuilder.productionFilterSequence, python.rootplot.root2matplotlib.replace(), ConfigBuilder.ConfigBuilder.schedule, ConfigBuilder.ConfigBuilder.scheduleSequenceAtEnd(), and ConfigBuilder.ConfigBuilder.stepMap.

prepare_HARVESTING()

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

Enrich the process with harvesting step 

Definition at line 2013 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("+")
        from DQMOffline.Configuration.autoDQM import autoDQM
        from Validation.Configuration.autoValidation import autoValidation
        import copy
        combined_mapping = copy.deepcopy( autoDQM )
        combined_mapping.update( autoValidation )
        self.expandMapping(harvestingList,combined_mapping,index=-1)
 
        if len(set(harvestingList))!=len(harvestingList):
            harvestingList=list(set(harvestingList))
            print("Duplicate entries for HARVESTING, using",harvestingList)
 
        for name in harvestingList:
            if not name in harvestingConfig.__dict__:
                print(name,"is not a possible harvesting type. Available are",harvestingConfig.__dict__.keys())
                # trigger hard error, like for other sequence types
                getattr(self.process, name)
                continue
            harvestingstream = getattr(harvestingConfig,name)
            if isinstance(harvestingstream,cms.Path):
                self.schedule.append(harvestingstream)
                self.blacklist_paths.append(harvestingstream)
            if isinstance(harvestingstream,cms.Sequence):
                setattr(self.process,name+"_step",cms.Path(harvestingstream))
                self.schedule.append(getattr(self.process,name+"_step"))
 
        self.scheduleSequence('DQMSaver','dqmsave_step')
        return
 

References ConfigBuilder.ConfigBuilder._options, and ConfigBuilder.ConfigBuilder.DQMSaverCFF.

Referenced by ConfigBuilder.ConfigBuilder.prepare_DQM().

prepare_HLT()

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

Enrich the schedule with the HLT simulation step

Definition at line 1522 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.items())
            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")
 
        if self._options.name != 'HLT':
            self.additionalCommands.append('from HLTrigger.Configuration.CustomConfigs import ProcessName')
            self.additionalCommands.append('process = ProcessName(process)')
            self.additionalCommands.append('')
            from HLTrigger.Configuration.CustomConfigs import ProcessName
            self.process = ProcessName(self.process)
 
        self.schedule.append(self.process.HLTSchedule)
        [self.blacklist_paths.append(path) for path in self.process.HLTSchedule if isinstance(path,(cms.Path,cms.EndPath))]
 
        #this is a fake, to be removed with fastim migration and HLT menu dump
        if self._options.fast:
            if not hasattr(self.process,'HLTEndSequence'):
                self.executeAndRemember("process.HLTEndSequence = cms.Sequence( process.dummyModule )")
 
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.additionalCommands, mps_setup.append, ConfigBuilder.ConfigBuilder.blacklist_paths, ConfigBuilder.ConfigBuilder.executeAndRemember(), join(), ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.prepare_RAW2RECO(), print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, CustomConfigs.ProcessName(), and ConfigBuilder.ConfigBuilder.schedule.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1REPACK().

prepare_L1()

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

Enrich the schedule with the L1 simulation step

Definition at line 1502 of file ConfigBuilder.py.

    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
 

References cms::cuda.assert(), ConfigBuilder.ConfigBuilder.L1EMDefaultCFF, ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.prepare_L1REPACK(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

Referenced by ConfigBuilder.ConfigBuilder.prepare_REPACK().

prepare_L1HwVal()

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

Enrich the schedule with L1 HW validation 

Definition at line 1601 of file ConfigBuilder.py.

    def prepare_L1HwVal(self, sequence = 'L1HwVal'):
        ''' Enrich the schedule with L1 HW validation '''
        self.loadDefaultOrSpecifiedCFF(sequence,self.L1HwValDefaultCFF)
        #self.scheduleSequence(sequence.split('.')[-1],'l1hwval_step')
        print('\n\n\n DEPRECATED this has no action \n\n\n')
        return
 

References ConfigBuilder.ConfigBuilder.L1HwValDefaultCFF, ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.prepare_L1Reco(), and print().

Referenced by ConfigBuilder.ConfigBuilder.prepare_PATFILTER().

prepare_L1Reco()

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

Enrich the schedule with L1 reconstruction 

Definition at line 1608 of file ConfigBuilder.py.

    def prepare_L1Reco(self, sequence = "L1Reco"):
        ''' Enrich the schedule with L1 reconstruction '''
        self.loadDefaultOrSpecifiedCFF(sequence,self.L1RecoDefaultCFF)
        self.scheduleSequence(sequence.split('.')[-1],'L1Reco_step')
        return
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1HwVal().

prepare_L1REPACK()

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 1509 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','CalouGT']
        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')
 
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.prepare_HLT(), print(), ConfigBuilder.ConfigBuilder.renameInputTagsInSequence(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1().

prepare_L1TrackTrigger()

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

Enrich the schedule with L1 reconstruction 

Definition at line 1614 of file ConfigBuilder.py.

    def prepare_L1TrackTrigger(self, sequence = "L1TrackTrigger"):
        ''' Enrich the schedule with L1 reconstruction '''
        self.loadDefaultOrSpecifiedCFF(sequence,self.L1TrackTriggerDefaultCFF)
        self.scheduleSequence(sequence.split('.')[-1],'L1TrackTrigger_step')
        return
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1Reco().

prepare_LHE()

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

Definition at line 1331 of file ConfigBuilder.py.

    def prepare_LHE(self, sequence = None):
            #load the fragment
            
        loadFragment = self._options.evt_type.replace('.py','',).replace('.','_').replace('python/','').replace('/','.')
        print("Loading lhe fragment from",loadFragment)
        __import__(loadFragment)
        self.process.load(loadFragment)
        
        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 )
 

prepare_NANO()

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

Enrich the schedule with NANO 

Definition at line 1705 of file ConfigBuilder.py.

    def prepare_NANO(self, sequence = "nanoAOD"):
        ''' Enrich the schedule with NANO '''
        self.loadDefaultOrSpecifiedCFF(sequence,self.NANODefaultCFF)
        self.scheduleSequence(sequence.split('.')[-1],'nanoAOD_step')
        custom = "nanoAOD_customizeData" if self._options.isData else "nanoAOD_customizeMC"
        self._options.customisation_file.insert(0,"PhysicsTools/NanoAOD/nano_cff."+custom)
        if self._options.hltProcess:
            if len(self._options.customise_commands) > 1:
                self._options.customise_commands = self._options.customise_commands + " \n"
            self._options.customise_commands = self._options.customise_commands + "process.unpackedPatTrigger.triggerResults= cms.InputTag( 'TriggerResults::"+self._options.hltProcess+"' )\n"
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_PATGEN().

prepare_NANOGEN()

def ConfigBuilder.ConfigBuilder.prepare_NANOGEN	(		self,
			sequence = "nanoAOD"
	)

Enrich the schedule with NANOGEN 

Definition at line 1716 of file ConfigBuilder.py.

    def prepare_NANOGEN(self, sequence = "nanoAOD"):
        ''' Enrich the schedule with NANOGEN '''
        # TODO: Need to modify this based on the input file type
        fromGen = any([x in self.stepMap for x in ['LHE', 'GEN', 'AOD']])
        self.loadDefaultOrSpecifiedCFF(sequence,self.NANOGENDefaultCFF)
        self.scheduleSequence(sequence.split('.')[-1],'nanoAOD_step')
        custom = "customizeNanoGEN" if fromGen else "customizeNanoGENFromMini"
        if self._options.runUnscheduled:
            self._options.customisation_file_unsch.insert(0, '.'.join([self.NANOGENDefaultCFF, custom]))
        else:
            self._options.customisation_file.insert(0, '.'.join([self.NANOGENDefaultCFF, custom]))
 

References ConfigBuilder.ConfigBuilder._options, any(), join(), ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.NANOGENDefaultCFF, ConfigBuilder.ConfigBuilder.prepare_EI(), ConfigBuilder.ConfigBuilder.scheduleSequence(), and ConfigBuilder.ConfigBuilder.stepMap.

Referenced by ConfigBuilder.ConfigBuilder.prepare_NANO().

prepare_PAT()

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

Enrich the schedule with PAT 

Definition at line 1673 of file ConfigBuilder.py.

    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 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")
 
        if self._options.hltProcess:
            if len(self._options.customise_commands) > 1:
                self._options.customise_commands = self._options.customise_commands + " \n"
            self._options.customise_commands = self._options.customise_commands + "process.patTrigger.processName = \""+self._options.hltProcess+"\"\n"
            self._options.customise_commands = self._options.customise_commands + "process.slimmedPatTrigger.triggerResults= cms.InputTag( 'TriggerResults::"+self._options.hltProcess+"' )\n"
            self._options.customise_commands = self._options.customise_commands + "process.patMuons.triggerResults= cms.InputTag( 'TriggerResults::"+self._options.hltProcess+"' )\n"
 
#            self.renameHLTprocessInSequence(sequence)
 
        return
 

References ConfigBuilder.ConfigBuilder._options, mps_setup.append, ConfigBuilder.ConfigBuilder.labelsToAssociate, ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.PATDefaultCFF, ConfigBuilder.ConfigBuilder.prepare_PATFILTER(), and ConfigBuilder.ConfigBuilder.prepare_PATGEN().

Referenced by ConfigBuilder.ConfigBuilder.prepare_RECOBEFMIX().

prepare_PATFILTER()

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

Definition at line 1595 of file ConfigBuilder.py.

    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))
 

References mps_setup.append, ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.prepare_L1HwVal(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, and ConfigBuilder.ConfigBuilder.schedule.

Referenced by ConfigBuilder.ConfigBuilder.prepare_PAT(), and ConfigBuilder.ConfigBuilder.prepare_RAW2DIGI().

prepare_PATGEN()

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

Enrich the schedule with PATGEN 

Definition at line 1697 of file ConfigBuilder.py.

    def prepare_PATGEN(self, sequence = "miniGEN"):
        ''' Enrich the schedule with PATGEN '''
        self.loadDefaultOrSpecifiedCFF(sequence,self.PATGENDefaultCFF) #this is unscheduled
        self.labelsToAssociate.append('patGENTask')
        if self._options.isData:
            raise Exception("PATGEN step can only run on MC")
        return
 

References ConfigBuilder.ConfigBuilder._options, mps_setup.append, ConfigBuilder.ConfigBuilder.labelsToAssociate, ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.PATGENDefaultCFF, and ConfigBuilder.ConfigBuilder.prepare_NANO().

Referenced by ConfigBuilder.ConfigBuilder.prepare_PAT().

prepare_POSTRECO()

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

Enrich the schedule with the postreco step 

Definition at line 1790 of file ConfigBuilder.py.

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

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_USER().

prepare_RAW2DIGI()

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

Definition at line 1588 of file ConfigBuilder.py.

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

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_RAW2RECO().

prepare_RAW2RECO()

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

Definition at line 1577 of file ConfigBuilder.py.

    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
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_HLT().

prepare_RECO()

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

Enrich the schedule with reconstruction 

Definition at line 1652 of file ConfigBuilder.py.

    def prepare_RECO(self, sequence = "reconstruction"):
        ''' Enrich the schedule with reconstruction '''
        self.loadDefaultOrSpecifiedCFF(sequence,self.RECODefaultCFF)
        self.scheduleSequence(sequence.split('.')[-1],'reconstruction_step')
        return
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_RAW2RECO().

prepare_RECOBEFMIX()

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 1664 of file ConfigBuilder.py.

    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
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.prepare_PAT(), print(), ConfigBuilder.ConfigBuilder.RECOBEFMIXDefaultCFF, ConfigBuilder.ConfigBuilder.RECOBEFMIXDefaultSeq, and ConfigBuilder.ConfigBuilder.scheduleSequence().

Referenced by ConfigBuilder.ConfigBuilder.prepare_RECOSIM().

prepare_RECOSIM()

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

Enrich the schedule with reconstruction 

Definition at line 1658 of file ConfigBuilder.py.

    def prepare_RECOSIM(self, sequence = "recosim"):
        ''' Enrich the schedule with reconstruction '''
        self.loadDefaultOrSpecifiedCFF(sequence,self.RECOSIMDefaultCFF)
        self.scheduleSequence(sequence.split('.')[-1],'recosim_step')
        return
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_RECO().

prepare_REPACK()

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

Definition at line 1497 of file ConfigBuilder.py.

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

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_DIGI2RAW().

prepare_SIM()

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

Enrich the schedule with the simulation step

Definition at line 1432 of file ConfigBuilder.py.

    def prepare_SIM(self, sequence = None):
        """ Enrich the schedule with the simulation step"""
        self.loadDefaultOrSpecifiedCFF(sequence,self.SIMDefaultCFF)
        if not self._options.fast:
            if self._options.gflash==True:
                self.loadAndRemember("Configuration/StandardSequences/GFlashSIM_cff")
 
            if self._options.magField=='0T':
                self.executeAndRemember("process.g4SimHits.UseMagneticField = cms.bool(False)")
        else:
            if self._options.magField=='0T':
                self.executeAndRemember("process.fastSimProducer.detectorDefinition.magneticFieldZ = cms.untracked.double(0.)")
 
        self.scheduleSequence(sequence.split('.')[-1],'simulation_step')
        return
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.ConfigBuilder.loadAndRemember(), ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.prepare_DIGI(), ConfigBuilder.ConfigBuilder.scheduleSequence(), and ConfigBuilder.ConfigBuilder.SIMDefaultCFF.

Referenced by ConfigBuilder.ConfigBuilder.prepare_GEN().

prepare_SKIM()

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

Enrich the schedule with skimming fragments

Definition at line 1740 of file ConfigBuilder.py.

    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('+')
        
        from Configuration.Skimming.autoSkim import autoSkim
        self.expandMapping(skimlist,autoSkim)
 
        #print "dictionnary for skims:",skimConfig.__dict__
        for skim in skimConfig.__dict__:
            skimstream = getattr(skimConfig,skim)
            if isinstance(skimstream,cms.Path):
            #black list the alca path so that they do not appear in the cfg
                self.blacklist_paths.append(skimstream)
            if (not isinstance(skimstream,cms.FilteredStream)):
                continue
            shortname = skim.replace('SKIMStream','')
            if (sequence=="all"):
                self.addExtraStream(skim,skimstream)
            elif (shortname in skimlist):
                self.addExtraStream(skim,skimstream)
                #add a DQM eventcontent for this guy
                if self._options.datatier=='DQM':
                    self.process.load(self.EVTCONTDefaultCFF)
                    skimstreamDQM = cms.FilteredStream(
                            responsible = skimstream.responsible,
                            name = skimstream.name+'DQM',
                            paths = skimstream.paths,
                            selectEvents = skimstream.selectEvents,
                            content = self._options.datatier+'EventContent',
                            dataTier = cms.untracked.string(self._options.datatier)
                            )
                    self.addExtraStream(skim+'DQM',skimstreamDQM)
                for i in range(skimlist.count(shortname)):
                    skimlist.remove(shortname)
 
 
 
        if (skimlist.__len__()!=0 and sequence!="all"):
            print('WARNING, possible typo with SKIM:'+'+'.join(skimlist))
            raise Exception('WARNING, possible typo with SKIM:'+'+'.join(skimlist))
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.addExtraStream(), mps_setup.append, ConfigBuilder.ConfigBuilder.blacklist_paths, ConfigBuilder.ConfigBuilder.EVTCONTDefaultCFF, ConfigBuilder.ConfigBuilder.expandMapping(), join(), ConfigBuilder.ConfigBuilder.load(), ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.prepare_USER(), print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, FastTimerService_cff.range, and ConfigBuilder.ConfigBuilder.SKIMDefaultCFF.

Referenced by ConfigBuilder.ConfigBuilder.prepare_EI().

prepare_USER()

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

Enrich the schedule with a user defined sequence 

Definition at line 1784 of file ConfigBuilder.py.

    def prepare_USER(self, sequence = None):
        ''' Enrich the schedule with a user defined sequence '''
        self.loadDefaultOrSpecifiedCFF(sequence,self.USERDefaultCFF)
        self.scheduleSequence(sequence.split('.')[-1],'user_step')
        return
 

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_SKIM().

prepare_VALIDATION()

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

Definition at line 1797 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):
            
            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)).insert(0, self.process.genstepfilter)
 
        return
 
 

References ConfigBuilder.ConfigBuilder._options, any(), mps_setup.append, ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.ConfigBuilder.expandMapping(), edm::eventsetup::heterocontainer.insert(), ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), genParticles_cff.map, resolutioncreator_cfi.object, print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, ConfigBuilder.ConfigBuilder.renameHLTprocessInSequence(), ConfigBuilder.ConfigBuilder.schedule, submitPVValidationJobs.split(), ConfigBuilder.ConfigBuilder.stepMap, and ConfigBuilder.ConfigBuilder.VALIDATIONDefaultCFF.

Referenced by ConfigBuilder.ConfigBuilder.prepare_POSTRECO().

profileOptions()

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 272 of file ConfigBuilder.py.

    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___%%I.gz" % (
                self._options.evt_type.replace("_cfi", ""),
                hashlib.md5(
                    str(self._options.step) + str(self._options.pileup) + str(self._options.conditions) +
                    str(self._options.datatier) + str(self._options.profileTypeLabel)
                ).hexdigest()
            )
        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)
 

References ConfigBuilder.ConfigBuilder._options, createfilelist.int, and str.

Referenced by ConfigBuilder.ConfigBuilder.addCommon().

renameHLTprocessInSequence()

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

Definition at line 1937 of file ConfigBuilder.py.

    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))
 
 

References ConfigBuilder.ConfigBuilder._options, ConfigBuilder.ConfigBuilder.additionalCommands, mps_setup.append, ConfigBuilder.ConfigBuilder.expandMapping(), print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, and ConfigBuilder.ConfigBuilder.process.

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

renameInputTagsInSequence()

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

Definition at line 1927 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))
 

References ConfigBuilder.ConfigBuilder.additionalCommands, mps_setup.append, MassReplace.massSearchReplaceAnyInputTag(), print(), DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, and ConfigBuilder.ConfigBuilder.renameHLTprocessInSequence().

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1REPACK().

scheduleSequence()

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

Definition at line 1232 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)
                    tmp = getattr(self.process, s)
                    if isinstance(tmp, cms.Task):
                        p.associate(tmp)
                    else:
                        p+=tmp
            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
 

References mps_setup.append, ConfigBuilder.ConfigBuilder.conditionalPaths, ConfigBuilder.ConfigBuilder.nextScheduleIsConditional, DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, DTTtrigWorkflow.DTttrigWorkflow.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, ConfigBuilder.ConfigBuilder.schedule, and ConfigBuilder.ConfigBuilder.scheduleSequenceAtEnd().

Referenced by ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF(), ConfigBuilder.ConfigBuilder.prepare_CFWRITER(), ConfigBuilder.ConfigBuilder.prepare_DATAMIX(), ConfigBuilder.ConfigBuilder.prepare_DIGI(), ConfigBuilder.ConfigBuilder.prepare_DIGI2RAW(), ConfigBuilder.ConfigBuilder.prepare_EI(), ConfigBuilder.ConfigBuilder.prepare_L1(), ConfigBuilder.ConfigBuilder.prepare_L1Reco(), ConfigBuilder.ConfigBuilder.prepare_L1REPACK(), ConfigBuilder.ConfigBuilder.prepare_L1TrackTrigger(), ConfigBuilder.ConfigBuilder.prepare_NANO(), ConfigBuilder.ConfigBuilder.prepare_NANOGEN(), ConfigBuilder.ConfigBuilder.prepare_POSTRECO(), ConfigBuilder.ConfigBuilder.prepare_RAW2DIGI(), ConfigBuilder.ConfigBuilder.prepare_RECO(), ConfigBuilder.ConfigBuilder.prepare_RECOBEFMIX(), ConfigBuilder.ConfigBuilder.prepare_RECOSIM(), ConfigBuilder.ConfigBuilder.prepare_REPACK(), ConfigBuilder.ConfigBuilder.prepare_SIM(), ConfigBuilder.ConfigBuilder.prepare_USER(), and ConfigBuilder.ConfigBuilder.scheduleSequenceAtEnd().

scheduleSequenceAtEnd()

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

Definition at line 1261 of file ConfigBuilder.py.

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

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_ENDJOB(), ConfigBuilder.ConfigBuilder.prepare_GEN(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

Member Data Documentation

_options

ConfigBuilder.ConfigBuilder._options

private

Definition at line 203 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addCommon(), ConfigBuilder.ConfigBuilder.addConditions(), ConfigBuilder.ConfigBuilder.addCustomise(), ConfigBuilder.ConfigBuilder.addCustomiseCmdLine(), ConfigBuilder.ConfigBuilder.addMaxEvents(), ConfigBuilder.ConfigBuilder.addOutput(), ConfigBuilder.ConfigBuilder.addSource(), ConfigBuilder.ConfigBuilder.addStandardSequences(), ConfigBuilder.ConfigBuilder.completeInputCommand(), ConfigBuilder.ConfigBuilder.define_Configs(), ConfigBuilder.ConfigBuilder.prepare(), ConfigBuilder.ConfigBuilder.prepare_DATAMIX(), ConfigBuilder.ConfigBuilder.prepare_DIGI(), ConfigBuilder.ConfigBuilder.prepare_DQM(), ConfigBuilder.ConfigBuilder.prepare_GEN(), ConfigBuilder.ConfigBuilder.prepare_HARVESTING(), ConfigBuilder.ConfigBuilder.prepare_HLT(), ConfigBuilder.ConfigBuilder.prepare_L1REPACK(), ConfigBuilder.ConfigBuilder.prepare_NANO(), ConfigBuilder.ConfigBuilder.prepare_NANOGEN(), ConfigBuilder.ConfigBuilder.prepare_PAT(), ConfigBuilder.ConfigBuilder.prepare_PATGEN(), ConfigBuilder.ConfigBuilder.prepare_RECOBEFMIX(), ConfigBuilder.ConfigBuilder.prepare_SIM(), ConfigBuilder.ConfigBuilder.prepare_SKIM(), ConfigBuilder.ConfigBuilder.prepare_VALIDATION(), ConfigBuilder.ConfigBuilder.profileOptions(), and ConfigBuilder.ConfigBuilder.renameHLTprocessInSequence().

addedObjects

ConfigBuilder.ConfigBuilder.addedObjects

Definition at line 263 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addCommon(), ConfigBuilder.ConfigBuilder.addMaxEvents(), ConfigBuilder.ConfigBuilder.addSource(), ConfigBuilder.ConfigBuilder.build_production_info(), and ConfigBuilder.ConfigBuilder.prepare().

additionalCommands

ConfigBuilder.ConfigBuilder.additionalCommands

Definition at line 260 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addConditions(), ConfigBuilder.ConfigBuilder.executeAndRemember(), ConfigBuilder.ConfigBuilder.prepare(), ConfigBuilder.ConfigBuilder.prepare_HLT(), ConfigBuilder.ConfigBuilder.renameHLTprocessInSequence(), and ConfigBuilder.ConfigBuilder.renameInputTagsInSequence().

additionalOutputs

ConfigBuilder.ConfigBuilder.additionalOutputs

Definition at line 264 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

ALCADefaultCFF

ConfigBuilder.ConfigBuilder.ALCADefaultCFF

Definition at line 951 of file ConfigBuilder.py.

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

ALCADefaultSeq

ConfigBuilder.ConfigBuilder.ALCADefaultSeq

Definition at line 987 of file ConfigBuilder.py.

ALCAHARVESTDefaultCFF

ConfigBuilder.ConfigBuilder.ALCAHARVESTDefaultCFF

Definition at line 975 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_ALCAHARVEST().

ALCAHARVESTDefaultSeq

ConfigBuilder.ConfigBuilder.ALCAHARVESTDefaultSeq

Definition at line 998 of file ConfigBuilder.py.

AlCaPaths

ConfigBuilder.ConfigBuilder.AlCaPaths

Definition at line 1282 of file ConfigBuilder.py.

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

blacklist_paths

ConfigBuilder.ConfigBuilder.blacklist_paths

Definition at line 262 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare(), ConfigBuilder.ConfigBuilder.prepare_HLT(), and ConfigBuilder.ConfigBuilder.prepare_SKIM().

CFWRITERDefaultCFF

ConfigBuilder.ConfigBuilder.CFWRITERDefaultCFF

Definition at line 978 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_CFWRITER().

CFWRITERDefaultSeq

ConfigBuilder.ConfigBuilder.CFWRITERDefaultSeq

Definition at line 999 of file ConfigBuilder.py.

conditionalPaths

ConfigBuilder.ConfigBuilder.conditionalPaths

Definition at line 269 of file ConfigBuilder.py.

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

ConditionsDefaultCFF

ConfigBuilder.ConfigBuilder.ConditionsDefaultCFF

Definition at line 977 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addConditions().

DATAMIXDefaultCFF

ConfigBuilder.ConfigBuilder.DATAMIXDefaultCFF

Definition at line 982 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_DATAMIX().

DATAMIXDefaultSeq

ConfigBuilder.ConfigBuilder.DATAMIXDefaultSeq

Definition at line 992 of file ConfigBuilder.py.

DIGI2RAWDefaultCFF

ConfigBuilder.ConfigBuilder.DIGI2RAWDefaultCFF

Definition at line 955 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_DIGI2RAW().

DIGI2RAWDefaultSeq

ConfigBuilder.ConfigBuilder.DIGI2RAWDefaultSeq

Definition at line 993 of file ConfigBuilder.py.

DIGIDefaultCFF

ConfigBuilder.ConfigBuilder.DIGIDefaultCFF

Definition at line 954 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_DIGI().

DIGIDefaultSeq

ConfigBuilder.ConfigBuilder.DIGIDefaultSeq

Definition at line 991 of file ConfigBuilder.py.

DQMDefaultSeq

ConfigBuilder.ConfigBuilder.DQMDefaultSeq

Definition at line 1011 of file ConfigBuilder.py.

DQMOFFLINEDefaultCFF

ConfigBuilder.ConfigBuilder.DQMOFFLINEDefaultCFF

Definition at line 973 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_DQM().

DQMSaverCFF

ConfigBuilder.ConfigBuilder.DQMSaverCFF

Definition at line 2015 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_HARVESTING().

EIDefaultCFF

ConfigBuilder.ConfigBuilder.EIDefaultCFF

Definition at line 968 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_EI().

EIDefaultSeq

ConfigBuilder.ConfigBuilder.EIDefaultSeq

Definition at line 1008 of file ConfigBuilder.py.

ENDJOBDefaultCFF

ConfigBuilder.ConfigBuilder.ENDJOBDefaultCFF

Definition at line 976 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_ENDJOB().

ENDJOBDefaultSeq

ConfigBuilder.ConfigBuilder.ENDJOBDefaultSeq

Definition at line 1013 of file ConfigBuilder.py.

EVTCONTDefaultCFF

ConfigBuilder.ConfigBuilder.EVTCONTDefaultCFF

Definition at line 1021 of file ConfigBuilder.py.

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

excludedPaths

ConfigBuilder.ConfigBuilder.excludedPaths

Definition at line 270 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

GENDefaultCFF

ConfigBuilder.ConfigBuilder.GENDefaultCFF

Definition at line 952 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_GEN().

GENDefaultSeq

ConfigBuilder.ConfigBuilder.GENDefaultSeq

Definition at line 989 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_GEN().

GeometryCFF

ConfigBuilder.ConfigBuilder.GeometryCFF

Definition at line 1084 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addStandardSequences().

geometryDBLabel

ConfigBuilder.ConfigBuilder.geometryDBLabel

Definition at line 1085 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addStandardSequences().

HARVESTINGDefaultCFF

ConfigBuilder.ConfigBuilder.HARVESTINGDefaultCFF

Definition at line 974 of file ConfigBuilder.py.

HARVESTINGDefaultSeq

ConfigBuilder.ConfigBuilder.HARVESTINGDefaultSeq

Definition at line 997 of file ConfigBuilder.py.

HLTDefaultCFF

ConfigBuilder.ConfigBuilder.HLTDefaultCFF

Definition at line 958 of file ConfigBuilder.py.

HLTDefaultSeq

ConfigBuilder.ConfigBuilder.HLTDefaultSeq

Definition at line 994 of file ConfigBuilder.py.

imports

ConfigBuilder.ConfigBuilder.imports

Definition at line 251 of file ConfigBuilder.py.

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

inliner

ConfigBuilder.ConfigBuilder.inliner

load the relevant part

needs to be in reverse order

print it in the configuration

Definition at line 1628 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_FILTER().

L1DefaultSeq

ConfigBuilder.ConfigBuilder.L1DefaultSeq

Definition at line 995 of file ConfigBuilder.py.

L1EMDefaultCFF

ConfigBuilder.ConfigBuilder.L1EMDefaultCFF

Definition at line 956 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1().

L1HwValDefaultCFF

ConfigBuilder.ConfigBuilder.L1HwValDefaultCFF

Definition at line 972 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1HwVal().

L1HwValDefaultSeq

ConfigBuilder.ConfigBuilder.L1HwValDefaultSeq

Definition at line 1010 of file ConfigBuilder.py.

L1MENUDefaultCFF

ConfigBuilder.ConfigBuilder.L1MENUDefaultCFF

Definition at line 957 of file ConfigBuilder.py.

L1RecoDefaultCFF

ConfigBuilder.ConfigBuilder.L1RecoDefaultCFF

Definition at line 961 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1Reco().

L1RecoDefaultSeq

ConfigBuilder.ConfigBuilder.L1RecoDefaultSeq

Definition at line 1001 of file ConfigBuilder.py.

L1REPACKDefaultSeq

ConfigBuilder.ConfigBuilder.L1REPACKDefaultSeq

Definition at line 996 of file ConfigBuilder.py.

L1TrackTriggerDefaultCFF

ConfigBuilder.ConfigBuilder.L1TrackTriggerDefaultCFF

Definition at line 962 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1TrackTrigger().

L1TrackTriggerDefaultSeq

ConfigBuilder.ConfigBuilder.L1TrackTriggerDefaultSeq

Definition at line 1002 of file ConfigBuilder.py.

labelsToAssociate

ConfigBuilder.ConfigBuilder.labelsToAssociate

Definition at line 267 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare(), ConfigBuilder.ConfigBuilder.prepare_PAT(), and ConfigBuilder.ConfigBuilder.prepare_PATGEN().

LHEDefaultSeq

ConfigBuilder.ConfigBuilder.LHEDefaultSeq

Definition at line 988 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_GEN().

magFieldCFF

ConfigBuilder.ConfigBuilder.magFieldCFF

Definition at line 1080 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addStandardSequences().

NANODefaultCFF

ConfigBuilder.ConfigBuilder.NANODefaultCFF

Definition at line 966 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_NANO().

NANODefaultSeq

ConfigBuilder.ConfigBuilder.NANODefaultSeq

Definition at line 1019 of file ConfigBuilder.py.

NANOGENDefaultCFF

ConfigBuilder.ConfigBuilder.NANOGENDefaultCFF

Definition at line 967 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_NANOGEN().

NANOGENDefaultSeq

ConfigBuilder.ConfigBuilder.NANOGENDefaultSeq

Definition at line 1018 of file ConfigBuilder.py.

nextScheduleIsConditional

ConfigBuilder.ConfigBuilder.nextScheduleIsConditional

put the filtering path in the schedule

Definition at line 268 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.scheduleSequence().

PATDefaultCFF

ConfigBuilder.ConfigBuilder.PATDefaultCFF

Definition at line 965 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_PAT().

PATDefaultSeq

ConfigBuilder.ConfigBuilder.PATDefaultSeq

Definition at line 1015 of file ConfigBuilder.py.

PATGENDefaultCFF

ConfigBuilder.ConfigBuilder.PATGENDefaultCFF

Definition at line 1031 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_PATGEN().

PATGENDefaultSeq

ConfigBuilder.ConfigBuilder.PATGENDefaultSeq

Definition at line 1016 of file ConfigBuilder.py.

POSTRECODefaultCFF

ConfigBuilder.ConfigBuilder.POSTRECODefaultCFF

Definition at line 970 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_POSTRECO().

POSTRECODefaultSeq

ConfigBuilder.ConfigBuilder.POSTRECODefaultSeq

Definition at line 1009 of file ConfigBuilder.py.

process

ConfigBuilder.ConfigBuilder.process

adding standard sequences might change the inputEventContent option and therefore needs to be finalized after

Definition at line 246 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addCommon(), ConfigBuilder.ConfigBuilder.addConditions(), ConfigBuilder.ConfigBuilder.addCustomise(), ConfigBuilder.ConfigBuilder.addMaxEvents(), ConfigBuilder.ConfigBuilder.addOutput(), ConfigBuilder.ConfigBuilder.addSource(), ConfigBuilder.ConfigBuilder.addStandardSequences(), ConfigBuilder.ConfigBuilder.build_production_info(), ConfigBuilder.ConfigBuilder.completeInputCommand(), ConfigBuilder.ConfigBuilder.finalizeFastSimHLT(), ConfigBuilder.ConfigBuilder.load(), ConfigBuilder.ConfigBuilder.loadAndRemember(), runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017(), ConfigBuilder.ConfigBuilder.prepare(), ConfigBuilder.ConfigBuilder.prepare_DIGI(), ConfigBuilder.ConfigBuilder.prepare_DQM(), ConfigBuilder.ConfigBuilder.prepare_GEN(), ConfigBuilder.ConfigBuilder.prepare_HLT(), ConfigBuilder.ConfigBuilder.prepare_PATFILTER(), ConfigBuilder.ConfigBuilder.prepare_SKIM(), ConfigBuilder.ConfigBuilder.prepare_VALIDATION(), runTauIdMVA.TauIDEmbedder.processDeepProducer(), ConfigBuilder.ConfigBuilder.renameHLTprocessInSequence(), ConfigBuilder.ConfigBuilder.renameInputTagsInSequence(), runTauIdMVA.TauIDEmbedder.runTauID(), ConfigBuilder.ConfigBuilder.scheduleSequence(), and runTauIdMVA.TauIDEmbedder.tauIDMVAinputs().

productionFilterSequence

ConfigBuilder.ConfigBuilder.productionFilterSequence

put it before all the other paths

Definition at line 266 of file ConfigBuilder.py.

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

pythonCfgCode

ConfigBuilder.ConfigBuilder.pythonCfgCode

Definition at line 2108 of file ConfigBuilder.py.

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

RAW2DIGIDefaultCFF

ConfigBuilder.ConfigBuilder.RAW2DIGIDefaultCFF

Definition at line 959 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_RAW2DIGI().

RAW2DIGIDefaultSeq

ConfigBuilder.ConfigBuilder.RAW2DIGIDefaultSeq

Definition at line 1000 of file ConfigBuilder.py.

RAW2RECODefaultSeq

ConfigBuilder.ConfigBuilder.RAW2RECODefaultSeq

Definition at line 1074 of file ConfigBuilder.py.

RECOBEFMIXDefaultCFF

ConfigBuilder.ConfigBuilder.RECOBEFMIXDefaultCFF

Definition at line 1135 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_RECOBEFMIX().

RECOBEFMIXDefaultSeq

ConfigBuilder.ConfigBuilder.RECOBEFMIXDefaultSeq

Definition at line 1136 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_RECOBEFMIX().

RECODefaultCFF

ConfigBuilder.ConfigBuilder.RECODefaultCFF

Definition at line 963 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_RECO().

RECODefaultSeq

ConfigBuilder.ConfigBuilder.RECODefaultSeq

Definition at line 1004 of file ConfigBuilder.py.

RECOSIMDefaultCFF

ConfigBuilder.ConfigBuilder.RECOSIMDefaultCFF

Definition at line 964 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_RECOSIM().

RECOSIMDefaultSeq

ConfigBuilder.ConfigBuilder.RECOSIMDefaultSeq

Definition at line 1007 of file ConfigBuilder.py.

REDIGIDefaultSeq

ConfigBuilder.ConfigBuilder.REDIGIDefaultSeq

Definition at line 1151 of file ConfigBuilder.py.

REPACKDefaultCFF

ConfigBuilder.ConfigBuilder.REPACKDefaultCFF

Definition at line 979 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_REPACK().

REPACKDefaultSeq

ConfigBuilder.ConfigBuilder.REPACKDefaultSeq

Definition at line 1014 of file ConfigBuilder.py.

runsAndWeights

ConfigBuilder.ConfigBuilder.runsAndWeights

drop LHEXMLStringProduct on input to save memory if appropriate

Definition at line 480 of file ConfigBuilder.py.

runsAndWeightsInt

ConfigBuilder.ConfigBuilder.runsAndWeightsInt

Definition at line 501 of file ConfigBuilder.py.

schedule

ConfigBuilder.ConfigBuilder.schedule

Definition at line 254 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addOutput(), Config.Process.dumpConfig(), Config.Process.dumpPython(), ConfigBuilder.ConfigBuilder.finalizeFastSimHLT(), ConfigBuilder.ConfigBuilder.prepare(), ConfigBuilder.ConfigBuilder.prepare_ALCAHARVEST(), ConfigBuilder.ConfigBuilder.prepare_DQM(), ConfigBuilder.ConfigBuilder.prepare_GEN(), ConfigBuilder.ConfigBuilder.prepare_HLT(), ConfigBuilder.ConfigBuilder.prepare_PATFILTER(), ConfigBuilder.ConfigBuilder.prepare_VALIDATION(), ConfigBuilder.ConfigBuilder.scheduleSequence(), and Config.Process.splitPython().

SIMDefaultCFF

ConfigBuilder.ConfigBuilder.SIMDefaultCFF

Definition at line 953 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_SIM().

SIMDefaultSeq

ConfigBuilder.ConfigBuilder.SIMDefaultSeq

Definition at line 990 of file ConfigBuilder.py.

SimGeometryCFF

ConfigBuilder.ConfigBuilder.SimGeometryCFF

Definition at line 1110 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addStandardSequences().

SKIMDefaultCFF

ConfigBuilder.ConfigBuilder.SKIMDefaultCFF

Definition at line 969 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_SKIM().

stepKeys

ConfigBuilder.ConfigBuilder.stepKeys

Definition at line 226 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addStandardSequences().

stepMap

ConfigBuilder.ConfigBuilder.stepMap

Definition at line 225 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.addCommon(), ConfigBuilder.ConfigBuilder.addSource(), ConfigBuilder.ConfigBuilder.addStandardSequences(), ConfigBuilder.ConfigBuilder.define_Configs(), ConfigBuilder.ConfigBuilder.prepare(), ConfigBuilder.ConfigBuilder.prepare_DQM(), ConfigBuilder.ConfigBuilder.prepare_GEN(), ConfigBuilder.ConfigBuilder.prepare_NANOGEN(), and ConfigBuilder.ConfigBuilder.prepare_VALIDATION().

USERDefaultCFF

ConfigBuilder.ConfigBuilder.USERDefaultCFF

Definition at line 1077 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_USER().

USERDefaultSeq

ConfigBuilder.ConfigBuilder.USERDefaultSeq

Definition at line 1076 of file ConfigBuilder.py.

VALIDATIONDefaultCFF

ConfigBuilder.ConfigBuilder.VALIDATIONDefaultCFF

Definition at line 971 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_VALIDATION().

VALIDATIONDefaultSeq

ConfigBuilder.ConfigBuilder.VALIDATIONDefaultSeq

Definition at line 1012 of file ConfigBuilder.py.

with_input

ConfigBuilder.ConfigBuilder.with_input

Definition at line 250 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

with_output

ConfigBuilder.ConfigBuilder.with_output

Definition at line 245 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().