validateAlignments.ValidationJob Class Reference

— Classes —############################ More...

Public Member Functions
def	__init__ (self, validation, config, options)
def	createJob (self)
def	getValidation (self)
def	runJob (self)

Public Attributes
	validation

Static Public Attributes
	batchCount
	batchJobIds
	crabCount
	interactCount
	jobCount

Private Member Functions
def	__createJob (self, jobMode, outpath)
def	__getValidation (self, valType, name, alignments, config, options)

Private Attributes
	__commandLineOptions
	__config
	__preexisting
	__scripts
	__valName
	__valType

Detailed Description

— Classes —############################

Definition at line 44 of file validateAlignments.py.

Constructor & Destructor Documentation

def validateAlignments.ValidationJob.__init__	(		self,
			validation,
			config,
			options
	)

Definition at line 53 of file validateAlignments.py.

References split.

    def __init__( self, validation, config, options ):
        if validation[1] == "":
            # intermediate syntax
            valString = validation[0].split( "->" )[0]
            alignments = validation[0].split( "->" )[1]
            # force user to use the normal syntax
            if "->" in validation[0]:
                msg = ("Instead of using the intermediate syntax\n'"
                       +valString.strip()+"-> "+alignments.strip()
                       +":'\nyou have to use the now fully supported syntax \n'"
                       +valString.strip()+": "
                       +alignments.strip()+"'.")
                raise AllInOneError(msg)
        else:
            valString = validation[0]
            alignments = validation[1]
        valString = valString.split()
        self.__valType = valString[0]
        self.__valName = valString[1]
        self.__commandLineOptions = options
        self.__config = config
        self.__preexisting = ("preexisting" in self.__valType)
        if self.__valType[0] == "*":
            self.__valType = self.__valType[1:]
            self.__preexisting = True

        # workaround for intermediate parallel version
        if self.__valType == "offlineParallel":
            print ("offlineParallel and offline are now the same.  To run an offline parallel validation,\n"
                   "just set parallelJobs to something > 1.  There is no reason to call it offlineParallel anymore.")
            self.__valType = "offline"            
        section = self.__valType + ":" + self.__valName
        if not self.__config.has_section( section ):
            raise AllInOneError("Validation '%s' of type '%s' is requested in"
                                  " '[validation]' section, but is not defined."
                                  "\nYou have to add a '[%s]' section."
                                  %( self.__valName, self.__valType, section ))
        self.validation = self.__getValidation( self.__valType, self.__valName,
                                                alignments, self.__config,
                                                options )

Member Function Documentation

def validateAlignments.ValidationJob.__createJob (   self,   jobMode,   outpath  )

private

This private method creates the needed files for the validation job.

Definition at line 154 of file validateAlignments.py.

References validateAlignments.ValidationJob.__preexisting.

Referenced by validateAlignments.ValidationJob.createJob().

    def __createJob( self, jobMode, outpath ):
        """This private method creates the needed files for the validation job.
           """
        self.validation.createConfiguration( outpath )
        if self.__preexisting:
            return
        self.__scripts = sum([addIndex(script, self.validation.NJobs) for script in self.validation.createScript( outpath )], [])
        if jobMode.split( ',' )[0] == "crab":
            self.validation.createCrabCfg( outpath )
        return None

def validateAlignments.ValidationJob.__getValidation (   self,   valType,   name,   alignments,   config,   options  )

private

Definition at line 94 of file validateAlignments.py.

References validateAlignments.ValidationJob.__config, split, and digi_MixPreMix_cfi.strip.

    def __getValidation( self, valType, name, alignments, config, options ):
        if valType == "compare":
            alignmentsList = alignments.split( "," )
            firstAlignList = alignmentsList[0].split()
            firstAlignName = firstAlignList[0].strip()
            if firstAlignName == "IDEAL":
                raise AllInOneError("'IDEAL' has to be the second (reference)"
                                      " alignment in 'compare <val_name>: "
                                      "<alignment> <reference>'.")
            if len( firstAlignList ) > 1:
                firstRun = firstAlignList[1]
            else:
                firstRun = "1"
            firstAlign = Alignment( firstAlignName, self.__config, firstRun )
            firstAlignName = firstAlign.name
            secondAlignList = alignmentsList[1].split()
            secondAlignName = secondAlignList[0].strip()
            if len( secondAlignList ) > 1:
                secondRun = secondAlignList[1]
            else:
                secondRun = "1"
            if secondAlignName == "IDEAL":
                secondAlign = secondAlignName
            else:
                secondAlign = Alignment( secondAlignName, self.__config,
                                         secondRun )
                secondAlignName = secondAlign.name
                
            validation = GeometryComparison( name, firstAlign, secondAlign,
                                             self.__config,
                                             self.__commandLineOptions.getImages)
        elif valType == "offline":
            validation = OfflineValidation( name, 
                Alignment( alignments.strip(), self.__config ), self.__config )
        elif valType == "preexistingoffline":
            validation = PreexistingOfflineValidation(name, self.__config)
        elif valType == "offlineDQM":
            validation = OfflineValidationDQM( name, 
                Alignment( alignments.strip(), self.__config ), self.__config )
        elif valType == "mcValidate":
            validation = MonteCarloValidation( name, 
                Alignment( alignments.strip(), self.__config ), self.__config )
        elif valType == "preexistingmcValidate":
            validation = PreexistingMonteCarloValidation(name, self.__config)
        elif valType == "split":
            validation = TrackSplittingValidation( name, 
                Alignment( alignments.strip(), self.__config ), self.__config )
        elif valType == "preexistingsplit":
            validation = PreexistingTrackSplittingValidation(name, self.__config)
        elif valType == "zmumu":
            validation = ZMuMuValidation( name, 
                Alignment( alignments.strip(), self.__config ), self.__config )
        elif valType == "primaryvertex":
            validation = PrimaryVertexValidation( name, 
                Alignment( alignments.strip(), self.__config ), self.__config )
        else:
            raise AllInOneError("Unknown validation mode '%s'"%valType)

        return validation

def validateAlignments.ValidationJob.createJob

(

self

)

This is the method called to create the job files.

Definition at line 165 of file validateAlignments.py.

References validateAlignments.ValidationJob.__createJob().

    def createJob(self):
        """This is the method called to create the job files."""
        self.__createJob( self.validation.jobmode,
                          os.path.abspath( self.__commandLineOptions.Name) )

def validateAlignments.ValidationJob.getValidation

(

self

)

Definition at line 242 of file validateAlignments.py.

References validateAlignments.ValidationJob.validation.

    def getValidation( self ):
        return self.validation

def validateAlignments.ValidationJob.runJob

(

self

)

Definition at line 170 of file validateAlignments.py.

References validateAlignments.ValidationJob.__preexisting, validateAlignments.ValidationJob.__scripts, validateAlignments.ValidationJob.__valName, validateAlignments.ValidationJob.__valType, cmsRelvalreport.exit, helperFunctions.getCommandOutput2(), split, and harvestTrackValidationPlots.str.

    def runJob( self ):
        if self.__preexisting:
            if self.validation.jobid:
                self.batchJobIds.append(self.validation.jobid)
            log = ">             " + self.validation.name + " is already validated."
            print log
            return log
        else:
            if self.validation.jobid:
                print "jobid {} will be ignored, since the validation {} is not preexisting".format(self.validation.jobid, self.validation.name)

        general = self.__config.getGeneral()
        log = ""
        for script in self.__scripts:
            name = os.path.splitext( os.path.basename( script) )[0]
            ValidationJob.jobCount += 1
            if self.__commandLineOptions.dryRun:
                print "%s would run: %s"%( name, os.path.basename( script) )
                continue
            log = ">             Validating "+name
            print ">             Validating "+name
            if self.validation.jobmode == "interactive":
                log += getCommandOutput2( script )
                ValidationJob.interactCount += 1
            elif self.validation.jobmode.split(",")[0] == "lxBatch":
                repMap = { 
                    "commands": self.validation.jobmode.split(",")[1],
                    "logDir": general["logdir"],
                    "jobName": name,
                    "script": script,
                    "bsub": "/afs/cern.ch/cms/caf/scripts/cmsbsub"
                    }
                for ext in ("stdout", "stderr", "stdout.gz", "stderr.gz"):
                    oldlog = "%(logDir)s/%(jobName)s."%repMap + ext
                    if os.path.exists(oldlog):
                        os.remove(oldlog)
                bsubOut=getCommandOutput2("%(bsub)s %(commands)s "
                                          "-J %(jobName)s "
                                          "-o %(logDir)s/%(jobName)s.stdout "
                                          "-e %(logDir)s/%(jobName)s.stderr "
                                          "%(script)s"%repMap)
                #Attention: here it is assumed that bsub returns a string
                #containing a job id like <123456789>
                ValidationJob.batchJobIds.append(bsubOut.split("<")[1].split(">")[0])
                log+=bsubOut
                ValidationJob.batchCount += 1
            elif self.validation.jobmode.split( "," )[0] == "crab":
                os.chdir( general["logdir"] )
                crabName = "crab." + os.path.basename( script )[:-3]
                theCrab = crabWrapper.CrabWrapper()
                options = { "-create": "",
                            "-cfg": crabName + ".cfg",
                            "-submit": "" }
                try:
                    theCrab.run( options )
                except AllInOneError as e:
                    print "crab:", str(e).split("\n")[0]
                    exit(1)
                ValidationJob.crabCount += 1

            else:
                raise AllInOneError("Unknown 'jobmode'!\n"
                                      "Please change this parameter either in "
                                      "the [general] or in the ["
                                      + self.__valType + ":" + self.__valName
                                      + "] section to one of the following "
                                      "values:\n"
                                      "\tinteractive\n\tlxBatch, -q <queue>\n"
                                      "\tcrab, -q <queue>")

        return log

Member Data Documentation

validateAlignments.ValidationJob.__commandLineOptions

private

Definition at line 72 of file validateAlignments.py.

validateAlignments.ValidationJob.__config

private

Definition at line 73 of file validateAlignments.py.

Referenced by validateAlignments.ValidationJob.__getValidation().

validateAlignments.ValidationJob.__preexisting

private

Definition at line 74 of file validateAlignments.py.

Referenced by validateAlignments.ValidationJob.__createJob(), and validateAlignments.ValidationJob.runJob().

validateAlignments.ValidationJob.__scripts

private

Definition at line 160 of file validateAlignments.py.

Referenced by validateAlignments.ValidationJob.runJob().

validateAlignments.ValidationJob.__valName

private

Definition at line 71 of file validateAlignments.py.

Referenced by validateAlignments.ValidationJob.runJob().

validateAlignments.ValidationJob.__valType

private

Definition at line 70 of file validateAlignments.py.

Referenced by validateAlignments.ValidationJob.runJob().

validateAlignments.ValidationJob.batchCount

static

Definition at line 49 of file validateAlignments.py.

validateAlignments.ValidationJob.batchJobIds

static

Definition at line 50 of file validateAlignments.py.

validateAlignments.ValidationJob.crabCount

static

Definition at line 47 of file validateAlignments.py.

validateAlignments.ValidationJob.interactCount

static

Definition at line 48 of file validateAlignments.py.

validateAlignments.ValidationJob.jobCount

static

Definition at line 51 of file validateAlignments.py.

validateAlignments.ValidationJob.validation

Definition at line 90 of file validateAlignments.py.

Referenced by validateAlignments.ValidationJob.getValidation().