ConfigBuilder.ConfigBuilder Class Reference

Inheritance diagram for ConfigBuilder.ConfigBuilder:

Classes
class	MassSearchReplaceProcessNameVisitor
class	PrintAllModules
	print it in the configuration More...

Public Member Functions
def	__init__
def	__init__
def	addCommon
def	addCommon
def	addConditions
def	addConditions
def	addCustomise
def	addCustomise
def	addExtraStream
def	addExtraStream
def	addMaxEvents
def	addMaxEvents
def	addOutput
def	addOutput
def	addSource
def	addSource
def	addStandardSequences
def	addStandardSequences
def	anyOf
def	build_production_info
def	build_production_info
def	completeInputCommand
def	completeInputCommand
def	define_Configs
def	define_Configs
def	doNotInlineEventContent
def	doNotInlineEventContent
def	doNotInlineEventContent
def	doNotInlineEventContent
def	executeAndRemember
def	executeAndRemember
def	expandMapping
def	expandMapping
def	filesFromOption
def	filesFromOption
def	finalizeFastSimHLT
def	finalizeFastSimHLT
def	inGeometryKeys
def	inGeometryKeys
def	load
def	load
def	loadAndRemember
def	loadAndRemember
def	loadDefaultOrSpecifiedCFF
def	loadDefaultOrSpecifiedCFF
def	prepare
def	prepare
def	prepare_ALCA
def	prepare_ALCA
def	prepare_ALCAHARVEST
def	prepare_ALCAHARVEST
def	prepare_ALCAOUTPUT
def	prepare_ALCAOUTPUT
def	prepare_ALCAPRODUCER
def	prepare_ALCAPRODUCER
def	prepare_CFWRITER
def	prepare_CFWRITER
def	prepare_DATAMIX
def	prepare_DATAMIX
def	prepare_DIGI
def	prepare_DIGI
def	prepare_DIGI2RAW
def	prepare_DIGI2RAW
def	prepare_DIGIPREMIX
def	prepare_DIGIPREMIX
def	prepare_DIGIPREMIX_S2
def	prepare_DIGIPREMIX_S2
def	prepare_DQM
def	prepare_DQM
def	prepare_EI
def	prepare_EI
def	prepare_ENDJOB
def	prepare_ENDJOB
def	prepare_FASTSIM
def	prepare_FASTSIM
def	prepare_FILTER
def	prepare_FILTER
def	prepare_GEN
def	prepare_GEN
def	prepare_HARVESTING
def	prepare_HARVESTING
def	prepare_HLT
def	prepare_HLT
def	prepare_L1
def	prepare_L1
def	prepare_L1HwVal
def	prepare_L1HwVal
def	prepare_L1Reco
def	prepare_L1Reco
def	prepare_L1REPACK
def	prepare_L1REPACK
def	prepare_L1TrackTrigger
def	prepare_L1TrackTrigger
def	prepare_LHE
def	prepare_LHE
def	prepare_PAT
def	prepare_PAT
def	prepare_POSTRECO
def	prepare_POSTRECO
def	prepare_RAW2DIGI
def	prepare_RAW2DIGI
def	prepare_RAW2RECO
def	prepare_RAW2RECO
def	prepare_RECO
	put the filtering path in the schedule More...
def	prepare_RECO
	put the filtering path in the schedule More...
def	prepare_REPACK
def	prepare_REPACK
def	prepare_SIM
def	prepare_SIM
def	prepare_SKIM
def	prepare_SKIM
def	prepare_USER
def	prepare_USER
def	prepare_VALIDATION
def	prepare_VALIDATION
def	profileOptions
def	profileOptions
def	renameHLTprocessInSequence
def	renameHLTprocessInSequence
def	renameInputTagsInSequence
def	renameInputTagsInSequence
def	scheduleSequence
def	scheduleSequence
def	scheduleSequenceAtEnd
def	scheduleSequenceAtEnd

Public Attributes
	ALCADefaultCFF
	DIGI2RAWDefaultCFF
	DIGIDefaultCFF
	EDMtoMECFF
	GENDefaultCFF
	HLTDefaultCFF
	L1EMDefaultCFF
	L1MENUDefaultCFF
	L1RecoDefaultCFF
	L1TrackTriggerDefaultCFF
	PATDefaultCFF
	RAW2DIGIDefaultCFF
	RECODefaultCFF
	SIMDefaultCFF

Static Public Attributes
list	afterHLT = self.schedule[self.schedule.index(self.process.HLTSchedule)+1:]
tuple	alcastream = getattr(alcaConfig,name)
list	allFcn = []
list	available = []
string	beamspotName = 'process.%sVtxSmearingParameters'
string	beamspotType = 'Flat'
list	beforeHLT = self.schedule[:self.schedule.index(self.process.HLTSchedule)]
list	cffToBeLoaded = VtxSmeared[self._options.beamspot]
tuple	com = string.lstrip(com)
tuple	combined_mapping = copy.deepcopy( autoDQM )
tuple	command = command.strip()
string	CppType = 'PoolOutputModule'
dictionary	custMap = {}
tuple	custMap = DictTypes.SortedKeysDict()
tuple	customiseFile = re.sub(r'\.pyc$', '.py', package.__file__)
	defaultFileName = self._options.outfile_name
tuple	defaultFileName = self._options.outfile_name.replace('.root','_in'+theTier+'.root')
tuple	fileName = opt.split('.')
tuple	filterConfig = self.load(sequence.split('.')[0])
	load the relevant part More...
tuple	filterSeq = sequence.split('.')
string	final_snippet = '\n'
	GEN_mixing = False
list	generatorModule = sys.modules[loadFragment]
	genModules = generatorModule.__dict__
tuple	genSeqName = sequence.split('.')
tuple	harvestingConfig = self.loadDefaultOrSpecifiedCFF(sequence,self.HARVESTINGDefaultCFF)
tuple	harvestingList = sequence.split("+")
tuple	harvestingstream = getattr(harvestingConfig,name)
tuple	io = open(self._options.io,'w')
dictionary	ioJson = {}
tuple	lastStep = getattr(harvestingConfig,"ALCAHARVESTDQMSaveAndMetadataWriter")
	loadFailure = True
tuple	loadFragment = self._options.evt_type.replace('.py','',)
string	loadFragment = 'Configuration.Generator.'
string	message = pileupSpec+' is not a know mixing scenario:\n available are: '
dictionary	mixingDict = {'file':pileupSpec}
tuple	mixingDict = copy.copy(Mixing[pileupSpec])
tuple	nl = self.additionalOutputs.keys()
tuple	outDefDictStr = outDefDict.__str__()
tuple	outList = eval(self._options.outputDefinition)
tuple	output
list	output = self.additionalOutputs[name]
tuple	outputModule = getattr(self.process,theModuleLabel)
string	outputModuleCfgCode = ""
	adding standard sequences might change the inputEventContent option and therefore needs to be finalized after More...
tuple	outputModuleCfgCode = self.addOutput()
string	outputModuleName = streamType+'output'
list	package = sys.modules[packageName]
tuple	packageName = f.replace(".py","")
tuple	path = getattr(self.process,theModuleLabel+'_step')
string	pathName = 'dqmoffline_step'
list	pathNames = ['process.'+p.label_() for p in beforeHLT]
tuple	pfs = getattr(self.process,self.productionFilterSequence)
tuple	pileupSpec = self._options.pileup.split(',')
list	pileupSpec = pileupSpec[4:]
tuple	rest = opt.split('.')
string	result = "process.schedule = cms.Schedule("
string	sequence = 'EIsequence'
tuple	sequence = sequence.split('.')
tuple	sequenceList = list(set(sequenceList))
tuple	shortName = name.replace('ALCARECOStream','')
tuple	shortname = skim.replace('SKIMStream','')
string	simGeometry = ''
list	simGeometry = geoms[0]
tuple	skimstream = getattr(skimConfig,skim)
tuple	skimstreamDQM
tuple	specialization = defineMixing(mixingDict)
list	stepList = [re.sub(r'^prepare_', '', methodName) for methodName in ConfigBuilder.__dict__ if methodName.startswith('prepare_')]
list	stepName = stepParts[0]
	add the corresponding input content More...
tuple	stepParts = step.split(":")
list	stepSpec = self.stepMap[stepName]
tuple	streamTypes = self._options.eventcontent.split(',')
	ends the –output options model More...
tuple	theEventContent = cms.PSet(outputCommands = cms.untracked.vstring('keep *'))
tuple	theExtraOutputCommands = anyOf(['o','oC','outputCommands'],outDefDict,'')
tuple	theFileName = self._options.dirout+anyOf(['fn','fileName'],outDefDict,defaultFileName)
	theFileName = self._options.outfile_name
tuple	theFilterName = anyOf(['f','ftN','filterName'],outDefDict,'')
string	theFilterName = 'StreamALCACombined'
	theFilterName = self._options.filtername
tuple	theModuleLabel = anyOf(['l','mL','moduleLabel'],outDefDict,'')
	theModuleLabel = name
tuple	theObject = getattr(generatorModule,name)
tuple	theSelectEvent = anyOf(['s','sE','selectEvents'],outDefDict,'')
tuple	theStreamType = anyOf(['e','ec','eventContent','streamType'],outDefDict,theTier)
	event content More...
tuple	theTier = anyOf(['t','tier','dataTier'],outDefDict)
tuple	tiers = self._options.datatier.split(',')
tuple	tmpOut = cms.EndPath(output)
list	tryNames

Private Attributes
	_options

Detailed Description

The main building routines 

Definition at line 173 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 176 of file ConfigBuilder.py.

Referenced by ConfigBuilder.ConfigBuilder.__init__().

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