Inheritance diagram for genericValidation.GenericValidation:

Public Member Functions
def	__init__ (self, valName, alignment, config, valType, addDefaults={}, addMandatories=[], addneedpackages=[])

def	createConfiguration (self, fileContents, path, schedule=None, repMap=None, repMaps=None)

def	createCrabCfg (self, fileContents, path)

def	createFiles (self, fileContents, path, repMap=None, repMaps=None)

def	createScript (self, fileContents, path, downloadFiles=[], repMap=None, repMaps=None)

def	getCompareStrings (self, requestId=None, plain=False)

def	getRepMap (self, alignment=None)

Public Attributes
	alignmentToValidate

	AutoAlternates

	cmssw

	cmsswreleasebase

	config

	configFiles

	crabConfigFiles

	filesToCompare

	general

	jobid

	jobmode

	name

	NJobs

	packages

	randomWorkdirPart

	scramarch

	scriptFiles

	valType

Static Public Attributes
string	defaultReferenceName = "DEFAULT"

Detailed Description

Definition at line 12 of file genericValidation.py.

Constructor & Destructor Documentation

def genericValidation.GenericValidation.__init__	(	self,
		valName,
		alignment,
		config,
		valType,
		addDefaults = `{}`,
		addMandatories = `[]`,
		addneedpackages = `[]`
	)

Definition at line 15 of file genericValidation.py.

                  addDefaults = {}, addMandatories=[], addneedpackages=[]):
         import random
         self.name = valName
         self.valType = valType
         self.alignmentToValidate = alignment
         self.general = config.getGeneral()
         self.randomWorkdirPart = "%0i"%random.randint(1,10e9)
         self.configFiles = []
         self.filesToCompare = {}
         self.config = config
         self.jobid = ""
 
         defaults = {
                     "jobmode":      self.general["jobmode"],
                     "cmssw":        os.environ['CMSSW_BASE'],
                     "parallelJobs": "1",
                     "jobid":        "",
                    }
         defaults.update(addDefaults)
         mandatories = []
         mandatories += addMandatories
         needpackages = ["Alignment/OfflineValidation"]
         needpackages += addneedpackages
         theUpdate = config.getResultingSection(valType+":"+self.name,
                                                defaultDict = defaults,
                                                demandPars = mandatories)
         self.general.update(theUpdate)
         self.jobmode = self.general["jobmode"]
         self.NJobs = int(self.general["parallelJobs"])
 
         # limit maximum number of parallel jobs to 40
         # (each output file is approximately 20MB)
         maximumNumberJobs = 40
         if self.NJobs > maximumNumberJobs:
             msg = ("Maximum allowed number of parallel jobs "
                    +str(maximumNumberJobs)+" exceeded!!!")
             raise AllInOneError(msg)
 
         self.jobid = self.general["jobid"]
         if self.jobid:
             try:  #make sure it's actually a valid jobid
                 output = getCommandOutput2("bjobs %(jobid)s 2>&1"%self.general)
                 if "is not found" in output: raise RuntimeError
             except RuntimeError:
                 raise AllInOneError("%s is not a valid jobid.\nMaybe it finished already?"%self.jobid)
 
         self.cmssw = self.general["cmssw"]
         badcharacters = r"\'"
         for character in badcharacters:
             if character in self.cmssw:
                 raise AllInOneError("The bad characters " + badcharacters + " are not allowed in the cmssw\n"
                                     "path name.  If you really have it in such a ridiculously named location,\n"
                                     "try making a symbolic link somewhere with a decent name.")
         try:
             os.listdir(self.cmssw)
         except OSError:
             raise AllInOneError("Your cmssw release " + self.cmssw + ' does not exist')
 
         if self.cmssw == os.environ["CMSSW_BASE"]:
             self.scramarch = os.environ["SCRAM_ARCH"]
             self.cmsswreleasebase = os.environ["CMSSW_RELEASE_BASE"]
         else:
             command = ("cd '" + self.cmssw + "' && eval `scramv1 ru -sh 2> /dev/null`"
                        ' && echo "$CMSSW_BASE\n$SCRAM_ARCH\n$CMSSW_RELEASE_BASE"')
             commandoutput = getCommandOutput2(command).split('\n')
             self.cmssw = commandoutput[0]
             self.scramarch = commandoutput[1]
             self.cmsswreleasebase = commandoutput[2]
 
         self.packages = {}
         for package in needpackages:
             for placetolook in self.cmssw, self.cmsswreleasebase:
                 pkgpath = os.path.join(placetolook, "src", package)
                 if os.path.exists(pkgpath):
                     self.packages[package] = pkgpath
                     break
             else:
                 raise AllInOneError("Package {} does not exist in {} or {}!".format(package, self.cmssw, self.cmsswreleasebase))
 
         self.AutoAlternates = True
         if config.has_option("alternateTemplates","AutoAlternates"):
             try:
                 self.AutoAlternates = json.loads(config.get("alternateTemplates","AutoAlternates").lower())
             except ValueError:
                 raise AllInOneError("AutoAlternates needs to be true or false, not %s" % config.get("alternateTemplates","AutoAlternates"))
 
         knownOpts = defaults.keys()+mandatories
         ignoreOpts = []
         config.checkInput(valType+":"+self.name,
                           knownSimpleOptions = knownOpts,
                           ignoreOptions = ignoreOpts)
 

Member Function Documentation

def genericValidation.GenericValidation.createConfiguration	(	self,
		fileContents,
		path,
		schedule = `None`,
		repMap = `None`,
		repMaps = `None`
	)

Definition at line 181 of file genericValidation.py.

References genericValidation.GenericValidation.configFiles.

     def createConfiguration(self, fileContents, path, schedule = None, repMap = None, repMaps = None):
         self.configFiles = GenericValidation.createFiles(self, fileContents,
                                                          path, repMap = repMap, repMaps = repMaps)
         if not schedule == None:
             schedule = [os.path.join( path, cfgName) for cfgName in schedule]
             for cfgName in schedule:
                 if not cfgName in self.configFiles:
                     msg = ("scheduled %s missing in generated configfiles: %s"
                            %(cfgName, self.configFiles))
                     raise AllInOneError(msg)
             for cfgName in self.configFiles:
                 if not cfgName in schedule:
                     msg = ("generated configuration %s not scheduled: %s"
                            %(cfgName, schedule))
                     raise AllInOneError(msg)
             self.configFiles = schedule
         return self.configFiles
 

def genericValidation.GenericValidation.createCrabCfg	(	self,
		fileContents,
		path
	)

Definition at line 207 of file genericValidation.py.

References genericValidation.GenericValidation.NJobs.

     def createCrabCfg(self, fileContents, path ):
         if self.NJobs > 1:
             msg =  ("jobmode 'crab' not supported for parallel validation."
                     " Please set parallelJobs = 1.")
             raise AllInOneError(msg)
         self.crabConfigFiles = GenericValidation.createFiles(self, fileContents,
                                                              path)
         return self.crabConfigFiles
 
 

def genericValidation.GenericValidation.createFiles	(	self,
		fileContents,
		path,
		repMap = `None`,
		repMaps = `None`
	)

repMap: single map for all files
   repMaps: a dict, with the filenames as the keys

Definition at line 158 of file genericValidation.py.

References helperFunctions.addIndex(), genericValidation.GenericValidation.NJobs, helperFunctions.replaceByMap(), and harvestTrackValidationPlots.str.

     def createFiles(self, fileContents, path, repMap = None, repMaps = None):
         """repMap: single map for all files
            repMaps: a dict, with the filenames as the keys"""
         if repMap is not None and repMaps is not None:
             raise AllInOneError("createFiles can only take repMap or repMaps (or neither), not both")
         result = []
         for fileName in fileContents:
             filePath = os.path.join(path, fileName)
             result.append(filePath)
 
             for (i, filePathi) in enumerate(addIndex(filePath, self.NJobs)):
                 theFile = open( filePathi, "w" )
                 fileContentsi = fileContents[ fileName ]
                 if repMaps is not None:
                     repMap = repMaps[fileName]
                 if repMap is not None:
                     repMap.update({"nIndex": str(i)})
                     fileContentsi = replaceByMap(fileContentsi, repMap)
                 theFile.write( fileContentsi )
                 theFile.close()
 
         return result
 

def genericValidation.GenericValidation.createScript	(	self,
		fileContents,
		path,
		downloadFiles = `[]`,
		repMap = `None`,
		repMaps = `None`
	)

Definition at line 199 of file genericValidation.py.

     def createScript(self, fileContents, path, downloadFiles=[], repMap = None, repMaps = None):
         self.scriptFiles = GenericValidation.createFiles(self, fileContents,
                                                          path, repMap = repMap, repMaps = repMaps)
         for script in self.scriptFiles:
             for scriptwithindex in addIndex(script, self.NJobs):
                 os.chmod(scriptwithindex,0o755)
         return self.scriptFiles
 

def genericValidation.GenericValidation.getCompareStrings	(	self,
		requestId = `None`,
		plain = `False`
	)

Definition at line 134 of file genericValidation.py.

References genericValidation.GenericValidation.filesToCompare.

Referenced by trackSplittingValidation.TrackSplittingValidation.appendToExtendedValidation(), preexistingValidation.PreexistingOfflineValidation.appendToExtendedValidation(), and preexistingValidation.PreexistingTrackSplittingValidation.appendToExtendedValidation().

     def getCompareStrings( self, requestId = None, plain = False ):
         result = {}
         repMap = self.alignmentToValidate.getRepMap()
         for validationId in self.filesToCompare:
             repMap["file"] = self.filesToCompare[ validationId ]
             if repMap["file"].startswith( "/castor/" ):
                 repMap["file"] = "rfio:%(file)s"%repMap
             elif repMap["file"].startswith( "/store/" ):
                 repMap["file"] = "root://eoscms.cern.ch//eos/cms%(file)s"%repMap
             if plain:
                 result[validationId]=repMap["file"]
             else:
                 result[validationId]= "%(file)s=%(title)s|%(color)s|%(style)s"%repMap
         if requestId == None:
             return result
         else:
             if not "." in requestId:
                 requestId += ".%s"%GenericValidation.defaultReferenceName
             if not requestId.split(".")[-1] in result:
                 msg = ("could not find %s in reference Objects!"
                        %requestId.split(".")[-1])
                 raise AllInOneError(msg)
             return result[ requestId.split(".")[-1] ]
 

def genericValidation.GenericValidation.getRepMap	(	self,
		alignment = `None`
	)

Definition at line 107 of file genericValidation.py.

Referenced by trackSplittingValidation.TrackSplittingValidation.appendToExtendedValidation(), zMuMuValidation.ZMuMuValidation.appendToExtendedValidation(), primaryVertexValidation.PrimaryVertexValidation.appendToExtendedValidation(), offlineValidation.OfflineValidation.appendToExtendedValidation(), preexistingValidation.PreexistingOfflineValidation.appendToExtendedValidation(), preexistingValidation.PreexistingTrackSplittingValidation.appendToExtendedValidation(), trackSplittingValidation.TrackSplittingValidation.appendToMerge(), primaryVertexValidation.PrimaryVertexValidation.appendToMerge(), offlineValidation.OfflineValidation.appendToMerge(), trackSplittingValidation.TrackSplittingValidation.createConfiguration(), monteCarloValidation.MonteCarloValidation.createConfiguration(), primaryVertexValidation.PrimaryVertexValidation.createConfiguration(), offlineValidation.OfflineValidation.createConfiguration(), zMuMuValidation.ZMuMuValidation.createConfiguration(), geometryComparison.GeometryComparison.createConfiguration(), genericValidation.GenericValidationData.createCrabCfg(), geometryComparison.GeometryComparison.createScript(), genericValidation.GenericValidationData.createScript(), preexistingValidation.PreexistingValidation.getCompareStrings(), and plottingOptions.PlottingOptionsTrackSplitting.validsubdets().

     def getRepMap(self, alignment = None):
         if alignment == None:
             alignment = self.alignmentToValidate
         try:
             result = PlottingOptions(self.config, self.valType)
         except KeyError:
             result = {}
         result.update(alignment.getRepMap())
         result.update( self.general )
         result.update({
                 "workdir": os.path.join(self.general["workdir"],
                                         self.randomWorkdirPart),
                 "datadir": self.general["datadir"],
                 "logdir": self.general["logdir"],
                 "CommandLineTemplate": ("#run configfile and post-proccess it\n"
                                         "cmsRun %(cfgFile)s\n"
                                         "%(postProcess)s "),
                 "CMSSW_BASE": self.cmssw,
                 "SCRAM_ARCH": self.scramarch,
                 "CMSSW_RELEASE_BASE": self.cmsswreleasebase,
                 "alignmentName": alignment.name,
                 "condLoad": alignment.getConditions(),
                 "LoadGlobalTagTemplate": configTemplates.loadGlobalTagTemplate,
                 })
         result.update(self.packages)
         return result
 