Inheritance diagram for ConfigBuilder.ConfigBuilder:

Classes
class	MassSearchReplaceProcessNameVisitor

class	PrintAllModules
	load the relevant part More...

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

def	addCommon (self)

def	addConditions (self)

def	addCustomise (self, unsch=0)

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

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

def	addMaxEvents (self)

def	addOutput (self)

def	addSource (self)

def	addStandardSequences (self)

def	build_production_info (self, evt_type, evtnumber)

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

def	define_Configs (self)

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

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

def	executeAndRemember (self, command)

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

def	filesFromOption (self)

def	finalizeFastSimHLT (self)

def	inGeometryKeys (opt)

def	load (self, includeFile)

def	loadAndRemember (self, includeFile)

def	loadDefaultOrSpecifiedCFF (self, sequence, defaultCFF)

def	prepare (self, doChecking=False)

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

def	prepare_ALCAHARVEST (self, sequence=None)

def	prepare_ALCAOUTPUT (self, sequence=None)

def	prepare_ALCAPRODUCER (self, sequence=None)

def	prepare_CFWRITER (self, sequence=None)

def	prepare_DATAMIX (self, sequence=None)

def	prepare_DIGI (self, sequence=None)

def	prepare_DIGI2RAW (self, sequence=None)

def	prepare_DIGIPREMIX (self, sequence=None)

def	prepare_DIGIPREMIX_S2 (self, sequence=None)

def	prepare_DQM (self, sequence='DQMOffline')

def	prepare_EI (self, sequence=None)

def	prepare_ENDJOB (self, sequence='endOfProcess')

def	prepare_FILTER (self, sequence=None)

def	prepare_GEN (self, sequence=None)

def	prepare_HARVESTING (self, sequence=None)

def	prepare_HLT (self, sequence=None)

def	prepare_L1 (self, sequence=None)

def	prepare_L1HwVal (self, sequence='L1HwVal')

def	prepare_L1Reco (self, sequence="L1Reco")

def	prepare_L1REPACK (self, sequence=None)

def	prepare_L1TrackTrigger (self, sequence="L1TrackTrigger")

def	prepare_LHE (self, sequence=None)

def	prepare_PAT (self, sequence="miniAOD")

def	prepare_PATFILTER (self, sequence=None)

def	prepare_PATGEN (self, sequence="miniGEN")

def	prepare_POSTRECO (self, sequence=None)

def	prepare_RAW2DIGI (self, sequence="RawToDigi")

def	prepare_RAW2RECO (self, sequence=None)

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

def	prepare_RECOBEFMIX (self, sequence="reconstruction")

def	prepare_REPACK (self, sequence=None)

def	prepare_SIM (self, sequence=None)

def	prepare_SKIM (self, sequence="all")

def	prepare_USER (self, sequence=None)

def	prepare_VALIDATION (self, sequence='validation')

def	profileOptions (self)

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

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

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

def	scheduleSequenceAtEnd (self, seq, prefix)

Public Attributes
	ALCADefaultCFF

	DIGI2RAWDefaultCFF

	DIGIDefaultCFF

	DQMSaverCFF

	GENDefaultCFF

	HLTDefaultCFF

	L1EMDefaultCFF

	L1MENUDefaultCFF

	L1RecoDefaultCFF

	L1TrackTriggerDefaultCFF

	PATDefaultCFF

	RAW2DIGIDefaultCFF

	RECODefaultCFF

	SIMDefaultCFF

Private Attributes
	_options

Detailed Description

The main building routines

Definition at line 189 of file ConfigBuilder.py.

Constructor & Destructor Documentation

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

options taken from old cmsDriver and optparse

Definition at line 192 of file ConfigBuilder.py.

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

Member Function Documentation

def ConfigBuilder.ConfigBuilder.addCommon ( self )

Definition at line 333 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.profileOptions().

Referenced by ConfigBuilder.ConfigBuilder.prepare().

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

def ConfigBuilder.ConfigBuilder.addConditions ( self )

Add conditions to the process

Definition at line 795 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

795 def addConditions(self):

796 """Add conditions to the process"""

ConfigBuilder.ConfigBuilder.addConditions

def addConditions(self)

Definition: ConfigBuilder.py:795

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

Include the customise code

Definition at line 810 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

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

def ConfigBuilder.ConfigBuilder.addCustomiseCmdLine ( self )

now for a useful command

Definition at line 883 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.executeAndRemember().

Referenced by ConfigBuilder.ConfigBuilder.prepare().

883 def addCustomiseCmdLine(self):

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

ConfigBuilder.ConfigBuilder.addCustomiseCmdLine

def addCustomiseCmdLine(self)

now for a useful command

Definition: ConfigBuilder.py:883

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

Definition at line 1119 of file ConfigBuilder.py.

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

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

def ConfigBuilder.ConfigBuilder.addMaxEvents ( self )

Here we decide how many evts will be processed

Definition at line 362 of file ConfigBuilder.py.

References createfilelist.int.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

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

def ConfigBuilder.ConfigBuilder.addOutput ( self )

Add output module to the process

Definition at line 497 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

497 def addOutput(self):

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

ConfigBuilder.ConfigBuilder.addOutput

def addOutput(self)

Definition: ConfigBuilder.py:497

def ConfigBuilder.ConfigBuilder.addSource ( self )

Here the source is built. Priority: file, generator

Definition at line 369 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

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

def ConfigBuilder.ConfigBuilder.addStandardSequences ( self )

Add selected standard sequences to the process

Definition at line 669 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

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

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

Add useful info for the production.

Definition at line 2045 of file ConfigBuilder.py.

References harvestTrackValidationPlots.str.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

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

def ConfigBuilder.ConfigBuilder.completeInputCommand ( self )

add the corresponding input content

Definition at line 764 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare().

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

def ConfigBuilder.ConfigBuilder.define_Configs ( self )

Definition at line 898 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadAndRemember().

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

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

event content

Definition at line 589 of file ConfigBuilder.py.

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

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

590 return label

ConfigBuilder.ConfigBuilder.doNotInlineEventContent

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

event content

Definition: ConfigBuilder.py:589

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

Definition at line 661 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.doNotInlineEventContent().

661 def doNotInlineEventContent(instance,label = "process."+streamType+"EventContent.outputCommands"):

662 return label

ConfigBuilder.ConfigBuilder.doNotInlineEventContent

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

event content

Definition: ConfigBuilder.py:589

def ConfigBuilder.ConfigBuilder.executeAndRemember	(	self,
		command
	)

helper routine to remember replace statements

Definition at line 324 of file ConfigBuilder.py.

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

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

Definition at line 1913 of file ConfigBuilder.py.

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

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

def ConfigBuilder.ConfigBuilder.filesFromOption ( self )

Definition at line 373 of file ConfigBuilder.py.

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

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

def ConfigBuilder.ConfigBuilder.finalizeFastSimHLT ( self )

Definition at line 2040 of file ConfigBuilder.py.

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

def ConfigBuilder.ConfigBuilder.inGeometryKeys ( opt )

Definition at line 1059 of file ConfigBuilder.py.

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

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

def ConfigBuilder.ConfigBuilder.load	(	self,
		includeFile
	)

Definition at line 310 of file ConfigBuilder.py.

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

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

def ConfigBuilder.ConfigBuilder.loadAndRemember	(	self,
		includeFile
	)

helper routine to load am memorize imports

Definition at line 315 of file ConfigBuilder.py.

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

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

Definition at line 1184 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadAndRemember().

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

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

Prepare the configuration string and add missing pieces.

Definition at line 2056 of file ConfigBuilder.py.

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

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

Enrich the process with alca streams

Definition at line 1231 of file ConfigBuilder.py.

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

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

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

Enrich the process with AlCaHarvesting step

Definition at line 2005 of file ConfigBuilder.py.

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

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

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

Definition at line 1228 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.prepare_ALCA().

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

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

Definition at line 1225 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.prepare_ALCA().

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

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

Enrich the schedule with the crossing frame writer step

Definition at line 1453 of file ConfigBuilder.py.

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

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

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

Enrich the schedule with the digitisation step

Definition at line 1459 of file ConfigBuilder.py.

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

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

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

Enrich the schedule with the digitisation step

Definition at line 1404 of file ConfigBuilder.py.

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

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

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

Definition at line 1477 of file ConfigBuilder.py.

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

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

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

Enrich the schedule with the digitisation step

Definition at line 1424 of file ConfigBuilder.py.

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

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

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

Enrich the schedule with the digitisation step

Definition at line 1438 of file ConfigBuilder.py.

1438 def prepare_DIGIPREMIX_S2(self, sequence = None):

1439 """ Enrich the schedule with the digitisation step"""

ConfigBuilder.ConfigBuilder.prepare_DIGIPREMIX_S2

def prepare_DIGIPREMIX_S2(self, sequence=None)

Definition: ConfigBuilder.py:1438

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

Definition at line 1932 of file ConfigBuilder.py.

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

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

Enrich the schedule with event interpretation

Definition at line 1690 of file ConfigBuilder.py.

1690 def prepare_EI(self, sequence = None):

1691 ''' Enrich the schedule with event interpretation '''

ConfigBuilder.ConfigBuilder.prepare_EI

def prepare_EI(self, sequence=None)

Definition: ConfigBuilder.py:1690

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

Definition at line 2035 of file ConfigBuilder.py.

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

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

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

Enrich the schedule with a user defined filter sequence

Definition at line 1609 of file ConfigBuilder.py.

1609 def prepare_FILTER(self, sequence = None):

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

ConfigBuilder.ConfigBuilder.prepare_FILTER

def prepare_FILTER(self, sequence=None)

Definition: ConfigBuilder.py:1609

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

load the fragment of generator configuration

Definition at line 1306 of file ConfigBuilder.py.

1306 def prepare_GEN(self, sequence = None):

1307 """ load the fragment of generator configuration """

ConfigBuilder.ConfigBuilder.prepare_GEN

def prepare_GEN(self, sequence=None)

Definition: ConfigBuilder.py:1306

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

Enrich the process with harvesting step

Definition at line 1969 of file ConfigBuilder.py.

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

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

Enrich the schedule with the HLT simulation step

Definition at line 1511 of file ConfigBuilder.py.

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

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

Enrich the schedule with the L1 simulation step

Definition at line 1491 of file ConfigBuilder.py.

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

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

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

Enrich the schedule with L1 HW validation

Definition at line 1590 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF().

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

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

Enrich the schedule with L1 reconstruction

Definition at line 1597 of file ConfigBuilder.py.

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

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

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

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

Definition at line 1498 of file ConfigBuilder.py.

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

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

Enrich the schedule with L1 reconstruction

Definition at line 1603 of file ConfigBuilder.py.

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

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

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

Definition at line 1289 of file ConfigBuilder.py.

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

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

Enrich the schedule with PAT

Definition at line 1656 of file ConfigBuilder.py.

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

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

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

Definition at line 1584 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_PAT().

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

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

Enrich the schedule with PATGEN

Definition at line 1680 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.loadDefaultOrSpecifiedCFF().

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

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

Enrich the schedule with the postreco step

Definition at line 1752 of file ConfigBuilder.py.

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

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

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

Definition at line 1577 of file ConfigBuilder.py.

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_RAW2RECO().

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

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

Definition at line 1566 of file ConfigBuilder.py.

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

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

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

put the filtering path in the schedule

put it before all the other paths

Enrich the schedule with reconstruction

Definition at line 1641 of file ConfigBuilder.py.

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

Referenced by ConfigBuilder.ConfigBuilder.prepare_RAW2RECO().

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

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

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

Definition at line 1647 of file ConfigBuilder.py.

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

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

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

Definition at line 1486 of file ConfigBuilder.py.

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

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

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

Enrich the schedule with the summary of the filter step

Enrich the schedule with the simulation step

Definition at line 1388 of file ConfigBuilder.py.

1388 def prepare_SIM(self, sequence = None):

1389 """ Enrich the schedule with the simulation step"""

ConfigBuilder.ConfigBuilder.prepare_SIM

def prepare_SIM(self, sequence=None)

Definition: ConfigBuilder.py:1388

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

Enrich the schedule with skimming fragments

Definition at line 1702 of file ConfigBuilder.py.

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

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

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

Enrich the schedule with a user defined sequence

Definition at line 1746 of file ConfigBuilder.py.

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

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

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

Definition at line 1759 of file ConfigBuilder.py.

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

def ConfigBuilder.ConfigBuilder.profileOptions ( self )

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

Definition at line 267 of file ConfigBuilder.py.

References createfilelist.int.

Referenced by ConfigBuilder.ConfigBuilder.addCommon().

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

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

Definition at line 1899 of file ConfigBuilder.py.

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

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

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

Definition at line 1889 of file ConfigBuilder.py.

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

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

Definition at line 1196 of file ConfigBuilder.py.

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

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

Definition at line 1221 of file ConfigBuilder.py.

References ConfigBuilder.ConfigBuilder.scheduleSequence().

Referenced by ConfigBuilder.ConfigBuilder.prepare_ENDJOB().

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

Member Data Documentation

ConfigBuilder.ConfigBuilder._options

private

Definition at line 197 of file ConfigBuilder.py.

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

ConfigBuilder.ConfigBuilder.ALCADefaultCFF

Definition at line 911 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_ALCA().

ConfigBuilder.ConfigBuilder.DIGI2RAWDefaultCFF

Definition at line 915 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_DIGI2RAW().

ConfigBuilder.ConfigBuilder.DIGIDefaultCFF

Definition at line 914 of file ConfigBuilder.py.

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

ConfigBuilder.ConfigBuilder.DQMSaverCFF

Definition at line 1971 of file ConfigBuilder.py.

ConfigBuilder.ConfigBuilder.GENDefaultCFF

Definition at line 912 of file ConfigBuilder.py.

ConfigBuilder.ConfigBuilder.HLTDefaultCFF

Definition at line 918 of file ConfigBuilder.py.

ConfigBuilder.ConfigBuilder.L1EMDefaultCFF

Definition at line 916 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1().

ConfigBuilder.ConfigBuilder.L1MENUDefaultCFF

Definition at line 917 of file ConfigBuilder.py.

ConfigBuilder.ConfigBuilder.L1RecoDefaultCFF

Definition at line 920 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1Reco().

ConfigBuilder.ConfigBuilder.L1TrackTriggerDefaultCFF

Definition at line 921 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_L1TrackTrigger().

ConfigBuilder.ConfigBuilder.PATDefaultCFF

Definition at line 923 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_PAT().

ConfigBuilder.ConfigBuilder.RAW2DIGIDefaultCFF

Definition at line 919 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.prepare_RAW2DIGI().

ConfigBuilder.ConfigBuilder.RECODefaultCFF

Definition at line 922 of file ConfigBuilder.py.

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

ConfigBuilder.ConfigBuilder.SIMDefaultCFF

Definition at line 913 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.inGeometryKeys().

Classes

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation