tools Namespace Reference

Functions
def	addCrabInputFile (crabCfg, inputFile)
def	copyFilesFromCastor (castor_dir, output_dir, type='root')
def	copyFilesLocal (dir, output_dir, type='root')
def	create_single_iov_db (inputs, run_number, output_db)
def	dqmWorkflowName (datasetpath, type, rev=1)
def	get_iovs (db, tag)
def	get_process_object (cfg)
def	get_tags (global_tag, records)
def	getDatasetStr (datasetpath)
def	haddInCastor (castor_dir, result_file, type='root', prefix='rfio:', suffix=None)
def	haddLocal (dir, result_file, type='root')
def	listFilesInCastor (castor_dir, type='root', prefix='rfio:')
def	listFilesLocal (dir, type='root')
def	loadCmsProcess (psetPath)
def	loadCmsProcessFile (psetName)
def	loadCrabCfg (cfgName=None)
def	loadCrabDefault (crabCfg, config)
def	make_unique_runranges (ali_producer)
def	parseInput (inputFields, requiredFields=())
def	prependPaths (process, seqname)
def	replaceTemplate (template, opts)
def	run_checked (cmd, suppress_stderr=False)
def	setGridEnv (cmssw_dir)
def	writeCfg (process, dir, psetName)
def	writeCfgPkl (process, dir, psetName)

Function Documentation

def tools.addCrabInputFile	(		crabCfg,
			inputFile
	)

Definition at line 183 of file tools.py.

Referenced by DTDQMValidation.DTDQMValidation.initCrab(), DTAnalysisResiduals.DTAnalysisResiduals.initCrab(), DTTTrigValid.DTTTrigValid.initCrab(), DTResidualCalibration.DTResidualCalibration.initCrab(), DTVDriftSegmentCalibration.DTVDriftSegmentCalibration.initCrab(), and DTVDriftMeanTimerCalibration.DTVDriftMeanTimerCalibration.initCrab().

def addCrabInputFile(crabCfg,inputFile):
    additionalInputFiles = ''
    if crabCfg.has_option('USER','additional_input_files'):
        additionalInputFiles = crabCfg.get('USER','additional_input_files')

    if additionalInputFiles: additionalInputFiles += ',%s' % inputFile
    else: additionalInputFiles = inputFile

    crabCfg.set('USER','additional_input_files',additionalInputFiles)

    return crabCfg

def tools.copyFilesFromCastor	(		castor_dir,
			output_dir,
			type = 'root'
	)

Definition at line 55 of file tools.py.

References listFilesInCastor().

Referenced by DTCalibrationWorker.DTCalibrationWorker.runNoiseWorkflow().

def copyFilesFromCastor(castor_dir,output_dir,type='root'):
    from subprocess import call
    files = listFilesInCastor(castor_dir,type,'')

    print "Copying files from %s to %s" % (castor_dir,output_dir) 
    for item in files:
        cmd = ['rfcp',item,output_dir] 
        print "..." + item
        retcode = call(cmd)
        if retcode != 0: raise RuntimeError('Error in copying file %s to directory %s' % (item,output_dir))

    return 0

def tools.copyFilesLocal	(		dir,
			output_dir,
			type = 'root'
	)

Definition at line 68 of file tools.py.

References listFilesLocal().

Referenced by DTCalibrationWorker.DTCalibrationWorker.runNoiseWorkflow().

def copyFilesLocal(dir,output_dir,type='root'):
    if not dir: raise ValueError('Please specify valid dir')
    if not output_dir: raise ValueError('Please specify valid output dir')
  
    from subprocess import call
    files = listFilesLocal(dir,type)
    cmd = ['cp']
    cmd.extend(files)
    cmd.append(output_dir)
    print cmd 
    retcode = call(cmd)
    return retcode

def tools.create_single_iov_db	(		inputs,
			run_number,
			output_db
	)

Create an sqlite file with single-IOV tags for alignment payloads.

Arguments:
- `inputs`: dictionary with input needed for payload extraction
- `run_number`: run for which the IOVs are selected
- `output_db`: name of the output sqlite file

Definition at line 9 of file tools.py.

References join(), run_checked(), and harvestTrackValidationPlots.str.

def create_single_iov_db(inputs, run_number, output_db):
    """Create an sqlite file with single-IOV tags for alignment payloads.

    Arguments:
    - `inputs`: dictionary with input needed for payload extraction
    - `run_number`: run for which the IOVs are selected
    - `output_db`: name of the output sqlite file
    """

    # find the IOV containing `run_number`
    for record,tag in inputs.iteritems():
        run_is_covered = False
        for iov in reversed(tag["iovs"]):
            if iov <= run_number:
                tag["since"] = str(iov)
                run_is_covered = True
                break
        if not run_is_covered:
            msg = ("Run number {0:d} is not covered in '{1:s}' ({2:s}) from"
                   " '{3:s}'.".format(run_number, tag["tag"], record,
                                      global_tag))
            print msg
            print "Aborting..."
            sys.exit(1)

    result = {}
    if os.path.exists(output_db): os.remove(output_db)
    for record,tag in inputs.iteritems():
        result[record] = {"connect": "sqlite_file:"+output_db,
                          "tag": "_".join([tag["tag"], tag["since"]])}

        if tag["connect"] == "pro":
            source_connect = "frontier://FrontierProd/CMS_CONDITIONS"
        elif tag["connect"] == "dev":
            source_connect = "frontier://FrontierPrep/CMS_CONDITIONS"
        else:
            source_connect = tag["connect"]

        cmd = ("conddb_import",
               "-f", source_connect,
               "-c", result[record]["connect"],
               "-i", tag["tag"],
               "-t", result[record]["tag"],
               "-b", str(run_number),
               "-e", str(run_number))
        run_checked(cmd)
    if len(inputs) > 0:
        run_checked(["sqlite3", output_db, "update iov set since=1"])

    return result

def tools.dqmWorkflowName	(		datasetpath,
			type,
			rev = 1
	)

Definition at line 23 of file tools.py.

Referenced by DTDqm.DTDqm.initProcess(), and DTDQMHarvesting.DTDQMHarvesting.initProcess().

def dqmWorkflowName(datasetpath,type,rev=1):
    workflowName = datasetpath
    sections = workflowName.split('/')[1:]
    workflowName = '/%s/%s-%s-rev%d/%s' % (sections[0],sections[1],type,rev,sections[2])
    
    return workflowName 
   

def tools.get_iovs	(		db,
			tag
	)

Retrieve the list of IOVs from `db` for `tag`.

Arguments:
- `db`: database connection string
- `tag`: tag of database record

Definition at line 161 of file tools.py.

References Vispa.Plugins.EdmBrowser.EdmDataAccessor.all(), ALCARECOTkAlBeamHalo_cff.filter, createfilelist.int, and python.rootplot.root2matplotlib.replace().

def get_iovs(db, tag):
    """Retrieve the list of IOVs from `db` for `tag`.

    Arguments:
    - `db`: database connection string
    - `tag`: tag of database record
    """

    db = db.replace("sqlite_file:", "").replace("sqlite:", "")
    db = db.replace("frontier://FrontierProd/CMS_CONDITIONS", "pro")
    db = db.replace("frontier://FrontierPrep/CMS_CONDITIONS", "dev")

    con = conddb.connect(url = conddb.make_url(db))
    session = con.session()
    IOV = session.get_dbtype(conddb.IOV)

    iovs = set(session.query(IOV.since).filter(IOV.tag_name == tag).all())
    if len(iovs) == 0:
        print "No IOVs found for tag '"+tag+"' in database '"+db+"'."
        sys.exit(1)

    session.close()

    return sorted([int(item[0]) for item in iovs])

def tools.get_process_object

(

cfg

)

Returns cms.Process object defined in `cfg`.

Arguments:
- `cfg`: path to CMSSW config file

Definition at line 81 of file tools.py.

def get_process_object(cfg):
    """Returns cms.Process object defined in `cfg`.

    Arguments:
    - `cfg`: path to CMSSW config file
    """

    sys.path.append(os.path.dirname(cfg)) # add location to python path
    cache_stdout = sys.stdout
    sys.stdout = open(os.devnull, "w")    # suppress unwanted output
    try:
        __configuration = \
            importlib.import_module(os.path.splitext(os.path.basename(cfg))[0])
    except Exception as e:
        print "Problem detected in configuration file '{0}'.".format(cfg)
        raise e
    sys.stdout = cache_stdout
    sys.path.pop()                        # clean up python path again
    try:
        os.remove(cfg+"c")                # try to remove temporary .pyc file
    except OSError as e:
        if e.args == (2, "No such file or directory"): pass
        else: raise

    return __configuration.process

def tools.get_tags	(		global_tag,
			records
	)

Get tags for `records` contained in `global_tag`.

Arguments:
- `global_tag`: global tag of interest
- `records`: database records of interest

Definition at line 126 of file tools.py.

References Vispa.Plugins.EdmBrowser.EdmDataAccessor.all(), and ALCARECOTkAlBeamHalo_cff.filter.

def get_tags(global_tag, records):
    """Get tags for `records` contained in `global_tag`.

    Arguments:
    - `global_tag`: global tag of interest
    - `records`: database records of interest
    """

    if len(records) == 0: return {} # avoid useless DB query

    # check for auto GT
    if global_tag.startswith("auto:"):
        import Configuration.AlCa.autoCond as AC
        try:
            global_tag = AC.autoCond[global_tag.split("auto:")[-1]]
        except KeyError:
            print "Unsupported auto GT:", global_tag
            sys.exit(1)

    # setting up the DB session
    con = conddb.connect(url = conddb.make_url())
    session = con.session()
    GlobalTagMap = session.get_dbtype(conddb.GlobalTagMap)

    # query tag names for records of interest contained in `global_tag`
    tags = session.query(GlobalTagMap.record, GlobalTagMap.tag_name).\
           filter(GlobalTagMap.global_tag_name == global_tag,
                  GlobalTagMap.record.in_(records)).all()

    # closing the DB session
    session.close()

    return {item[0]: {"tag": item[1], "connect": "pro"} for item in tags}

def tools.getDatasetStr

(

datasetpath

)

Definition at line 15 of file tools.py.

Referenced by DTCalibrationWorker.DTCalibrationWorker.dqmOutputDir(), DTDQMMerge.DTDQMMerge.initProcess(), DTCalibrationWorker.DTCalibrationWorker.runAnalysisResiduals(), DTCalibrationWorker.DTCalibrationWorker.runNoiseWorkflow(), DTCalibrationWorker.DTCalibrationWorker.runResidualCalib(), DTCalibrationWorker.DTCalibrationWorker.runTtrigProd(), DTCalibrationWorker.DTCalibrationWorker.runTtrigValid(), DTCalibrationWorker.DTCalibrationWorker.runValidationWorkflow(), DTCalibrationWorker.DTCalibrationWorker.runVDriftMeanTimerCalib(), and DTCalibrationWorker.DTCalibrationWorker.runVDriftSegmentCalib().

def getDatasetStr(datasetpath):
    datasetstr = datasetpath
    datasetstr.strip()
    if datasetstr[0] == '/': datasetstr = datasetstr[1:]
    datasetstr = datasetstr.replace('/','_')

    return datasetstr

def tools.haddInCastor	(		castor_dir,
			result_file,
			type = 'root',
			prefix = 'rfio:',
			suffix = None
	)

Definition at line 81 of file tools.py.

References listFilesInCastor().

Referenced by DTCalibrationWorker.DTCalibrationWorker.runAnalysisResiduals(), DTCalibrationWorker.DTCalibrationWorker.runResidualCalib(), DTCalibrationWorker.DTCalibrationWorker.runTtrigProd(), DTCalibrationWorker.DTCalibrationWorker.runVDriftMeanTimerCalib(), and DTCalibrationWorker.DTCalibrationWorker.runVDriftSegmentCalib().

def haddInCastor(castor_dir,result_file,type = 'root',prefix = 'rfio:',suffix = None):
    if not castor_dir: raise ValueError('Please specify valid castor dir')
    if not result_file: raise ValueError('Please specify valid output file name')

    #cmd = 'hadd %s `./listfilesCastor %s | grep %s`'%(result_file,castor_dir,type)
    #print "Running",cmd
    #os.system(cmd)
    from subprocess import call
    files = listFilesInCastor(castor_dir,type,prefix)
    if suffix: files = [item + suffix for item in files]
 
    cmd = ['hadd',result_file]
    cmd.extend(files)
    #print cmd
    retcode = call(cmd)
    return retcode

def tools.haddLocal	(		dir,
			result_file,
			type = 'root'
	)

Definition at line 98 of file tools.py.

References listFilesLocal().

Referenced by DTCalibrationWorker.DTCalibrationWorker.runAnalysisResiduals(), DTCalibrationWorker.DTCalibrationWorker.runResidualCalib(), DTCalibrationWorker.DTCalibrationWorker.runTtrigProd(), DTCalibrationWorker.DTCalibrationWorker.runVDriftMeanTimerCalib(), and DTCalibrationWorker.DTCalibrationWorker.runVDriftSegmentCalib().

def haddLocal(dir,result_file,type = 'root'):
    if not dir: raise ValueError('Please specify valid dir')
    if not result_file: raise ValueError('Please specify valid output file name')

    from subprocess import call
    files = listFilesLocal(dir,type)
    cmd = ['hadd',result_file]
    cmd.extend(files)
    #print cmd
    retcode = call(cmd)
    return retcode

def tools.listFilesInCastor	(		castor_dir,
			type = 'root',
			prefix = 'rfio:'
	)

Definition at line 30 of file tools.py.

Referenced by copyFilesFromCastor(), haddInCastor(), DTDqm.runDQM(), DTDQMMerge.runDQM(), DTCalibrationWorker.DTCalibrationWorker.runDQMClient(), DTCalibrationWorker.DTCalibrationWorker.runDQMHarvesting(), and DTCalibrationWorker.DTCalibrationWorker.runDQMMerge().

def listFilesInCastor(castor_dir,type = 'root',prefix = 'rfio:'):
    if not castor_dir: raise ValueError('Please specify valid castor dir')

    from subprocess import Popen,PIPE
    p1 = Popen(['nsls',castor_dir],stdout=PIPE)
    #p2 = Popen(['grep',type],stdin=p1.stdout,stdout=PIPE)
    #files = [prefix + castor_dir + "/" + item[:-1] for item in p2.stdout]
    #p2.stdout.close()
    files = [ "%s%s/%s" % (prefix,castor_dir,item.rstrip()) for item in p1.stdout if item.find(type) != -1 ] 
    p1.stdout.close()
    return files

def tools.listFilesLocal	(		dir,
			type = 'root'
	)

Definition at line 42 of file tools.py.

Referenced by copyFilesLocal(), haddLocal(), DTCalibrationWorker.DTCalibrationWorker.runDQMClient(), DTCalibrationWorker.DTCalibrationWorker.runDQMHarvesting(), and DTCalibrationWorker.DTCalibrationWorker.runDQMMerge().

def listFilesLocal(dir,type = 'root'):
    if not dir: raise ValueError('Please specify valid dir')

    #from subprocess import Popen,PIPE
    #p1 = Popen(['ls',dir],stdout=PIPE)
    #p2 = Popen(['grep',type],stdin=p1.stdout,stdout=PIPE)
    #files = [dir + "/" + item[:-1] for item in p2.stdout]
    #p2.stdout.close()
    files = os.listdir(dir)
    files = [ "%s/%s" % (dir,item) for item in files if item.find(type) != -1 ]

    return files

def tools.loadCmsProcess

(

psetPath

)

Definition at line 144 of file tools.py.

Referenced by DTValidSummary.DTValidSummary.initProcess(), DTDqm.DTDqm.initProcess(), DTDQMMerge.DTDQMMerge.initProcess(), DTAnalysisResiduals.DTAnalysisResiduals.initProcess(), DTTTrigProd.DTTTrigProd.initProcess(), DTVDriftMeanTimerCalibration.DTVDriftMeanTimerCalibration.initProcess(), DTDQMHarvesting.DTDQMHarvesting.initProcess(), DTVDriftSegmentCalibration.DTVDriftSegmentCalibration.initProcess(), DTNoiseCalibration.DTNoiseCalibration.initProcess(), DTResidualCalibration.DTResidualCalibration.initProcess(), DTDQMValidation.DTDQMValidation.initProcess(), and DTTTrigValid.DTTTrigValid.initProcess().

def loadCmsProcess(psetPath):
    module = __import__(psetPath)
    process = sys.modules[psetPath].process

    import copy 
    #FIXME: clone process
    #processNew = copy.deepcopy(process)
    processNew = copy.copy(process) 
    return processNew

def tools.loadCmsProcessFile

(

psetName

)

Definition at line 140 of file tools.py.

def loadCmsProcessFile(psetName):
    pset = imp.load_source("psetmodule",psetName)
    return pset.process

def tools.loadCrabCfg

(

cfgName = None

)

Definition at line 178 of file tools.py.

Referenced by DTNoiseCalibration.DTNoiseCalibration.initCrab(), DTTTrigProd.DTTTrigProd.initCrab(), DTDQMValidation.DTDQMValidation.initCrab(), DTResidualCalibration.DTResidualCalibration.initCrab(), DTAnalysisResiduals.DTAnalysisResiduals.initCrab(), DTTTrigValid.DTTTrigValid.initCrab(), DTVDriftSegmentCalibration.DTVDriftSegmentCalibration.initCrab(), and DTVDriftMeanTimerCalibration.DTVDriftMeanTimerCalibration.initCrab().

def loadCrabCfg(cfgName=None):
    config = ConfigParser.ConfigParser()
    if cfgName: config.read(cfgName)
    return config

def tools.loadCrabDefault	(		crabCfg,
			config
	)

Definition at line 195 of file tools.py.

Referenced by DTNoiseCalibration.DTNoiseCalibration.initCrab(), DTTTrigProd.DTTTrigProd.initCrab(), DTDQMValidation.DTDQMValidation.initCrab(), DTResidualCalibration.DTResidualCalibration.initCrab(), DTAnalysisResiduals.DTAnalysisResiduals.initCrab(), DTTTrigValid.DTTTrigValid.initCrab(), DTVDriftSegmentCalibration.DTVDriftSegmentCalibration.initCrab(), and DTVDriftMeanTimerCalibration.DTVDriftMeanTimerCalibration.initCrab().

def loadCrabDefault(crabCfg,config):
    # CRAB section
    if not crabCfg.has_section('CRAB'): crabCfg.add_section('CRAB')
    crabCfg.set('CRAB','jobtype','cmssw')

    if hasattr(config,'scheduler') and config.scheduler: crabCfg.set('CRAB','scheduler',config.scheduler) 
    else: crabCfg.set('CRAB','scheduler','CAF')

    if hasattr(config,'useserver') and config.useserver: crabCfg.set('CRAB','use_server',1)

    # CMSSW section
    if not crabCfg.has_section('CMSSW'): crabCfg.add_section('CMSSW')
    if hasattr(config,'datasetpath') and config.datasetpath: crabCfg.set('CMSSW','datasetpath',config.datasetpath)
    else: crabCfg.set('CMSSW','datasetpath','/XXX/YYY/ZZZ') 
    crabCfg.set('CMSSW','pset','pset.py')

    # Splitting config
    crabCfg.remove_option('CMSSW','total_number_of_events')
    crabCfg.remove_option('CMSSW','events_per_job')
    crabCfg.remove_option('CMSSW','number_of_jobs')
    crabCfg.remove_option('CMSSW','total_number_of_lumis')
    crabCfg.remove_option('CMSSW','lumis_per_job')
    crabCfg.remove_option('CMSSW','lumi_mask')
    crabCfg.remove_option('CMSSW','split_by_run')
 
    """
    if hasattr(config,'totalnumberevents'): crabCfg.set('CMSSW','total_number_of_events',config.totalnumberevents)
    if hasattr(config,'eventsperjob'): crabCfg.set('CMSSW','events_per_job',config.eventsperjob) 
    """
    if hasattr(config,'splitByLumi') and config.splitByLumi:
        crabCfg.set('CMSSW','total_number_of_lumis',config.totalnumberlumis)
        crabCfg.set('CMSSW','lumis_per_job',config.lumisperjob)
        if hasattr(config,'lumimask') and config.lumimask: crabCfg.set('CMSSW','lumi_mask',config.lumimask)
    elif hasattr(config,'splitByEvent') and config.splitByEvent:
        crabCfg.set('CMSSW','total_number_of_events',config.totalnumberevents)
        crabCfg.set('CMSSW','events_per_job',config.eventsperjob)
    else:
        crabCfg.set('CMSSW','split_by_run',1)

    if hasattr(config,'splitByEvent') and config.splitByEvent:
        crabCfg.remove_option('CMSSW','runselection')
    else:
    if hasattr(config,'runselection') and config.runselection:
        crabCfg.set('CMSSW','runselection',config.runselection)

    # USER section
    if not crabCfg.has_section('USER'): crabCfg.add_section('USER')  

    # Stageout config
    if hasattr(config,'stageOutCAF') and config.stageOutCAF:
        crabCfg.set('USER','return_data',0)                
        crabCfg.set('USER','copy_data',1)  
        crabCfg.set('USER','storage_element','T2_CH_CAF')
        crabCfg.set('USER','user_remote_dir',config.userdircaf)
        crabCfg.set('USER','check_user_remote_dir',0)
    elif hasattr(config,'stageOutLocal') and config.stageOutLocal:
        crabCfg.set('USER','return_data',1)                
        crabCfg.set('USER','copy_data',0)
        crabCfg.remove_option('USER','storage_element')
        crabCfg.remove_option('USER','user_remote_dir')
        crabCfg.remove_option('USER','check_user_remote_dir')

    if hasattr(config,'email') and config.email: crabCfg.set('USER','eMail',config.email)
    crabCfg.set('USER','xml_report','crabReport.xml')

    if hasattr(config,'runOnGrid') and config.runOnGrid:
        crabCfg.remove_section('CAF')
        if hasattr(config,'ce_black_list'):
            if not crabCfg.has_section('GRID'): crabCfg.add_section('GRID')
            crabCfg.set('GRID','ce_black_list', config.ce_black_list)
        if hasattr(config,'ce_white_list'):
            if not crabCfg.has_section('GRID'): crabCfg.add_section('GRID')
            crabCfg.set('GRID','ce_white_list', config.ce_white_list)
    else:
        if not crabCfg.has_section('CAF'): crabCfg.add_section('CAF')
        crabCfg.set('CAF','queue',config.queueAtCAF) 
    
    return crabCfg

def tools.make_unique_runranges

(

ali_producer

)

Derive unique run ranges from AlignmentProducer PSet.

Arguments:
- `ali_producer`: cms.PSet containing AlignmentProducer configuration

Definition at line 108 of file tools.py.

References createfilelist.int.

def make_unique_runranges(ali_producer):
    """Derive unique run ranges from AlignmentProducer PSet.

    Arguments:
    - `ali_producer`: cms.PSet containing AlignmentProducer configuration
    """

    if (hasattr(ali_producer, "RunRangeSelection") and
        len(ali_producer.RunRangeSelection) > 0):
        iovs = set([int(iov)
                    for sel in ali_producer.RunRangeSelection
                    for iov in sel.RunRanges])
        if len(iovs) == 0: return [1] # single IOV starting from run 1
        return sorted(iovs)
    else:
        return [1]                    # single IOV starting from run 1

def tools.parseInput	(		inputFields,
			requiredFields = ()
	)

Definition at line 122 of file tools.py.

Referenced by edmStreamStallGrapher.readLogFile().

def parseInput(inputFields,requiredFields = ()):

    class options: pass
    for item in sys.argv:
        option = item.split('=')[0]
        if option in inputFields:
            value = item.split('=')[1]
            if value in ('true','True','yes','Yes'): value = True
            elif value in ('false','False','no','No'): value = False

            setattr(options,option,value)

    for item in requiredFields:
        if not hasattr(options,item):
            raise RuntimeError('Need to set "%s"' % item)

    return options

def tools.prependPaths	(		process,
			seqname
	)

Definition at line 154 of file tools.py.

Referenced by DTAnalysisResiduals.DTAnalysisResiduals.initProcess(), DTTTrigProd.DTTTrigProd.initProcess(), DTVDriftSegmentCalibration.DTVDriftSegmentCalibration.initProcess(), DTVDriftMeanTimerCalibration.DTVDriftMeanTimerCalibration.initProcess(), DTResidualCalibration.DTResidualCalibration.initProcess(), DTNoiseCalibration.DTNoiseCalibration.initProcess(), DTTTrigValid.DTTTrigValid.initProcess(), and DTDQMValidation.DTDQMValidation.initProcess().

def prependPaths(process,seqname):
    for path in process.paths: 
        getattr(process,path)._seq = getattr(process,seqname)*getattr(process,path)._seq

def tools.replaceTemplate	(		template,
			opts
	)

Definition at line 5 of file tools.py.

References harvestTrackValidationPlots.str.

def replaceTemplate(template,**opts):
    result = open(template).read()
    for item in opts:
         old = '@@%s@@'%item
         new = str(opts[item])
         print "Replacing",old,"to",new
         result = result.replace(old,new)

    return result
 

def tools.run_checked	(		cmd,
			suppress_stderr = False
	)

Run `cmd` and exit in case of failures.

Arguments:
- `cmd`: list containing the strings of the command
- `suppress_stderr`: suppress output from stderr

Definition at line 61 of file tools.py.

References join().

Referenced by create_single_iov_db().

def run_checked(cmd, suppress_stderr = False):
    """Run `cmd` and exit in case of failures.

    Arguments:
    - `cmd`: list containing the strings of the command
    - `suppress_stderr`: suppress output from stderr
    """

    try:
        with open(os.devnull, "w") as devnull:
            if suppress_stderr:
                subprocess.check_call(cmd, stdout = devnull, stderr = devnull)
            else:
                subprocess.check_call(cmd, stdout = devnull)
    except subprocess.CalledProcessError as e:
        print "Problem in running the following command:"
        print " ".join(e.cmd)
        sys.exit(1)

def tools.setGridEnv

(

cmssw_dir

)

Definition at line 110 of file tools.py.

def setGridEnv(cmssw_dir):
    cwd = os.getcwd()
    os.chdir(cmssw_dir)

    os.system('source /afs/cern.ch/cms/LCG/LCG-2/UI/cms_ui_env.sh')
    os.system('cmsenv')
    os.system('source /afs/cern.ch/cms/ccs/wm/scripts/Crab/crab.sh')
 
    os.chdir(cwd)
 
    return

def tools.writeCfg	(		process,
			dir,
			psetName
	)

Definition at line 158 of file tools.py.

References TriggerAnalyzer.write().

def writeCfg(process,dir,psetName):
    if not os.path.exists(dir): os.makedirs(dir)
    open(dir + '/' + psetName,'w').write(process.dumpPython())

def tools.writeCfgPkl	(		process,
			dir,
			psetName
	)

Definition at line 162 of file tools.py.

def writeCfgPkl(process,dir,psetName):
    if not os.path.exists(dir): os.makedirs(dir)

    pklFileName = psetName.split('.')[0] + '.pkl'
    pklFile = open(dir + '/' + pklFileName,"wb")
    myPickle = pickle.Pickler(pklFile)
    myPickle.dump(process)
    pklFile.close()
 
    outFile = open(dir + '/' + psetName,"w")
    outFile.write("import FWCore.ParameterSet.Config as cms\n")
    outFile.write("import pickle\n")
    outFile.write("process = pickle.load(open('%s', 'rb'))\n" % pklFileName)
    outFile.close()

---

Generated for CMSSW Reference Manual by  1.8.11