alignment.Alignment Class Reference

Inheritance diagram for alignment.Alignment:

Public Member Functions
def	__init__ (self, name, config, runGeomComp="1")
def	getConditions (self)
def	getRepMap (self)
def	restrictTo (self, restriction)

Public Attributes
	color
	conditions
	globaltag
	mode
	name
	runGeomComp
	style
	title

Static Public Attributes
dictionary	condShorts

Private Member Functions
def	__getConditions (self, theConfig, theSection)
def	__shorthandExists (self, theRcdName, theShorthand)
def	__testDbExist (self, dbpath, tagname)

Detailed Description

Definition at line 11 of file alignment.py.

Constructor & Destructor Documentation

__init__()

def alignment.Alignment.__init__	(		self,
			name,
			config,
			runGeomComp = "1"
	)

Definition at line 36 of file alignment.py.

    def __init__(self, name, config, runGeomComp = "1"):
        section = "alignment:%s"%name
        if not config.has_section( section ):
            raise AllInOneError("section %s not found. Please define the "
                                  "alignment!"%section)
        config.checkInput(section,
                          knownSimpleOptions = ['globaltag', 'style', 'color', 'title', 'mp', 'mp_alignments', 'mp_deformations', 'mp_APEs', 'hp', 'hp_alignments', 'hp_deformations', 'sm', 'sm_alignments', 'sm_deformations'],
                          knownKeywords = ['condition'])
        self.name = clean_name(name)
        if config.exists(section,"title"):
            self.title = config.get(section,"title")
        else:
            self.title = self.name
        if (int(runGeomComp) != 1):
            self.name += "_run" + runGeomComp
            self.title += " run " + runGeomComp
        if "|" in self.title or "," in self.title or '"' in self.title:
            msg = "The characters '|', '\"', and ',' cannot be used in the alignment title!"
            raise AllInOneError(msg)
        self.runGeomComp = runGeomComp
        self.globaltag = config.get( section, "globaltag" )
        self.conditions = self.__getConditions( config, section )
 
        self.color = config.get(section,"color")
        self.style = config.get(section,"style")
 
        self.color = str(parsecolor(self.color))
        self.style = str(parsestyle(self.style))
 

Member Function Documentation

__getConditions()

def alignment.Alignment.__getConditions (   self,   theConfig,   theSection  )

private

Definition at line 80 of file alignment.py.

    def __getConditions( self, theConfig, theSection ):
        conditions = []
        for option in theConfig.options( theSection ):
            if option in ("mp", "mp_alignments", "mp_deformations", "mp_APEs", "hp", "hp_alignments", "hp_deformations", "sm", "sm_alignments", "sm_deformations"):
                matches = [re.match(_, option) for _ in ("^(..)$", "^(..)_alignments$", "^(..)_deformations$", "^(..)_APEs$")]
                assert sum(bool(_) for _ in matches) == 1, option
                condPars = theConfig.get(theSection, option).split(",")
                condPars = [_.strip() for _ in condPars]
                if matches[0]:
                    alignments = True
                    deformations = True
                    APEs = {"hp": False, "mp": True}[option]
                elif matches[1]:
                    alignments = True
                    deformations = False
                    APEs = False
                    option = matches[1].group(1)
                elif matches[2]:
                    alignments = False
                    deformations = True
                    APEs = False
                    option = matches[2].group(1)
                elif matches[3]:
                    alignments = False
                    deformations = False
                    APEs = True
                    option = matches[3].group(1)
                else:
                    assert False
 
                if option == "mp":
                    if len(condPars) == 1:
                        number, = condPars
                        jobm = None
                    elif len(condPars) == 2:
                        number, jobm = condPars
                    else:
                        raise AllInOneError("Up to 2 arguments accepted for {} (job number, and optionally jobm index)".format(option))
 
                    folder = "/afs/cern.ch/cms/CAF/CMSALCA/ALCA_TRACKERALIGN/MP/MPproduction/{}{}/".format(option, number)
                    if not os.path.exists(folder):
                        raise AllInOneError(folder+" does not exist.")
                    folder = os.path.join(folder, "jobData")
                    jobmfolders = set()
                    if jobm is None:
                        for filename in os.listdir(folder):
                            if re.match("jobm([0-9]*)", filename) and os.path.isdir(os.path.join(folder, filename)):
                                jobmfolders.add(filename)
                        if len(jobmfolders) == 0:
                            raise AllInOneError("No jobm or jobm(number) folder in {}".format(folder))
                        elif len(jobmfolders) == 1:
                            folder = os.path.join(folder, jobmfolders.pop())
                        else:
                            raise AllInOneError(
                                                "Multiple jobm or jobm(number) folders in {}\n".format(folder)
                                                + ", ".join(jobmfolders) + "\n"
                                                + "Please specify 0 for jobm, or a number for one of the others."
                                               )
                    elif jobm == "0":
                        folder = os.path.join(folder, "jobm")
                        if os.path.exists(folder + "0"):
                            raise AllInOneError("Not set up to handle a folder named jobm0")
                    else:
                        folder = os.path.join(folder, "jobm{}".format(jobm))
 
                    dbfile = os.path.join(folder, "alignments_MP.db")
                    if not os.path.exists(dbfile):
                        raise AllInOneError("No file {}.  Maybe your alignment folder is corrupted, or maybe you specified the wrong jobm?".format(dbfile))
 
                elif option in ("hp", "sm"):
                    if len(condPars) == 1:
                        number, = condPars
                        iteration = None
                    elif len(condPars) == 2:
                        number, iteration = condPars
                    else:
                        raise AllInOneError("Up to 2 arguments accepted for {} (job number, and optionally iteration)".format(option))
                    folder = "/afs/cern.ch/cms/CAF/CMSALCA/ALCA_TRACKERALIGN2/HipPy/alignments/{}{}".format(option, number)
                    if not os.path.exists(folder):
                        raise AllInOneError(folder+" does not exist.")
                    if iteration is None:
                        for filename in os.listdir(folder):
                            match = re.match("alignments_iter([0-9]*).db", filename)
                            if match:
                                if iteration is None or int(match.group(1)) > iteration:
                                    iteration = int(match.group(1))
                        if iteration is None:
                            raise AllInOneError("No alignments in {}".format(folder))
                    dbfile = os.path.join(folder, "alignments_iter{}.db".format(iteration))
                    if not os.path.exists(dbfile):
                        raise AllInOneError("No file {}.".format(dbfile))
 
                    if "Deformations" not in getTagsMap(dbfile).keys():
                        deformations = False  #so that hp = XXXX works whether or not deformations were aligned
                        if not alignments:    #then it's specified with hp_deformations, which is a mistake
                            raise AllInOneError("{}{} has no deformations".format(option, number))
 
                else:
                    assert False, option
 
                if alignments:
                    conditions.append({"rcdName": "TrackerAlignmentRcd",
                                       "connectString": "sqlite_file:"+dbfile,
                                       "tagName": "Alignments",
                                       "labelName": ""})
                if deformations:
                    conditions.append({"rcdName": "TrackerSurfaceDeformationRcd",
                                       "connectString": "sqlite_file:"+dbfile,
                                       "tagName": "Deformations",
                                       "labelName": ""})
                if APEs:
                    conditions.append({"rcdName": "TrackerAlignmentErrorExtendedRcd",
                                       "connectString": "sqlite_file:"+dbfile,
                                       "tagName": "AlignmentErrorsExtended",
                                       "labelName": ""})
 
            elif option.startswith( "condition " ):
                rcdName = option.split( "condition " )[1]
                condPars = theConfig.get( theSection, option ).split( "," )
                if len(condPars) == 1:
                    if len(condPars[0])==0:
                        msg = ("In section [%s]: '%s' is used with too few "
                               "arguments. A connect_string and a tag are "
                               "required!"%(theSection, option))
                        raise AllInOneError(msg)
                    elif self.__shorthandExists(rcdName, condPars[0]):
                        shorthand = condPars[0]
                        condPars = [
                            self.condShorts[rcdName][shorthand]["connectString"],
                            self.condShorts[rcdName][shorthand]["tagName"],
                            self.condShorts[rcdName][shorthand]["labelName"]]
                    elif rcdName == "TrackerAlignmentErrorExtendedRcd" and condPars[0] == "zeroAPE":
                        raise AllInOneError("Please specify either zeroAPE_phase0 or zeroAPE_phase1")
                        #can probably make zeroAPE an alias of zeroAPE_phase1 at some point,
                        #but not sure if now is the time
                    else:
                        msg = ("In section [%s]: '%s' is used with '%s', "
                               "which is an unknown shorthand for '%s'. Either "
                               "provide at least a connect_string and a tag or "
                               "use a known shorthand.\n"
                               %(theSection, option, condPars[0], rcdName))
                        if rcdName in self.condShorts:
                            msg += "Known shorthands for '%s':\n"%(rcdName)
                            theShorts = self.condShorts[rcdName]
                            knownShorts = [("\t"+key+": "
                                            +theShorts[key]["connectString"]+","
                                            +theShorts[key]["tagName"]+","
                                            +theShorts[key]["labelName"]) \
                                               for key in theShorts]
                            msg+="\n".join(knownShorts)
                        else:
                            msg += ("There are no known shorthands for '%s'."
                                    %(rcdName))
                        raise AllInOneError(msg)
                if len( condPars ) == 2:
                    condPars.append( "" )
                if len(condPars) > 3:
                    msg = ("In section [%s]: '%s' is used with too many "
                           "arguments. A maximum of 3 arguments is allowed."
                           %(theSection, option))
                    raise AllInOneError(msg)
                conditions.append({"rcdName": rcdName.strip(),
                                   "connectString": condPars[0].strip(),
                                   "tagName": condPars[1].strip(),
                                   "labelName": condPars[2].strip()})
 
        rcdnames = collections.Counter(condition["rcdName"] for condition in conditions)
        if rcdnames and max(rcdnames.values()) >= 2:
            raise AllInOneError("Some conditions are specified multiple times (possibly through mp or hp options)!\n"
                                + ", ".join(rcdname for rcdname, count in six.iteritems(rcdnames) if count >= 2))
 
        for condition in conditions:
            self.__testDbExist(condition["connectString"], condition["tagName"])
 
        return conditions
 

References alignment.Alignment.__shorthandExists(), alignment.Alignment.__testDbExist(), electrons_cff.bool, alignment.Alignment.condShorts, helperFunctions.getTagsMap(), watchdog.group, createfilelist.int, join(), relativeConstraints.keys, SiStripPI.max, cms::dd.split(), and digitizers_cfi.strip.

__shorthandExists()

def alignment.Alignment.__shorthandExists (   self,   theRcdName,   theShorthand  )

private

Method which checks, if `theShorthand` is a valid shorthand for the
given `theRcdName`.

Arguments:
- `theRcdName`: String which specifies the database record.
- `theShorthand`: String which specifies the shorthand to check.

Definition at line 65 of file alignment.py.

    def __shorthandExists(self, theRcdName, theShorthand):
        """Method which checks, if `theShorthand` is a valid shorthand for the
        given `theRcdName`.
 
        Arguments:
        - `theRcdName`: String which specifies the database record.
        - `theShorthand`: String which specifies the shorthand to check.
        """
 
        if (theRcdName in self.condShorts) and \
                (theShorthand in self.condShorts[theRcdName]):
            return True
        else:
            return False
 

References alignment.Alignment.condShorts.

Referenced by alignment.Alignment.__getConditions().

__testDbExist()

def alignment.Alignment.__testDbExist (   self,   dbpath,   tagname  )

private

Definition at line 256 of file alignment.py.

    def __testDbExist(self, dbpath, tagname):
        if dbpath.startswith("sqlite_file:"):
            if not os.path.exists( dbpath.split("sqlite_file:")[1] ):
                raise AllInOneError("could not find file: '%s'"%dbpath.split("sqlite_file:")[1])
            elif tagname not in getTagsMap(dbpath).values():
                raise AllInOneError("{} does not exist in {}".format(tagname, dbpath))
 

References helperFunctions.getTagsMap(), and contentValuesCheck.values.

Referenced by alignment.Alignment.__getConditions().

getConditions()

def alignment.Alignment.getConditions

(

self

)

This function creates the configuration snippet to override
   global tag conditions.

Definition at line 282 of file alignment.py.

    def getConditions(self):
        """This function creates the configuration snippet to override
           global tag conditions.
           """
        if len( self.conditions ):
            loadCond = ("\nimport CalibTracker.Configuration."
                        "Common.PoolDBESSource_cfi\n")
            for cond in self.conditions:
                if not cond["labelName"] == "":
                    temp = configTemplates.conditionsTemplate.replace(
                        "tag = cms.string('.oO[tagName]Oo.')",
                        ("tag = cms.string('.oO[tagName]Oo.'),"
                         "\nlabel = cms.untracked.string('.oO[labelName]Oo.')"))
                else:
                    temp = configTemplates.conditionsTemplate
                loadCond += replaceByMap( temp, cond )
        else:
            loadCond = ""
        return loadCond

References alignment.Alignment.conditions, and helperFunctions.replaceByMap().

getRepMap()

def alignment.Alignment.getRepMap

(

self

)

Definition at line 271 of file alignment.py.

    def getRepMap( self ):
        result = {
            "name": self.name,
            "title": self.title,
            "color": self.color,
            "style": self.style,
            "runGeomComp": self.runGeomComp,
            "GlobalTag": self.globaltag
            }
        return result
 

References alignment.Alignment.color, alignment.Alignment.globaltag, AlignableObjectId::entry.name, alignment.Alignment.name, TrackerSectorStruct.name, MuonGeometrySanityCheckPoint.name, classes.MonitorData.name, classes.OutputData.name, geometry.Structure.name, plotscripts.SawTeethFunction.name, alignment.Alignment.runGeomComp, alignment.Alignment.style, classes.PlotData.title, alignment.Alignment.title, and Geometry.title.

Referenced by overlapValidation.OverlapValidation.appendToMerge(), trackSplittingValidation.TrackSplittingValidation.appendToMerge(), primaryVertexResolution.PrimaryVertexResolution.appendToMerge(), primaryVertexValidation.PrimaryVertexValidation.appendToMerge(), offlineValidation.OfflineValidation.appendToMerge(), overlapValidation.OverlapValidation.appendToPlots(), trackSplittingValidation.TrackSplittingValidation.appendToPlots(), primaryVertexResolution.PrimaryVertexResolution.appendToPlots(), primaryVertexValidation.PrimaryVertexValidation.appendToPlots(), zMuMuValidation.ZMuMuValidation.appendToPlots(), geometryComparison.GeometryComparison.createConfiguration(), genericValidation.GenericValidationData.createConfiguration(), genericValidation.GenericValidationData.createCrabCfg(), geometryComparison.GeometryComparison.createScript(), genericValidation.GenericValidationData.createScript(), genericValidation.ParallelValidation.doMerge(), zMuMuValidation.ZMuMuValidation.filesToCompare(), genericValidation.GenericValidationData.filesToCompare(), and plottingOptions.PlottingOptionsTrackSplitting.validsubdets().

restrictTo()

def alignment.Alignment.restrictTo	(		self,
			restriction
	)

Definition at line 263 of file alignment.py.

    def restrictTo( self, restriction ):
        result = []
        if not restriction == None:
            for mode in self.mode:
                if mode in restriction:
                    result.append( mode )
            self.mode = result
 

References GeneralPurposeTrackAnalyzer.mode, alignment.Alignment.mode, and svgfig.Poly.mode.

Member Data Documentation

color

alignment.Alignment.color

Definition at line 59 of file alignment.py.

Referenced by alignment.Alignment.getRepMap(), and edmStreamStallGrapher.StreamInfoElement.unpack().

conditions

alignment.Alignment.conditions

Definition at line 57 of file alignment.py.

Referenced by alignment.Alignment.getConditions().

condShorts

dictionary alignment.Alignment.condShorts

static

Initial value:

=  {
        "TrackerAlignmentErrorExtendedRcd": {
            "zeroAPE_phase0": {
                "connectString":("frontier://FrontierProd"
                                         "/CMS_CONDITIONS"),
                "tagName": "TrackerIdealGeometryErrorsExtended210_mc",
                "labelName": ""
            },
            "zeroAPE_phase1": {
                "connectString":("frontier://FrontierProd"
                                         "/CMS_CONDITIONS"),
                "tagName": "TrackerAlignmentErrorsExtended_Upgrade2017_design_v0",
                "labelName": ""
            },
        },
        "TrackerSurfaceDeformationRcd": {
            "zeroDeformations": {
                "connectString":("frontier://FrontierProd"
                                         "/CMS_CONDITIONS"),
                "tagName": "TrackerSurfaceDeformations_zero",
                "labelName": ""
            },
        },
    }

Definition at line 12 of file alignment.py.

Referenced by alignment.Alignment.__getConditions(), and alignment.Alignment.__shorthandExists().

globaltag

alignment.Alignment.globaltag

Definition at line 56 of file alignment.py.

Referenced by alignment.Alignment.getRepMap(), and cmsHarvester.CMSHarvester.option_handler_globaltag().

mode

alignment.Alignment.mode

Definition at line 269 of file alignment.py.

Referenced by alignment.Alignment.restrictTo().

name

alignment.Alignment.name

Definition at line 44 of file alignment.py.

Referenced by ElectronMVAID.ElectronMVAID.__call__(), FWLite.ElectronMVAID.__call__(), dirstructure.Directory.__create_pie_image(), DisplayManager.DisplayManager.__del__(), dqm_interfaces.DirID.__eq__(), BeautifulSoup.Tag.__eq__(), dirstructure.Directory.__get_full_path(), dirstructure.Comparison.__get_img_name(), dataset.Dataset.__getDataType(), dataset.Dataset.__getFileInfoList(), dirstructure.Comparison.__make_image(), core.autovars.NTupleVariable.__repr__(), core.autovars.NTupleObjectType.__repr__(), core.autovars.NTupleObject.__repr__(), core.autovars.NTupleCollection.__repr__(), dirstructure.Directory.__repr__(), dqm_interfaces.DirID.__repr__(), dirstructure.Comparison.__repr__(), config.Service.__setattr__(), config.CFG.__str__(), counter.Counter.__str__(), average.Average.__str__(), BeautifulSoup.Tag.__str__(), BeautifulSoup.SoupStrainer.__str__(), FWLite.WorkingPoints._reformat_cut_definitions(), core.autovars.NTupleObjectType.addSubObjects(), core.autovars.NTupleObjectType.addVariables(), core.autovars.NTupleObjectType.allVars(), dataset.CMSDataset.buildListOfFiles(), dataset.LocalDataset.buildListOfFiles(), dataset.CMSDataset.buildListOfFilesDBS(), dirstructure.Directory.calcStats(), genericValidation.GenericValidationData.cfgName(), crabFunctions.CrabTask.crabConfig(), crabFunctions.CrabTask.crabFolder(), genericValidation.GenericValidationData.createCrabCfg(), geometryComparison.GeometryComparison.createScript(), genericValidation.GenericValidationData.createScript(), validation.Sample.digest(), python.rootplot.utilities.Hist.divide(), python.rootplot.utilities.Hist.divide_wilson(), DisplayManager.DisplayManager.Draw(), TreeCrawler.Package.dump(), core.autovars.NTupleVariable.fillBranch(), core.autovars.NTupleObject.fillBranches(), core.autovars.NTupleCollection.fillBranchesScalar(), core.autovars.NTupleCollection.fillBranchesVector(), core.autovars.NTupleCollection.get_cpp_declaration(), core.autovars.NTupleCollection.get_cpp_wrapper_class(), core.autovars.NTupleCollection.get_py_wrapper_class(), utils.StatisticalTest.get_status(), production_tasks.Task.getname(), dataset.CMSDataset.getPrimaryDatasetEntries(), dataset.PrivateDataset.getPrimaryDatasetEntries(), primaryVertexResolution.PrimaryVertexResolution.getRepMap(), primaryVertexValidation.PrimaryVertexValidation.getRepMap(), zMuMuValidation.ZMuMuValidation.getRepMap(), alignment.Alignment.getRepMap(), genericValidation.GenericValidationData.getRepMap(), crabFunctions.CrabTask.handleNoState(), VIDSelectorBase.VIDSelectorBase.initialize(), crabFunctions.CrabTask.isData(), personalPlayback.Applet.log(), core.autovars.NTupleVariable.makeBranch(), core.autovars.NTupleObject.makeBranches(), core.autovars.NTupleCollection.makeBranchesScalar(), core.autovars.NTupleCollection.makeBranchesVector(), dirstructure.Directory.print_report(), dataset.BaseDataset.printInfo(), dataset.Dataset.printInfo(), crabFunctions.CrabTask.resubmit_failed(), production_tasks.MonitorJobs.run(), BeautifulSoup.SoupStrainer.searchTag(), python.rootplot.utilities.Hist.TGraph(), python.rootplot.utilities.Hist.TH1F(), crabFunctions.CrabTask.update(), crabFunctions.CrabTask.updateJobStats(), counter.Counter.write(), and average.Average.write().

runGeomComp

alignment.Alignment.runGeomComp

Definition at line 55 of file alignment.py.

Referenced by alignment.Alignment.getRepMap().

style

alignment.Alignment.style

Definition at line 60 of file alignment.py.

Referenced by alignment.Alignment.getRepMap(), and Formatter.SimpleHTMLFormatter.headers().

title

alignment.Alignment.title

Definition at line 46 of file alignment.py.

Referenced by python.rootplot.root2matplotlib.HistStack.bar(), python.rootplot.root2matplotlib.HistStack.bar3d(), python.rootplot.root2matplotlib.HistStack.barcluster(), python.rootplot.root2matplotlib.HistStack.barh(), python.rootplot.root2matplotlib.HistStack.barstack(), python.rootplot.root2matplotlib.HistStack.errorbar(), python.rootplot.root2matplotlib.HistStack.errorbarh(), alignment.Alignment.getRepMap(), Formatter.SimpleHTMLFormatter.headers(), python.rootplot.root2matplotlib.HistStack.histstack(), presentation.SubsectionOnePage.pages(), presentation.SubsectionFromList.pages(), presentation.SummarySection.pages(), python.rootplot.root2matplotlib.Hist.show_titles(), python.rootplot.utilities.Hist.TGraph(), python.rootplot.utilities.Hist.TH1F(), python.rootplot.utilities.Hist2D.TH2F(), python.rootplot.root2matplotlib.Hist2D.TH2F(), and presentation.SubsectionBase.write().