Ejemplo n.º 1
0
def setup_popcon( recordName, tagTimeType ):
    psetForOutRec = []
    psetForOutRec.append( cms.PSet( record = cms.string(str( recordName )),
                                    tag = cms.string(str( options.destinationTag )),
                                    timetype = cms.untracked.string(str(tagTimeType))
                                    )
                          )

    sqliteConnect = 'sqlite:%s' %popcon2dropbox.dbFileForDropBox
    process = cms.Process("PopCon")
    process.load("CondCore.CondDB.CondDB_cfi")
    process.CondDB.DBParameters.messageLevel = cms.untracked.int32( 3 )
    #process.CondDB.connect = 'sqlite:%s' %popcon2dropbox.dbFileForDropBox

    process.PoolDBOutputService = cms.Service("PoolDBOutputService",
                                              DBParameters = cms.PSet( messageLevel = cms.untracked.int32( 3 ),
                                                                       ),
                                              connect = cms.string( sqliteConnect ),
                                              toPut = cms.VPSet( psetForOutRec )
    )
    
    process.source = cms.Source("EmptyIOVSource",
                                timetype   = cms.string('runnumber'),
                                firstValue = cms.uint64(1),
                                lastValue  = cms.uint64(1),
                                interval   = cms.uint64(1)
    )
    return process
Ejemplo n.º 2
0
 vint4=cms.vint32(2147483647, -2147483647, 0),
 uint1=cms.uint32(4294967295),
 uint2=cms.untracked.uint32(0),
 vuint1=cms.vuint32(),
 vuint2=cms.vuint32(4294967295),
 vuint3=cms.vuint32(4294967295, 0),
 vuint4=cms.vuint32(4294967295, 0, 11),
 vuint5=cms.vuint32(4294967295, 0, 11, 21, 31, 41),
 int64v1=cms.int64(9000000000000000000),
 int64v2=cms.int64(-9000000000000000000),
 int64v3=cms.int64(0),
 vint64v1=cms.vint64(),
 vint64v2=cms.vint64(9000000000000000000),
 vint64v3=cms.vint64(9000000000000000000, -9000000000000000000),
 vint64v4=cms.vint64(9000000000000000000, -9000000000000000000, 0),
 uint64v1=cms.uint64(18000000000000000000),
 uint64v2=cms.untracked.uint64(0),
 vuint64v1=cms.vuint64(),
 vuint64v2=cms.vuint64(18000000000000000000),
 vuint64v3=cms.vuint64(18000000000000000000, 0),
 vuint64v4=cms.vuint64(18000000000000000000, 0, 11),
 doublev1=cms.double(2.2250738585072014e-308),
 doublev2=cms.untracked.double(0),
 doublev3=cms.untracked.double(0.3),
 vdoublev1=cms.vdouble(),
 vdoublev2=cms.vdouble(1e+300),
 vdoublev3=cms.vdouble(1e+300, 0),
 vdoublev4=cms.vdouble(1e+300, 0, 11),
 vdoublev5=cms.vdouble(1e+300, 0, 11, 0.3),
 boolv1=cms.bool(True),
 boolv2=cms.bool(False),
Ejemplo n.º 3
0
process.load("DQM.SiStripCommon.TkHistoMap_cfi")

process.TkDetMap = cms.Service("TkDetMap")
process.SiStripDetInfoFileReader = cms.Service("SiStripDetInfoFileReader")


#-------------------------------------------------
# DQM
#-------------------------------------------------
process.load("DQM.SiStripMonitorSummary.SiStripMonitorCondData_cfi")
process.load("CalibTracker.Configuration.Tracker_DependentRecords_forGlobalTag_nofakes_cff"
)

process.source = cms.Source("EmptyIOVSource",
                            lastValue = cms.uint64(216000),
                            timetype = cms.string('runnumber'),
                            firstValue = cms.uint64(216000),
                            interval = cms.uint64(1)
                            )


# the DB Geometry is NOT used because in this cfg only one tag is taken from the DB and no GT is used. To be fixed if this is a problem
process.load('Configuration.Geometry.GeometryExtended_cff')
process.TrackerTopologyEP = cms.ESProducer("TrackerTopologyEP")
process.load("Geometry.TrackerGeometryBuilder.trackerParameters_cfi")

process.a = cms.ESSource("PoolDBESSource",
   BlobStreamerName = cms.untracked.string('TBufferBlobStreamingService'),
   DBParameters = cms.PSet(
        messageLevel = cms.untracked.int32(2),
Ejemplo n.º 4
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("PIPPO")

process.source = cms.Source("EmptyIOVSource",
    timetype   = cms.string('runnumber'),
    firstValue = cms.uint64(123456),
    lastValue  = cms.uint64(123465),
    interval   = cms.uint64(1)
)


process.testSimpleEDMNtuple = cms.EDProducer(
    "TestSimpleEDMNtuple"
)


process.out = cms.OutputModule(
    "PoolOutputModule",
    fileName = cms.untracked.string('ntuple_edm.root'),
    outputCommands = cms.untracked.vstring(
      "drop *",
      "keep *_testSimpleEDMNtuple_*_*"      
    )
)

process.p = cms.Path(process.testSimpleEDMNtuple)
process.e = cms.EndPath(process.out)

		cms.bool(True)
process.HcalTPGCoderULUT.LUTGenerationMode = cms.bool(False)
process.emulTPDigis.FG_threshold = cms.uint32(2)
process.emulTPDigis.InputTagFEDRaw = rawTag
process.emulTPDigis.upgradeHF = cms.bool(True)
process.emulTPDigis.upgradeHE = cms.bool(True)
process.emulTPDigis.inputLabel = cms.VInputTag("hcalDigis", "hcalDigis")
process.emulTPDigis.inputUpgradeLabel = cms.VInputTag("hcalDigis", "hcalDigis")
# Enable ZS on emulated TPs, to match what is done in data
process.emulTPDigis.RunZS = cms.bool(True)
process.emulTPDigis.ZS_threshold = cms.uint32(0)
process.hcalDigis.InputLabel = rawTag
process.emulTPDigisNoTDCCut = process.emulTPDigis.clone()
process.emulTPDigisNoTDCCut.parameters = cms.untracked.PSet(
	ADCThresholdHF = cms.uint32(255),
	TDCMaskHF = cms.uint64(0xFFFFFFFFFFFFFFFF)
)


# Exclude the laser FEDs. They contaminate the QIE10/11 digi collections. 
#from Configuration.Eras.Modifier_run2_HCAL_2017_cff import run2_HCAL_2017
#run2_HCAL_2017.toModify(process.hcalDigis, FEDs=cms.untracked.vint32(724,725,726,727,728,729,730,731,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123))

#-------------------------------------
#	Hcal DQM Tasks and Harvesters import
#	New Style
#-------------------------------------
process.load("DQM.HcalTasks.DigiTask")
process.load('DQM.HcalTasks.TPTask')
process.load('DQM.HcalTasks.RawTask')
process.load('DQM.HcalTasks.NoCQTask')
# the N events must be specified in the maxEvents as usual but the
# first value, last value, timetype (runnumber, timestamp or lumiid) must be specified
# in the EmptyIOVSource configuration block. It will then generate events with the given
# interval.
# To generate one event per run in a given range of runs you should then use:
# - first - last value as the run range
# - interval == 1 (means move of one run unit at a time)
# - maxEvents = lastValue - firstValue (so that there is one event per run
# otherwise it will stop before completing the range or it will go beyond (to infinity).

process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(5)
)
process.source = cms.Source("EmptyIOVSource",
    timetype   = cms.string('runnumber'),
    firstValue = cms.uint64(97),
    lastValue  = cms.uint64(102),
    interval = cms.uint64(1)
)

process.load("CalibTracker.SiStripESProducers.SiStripDelayESProducer_cfi")

# Need to specify the Record for each BaseDelay.
# Optionally the Label associated to the tag can also be specified (default = "").
process.siStripDelayESProducer.ListOfRecordToMerge = cms.VPSet(
   cms.PSet(
       Record = cms.string('SiStripBaseDelayRcd'),
       Label = cms.string('baseDelay1'),
       SumSign = cms.int32(1)
   ),
   cms.PSet(
Ejemplo n.º 7
0
process = cms.Process("TESTC")

process.HeavyIonGlobalParameters = cms.PSet(
    centralitySrc = cms.InputTag("hiCentrality"),
    centralityVariable = cms.string("HFhits"),
    nonDefaultGlauberModel = cms.string("")
    )

process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag = 'GR_R_39X_V1::All'

from CmsHi.Analysis2010.CommonFunctions_cff import *
overrideCentrality(process)

process.source = cms.Source("EmptyIOVSource",
                            timetype = cms.string("runnumber"),
                            firstValue = cms.uint64(151076),
                            lastValue = cms.uint64(151076),
                            interval = cms.uint64(1)
                            )

process.analyze = cms.EDAnalyzer("AnalyzerWithCentrality")

process.TFileService = cms.Service('TFileService',
                                   fileName = cms.string("histogramsAndTable.root")
                                   )

process.p = cms.Path(process.analyze)

Ejemplo n.º 8
0
import FWCore.ParameterSet.Types as CfgTypes
import FWCore.ParameterSet.Config as cms
process = cms.Process("TTHAnalyzer")

xsecTT_SL = 107.66
xsecTT_FL = 25.81
xsecTT_FH = 112.33

process.fwliteInput = cms.PSet(
    outFileName   = cms.string("output.root"),
    pathToFile    = cms.string("/data/shared/Long_Exercise_tth/"),
    ordering      = cms.string(""),
    firstEvent    = cms.uint64(0),
    lastEvent    = cms.uint64(0),
    samples = cms.VPSet([
        cms.PSet(
            name     = cms.string("TTH125"),
            nickName = cms.string("TTH125"),
            color    = cms.int32(1),
            xSec     = cms.double(0.1302*0.569),
            ngen    = cms.double(433891.09375),
        ),
        cms.PSet(
            name     = cms.string("TTJetsFullLept"),
            nickName = cms.string("TTJetsFullLept"),
            color    = cms.int32(2),
            xSec     = cms.double(xsecTT_FL),
            ngen    = cms.double(11684417.0),
        ),
        cms.PSet(
            name     = cms.string("TTJetsSemiLept"),
process.load('Configuration.StandardSequences.MagneticField_38T_PostLS1_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff')
process.load('Configuration.StandardSequences.Services_cff')

from Configuration.AlCa.GlobalTag_condDBv2 import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'GR_P_V56', '')

process.options   = cms.untracked.PSet(
      wantSummary = cms.untracked.bool(True),
      SkipEvent = cms.untracked.vstring('ProductNotFound'),
)
process.MessageLogger.cerr.FwkReport.reportEvery = 1000

process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(1) )

process.TFileService = cms.Service("TFileService",  
          fileName = cms.string('geom_fwlite.root') 
) 

process.source = cms.Source("EmptyIOVSource", #LQ: I guess the alignement may depend on the run number
    timetype   = cms.string('runnumber'),
    interval   = cms.uint64(1),
    firstValue = cms.uint64(251252),
    lastValue  = cms.uint64(251253)
)


process.GeomDumper = cms.EDAnalyzer("GeomDumpForFWLite") 
process.DumpPath = cms.Path(process.GeomDumper)
process.schedule = cms.Schedule(process.DumpPath)
Ejemplo n.º 10
0
import FWCore.ParameterSet.Config as cms
from CondCore.CondDB.CondDB_cfi import *
import CondTools.Ecal.conddb_init as conddb_init

process = cms.Process("EcalADCToGeVConstantPopulator")

process.MessageLogger = cms.Service(
    "MessageLogger",
    destinations=cms.untracked.vstring("cout"),
    cout=cms.untracked.PSet(threshold=cms.untracked.string("INFO")))

process.source = cms.Source(
    "EmptyIOVSource",
    lastValue=cms.uint64(conddb_init.options.runNumber),
    timetype=cms.string('runnumber'),
    firstValue=cms.uint64(conddb_init.options.runNumber),
    interval=cms.uint64(1))

CondDBConnection = CondDB.clone(
    connect=cms.string(conddb_init.options.destinationDatabase))

process.PoolDBOutputService = cms.Service(
    "PoolDBOutputService",
    CondDBConnection,
    toPut=cms.VPSet(
        cms.PSet(record=cms.string("EcalADCToGeVConstantRcd"),
                 tag=cms.string(conddb_init.options.destinationTag))))

process.popConEcalADCToGeVConstant = cms.EDAnalyzer(
    "EcalADCToGeVConstantPopConBTransitionAnalyzer",
    SinceAppendMode=cms.bool(True),
Ejemplo n.º 11
0
import FWCore.ParameterSet.Config as cms
process = cms.Process("TEST")
process.source = cms.Source("EmptyIOVSource",
                            timetype=cms.string('lumiid'),
                            firstValue=cms.uint64((1211 << 32) + 1),
                            lastValue=cms.uint64((1211 << 32) + 8),
                            interval=cms.uint64(2))
process.emulTPDigis.FrontEndFormatError = \
  cms.bool(True)
process.HcalTPGCoderULUT.LUTGenerationMode = cms.bool(False)
process.emulTPDigis.FG_threshold = cms.uint32(2)
process.emulTPDigis.InputTagFEDRaw = rawTag
process.emulTPDigis.upgradeHF = cms.bool(True)
process.emulTPDigis.upgradeHE = cms.bool(True)
process.emulTPDigis.inputLabel = cms.VInputTag("hcalDigis", "hcalDigis")
process.emulTPDigis.inputUpgradeLabel = cms.VInputTag("hcalDigis", "hcalDigis")
# Enable ZS on emulated TPs, to match what is done in data
process.emulTPDigis.RunZS = cms.bool(True)
process.emulTPDigis.ZS_threshold = cms.uint32(0)
process.hcalDigis.InputLabel = rawTag
process.emulTPDigisNoTDCCut = process.emulTPDigis.clone()
process.emulTPDigisNoTDCCut.parameters = cms.untracked.PSet(
    ADCThresholdHF=cms.uint32(255), TDCMaskHF=cms.uint64(0xFFFFFFFFFFFFFFFF))

# For sent-received comparison
process.load("L1Trigger.Configuration.L1TRawToDigi_cff")
# For heavy ion runs, need to reconfigure sources for L1TRawToDigi
if isHeavyIon:
    process.csctfDigis.producer = cms.InputTag("rawDataRepacker")
    process.dttfDigis.DTTF_FED_Source = cms.InputTag("rawDataRepacker")
    process.twinMuxStage2Digis.DTTM7_FED_Source = cms.InputTag(
        "rawDataRepacker")
    process.omtfStage2Digis.inputLabel = cms.InputTag("rawDataRepacker")
    process.caloStage1Digis.InputLabel = cms.InputTag("rawDataRepacker")  #new
    process.bmtfDigis.InputLabel = cms.InputTag("rawDataRepacker")
    process.emtfStage2Digis.InputLabel = cms.InputTag("rawDataRepacker")
    process.caloLayer1Digis.InputLabel = cms.InputTag(
        "rawDataRepacker")  #not sure
Ejemplo n.º 13
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("Demo")

process.load("FWCore.MessageService.MessageLogger_cfi")

process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1000))

process.source = cms.Source(
    "PoolSource",
    fileNames=cms.untracked.vstring("file:MuAlZMuMu-2016H-002590494DA0.root"))

process.demo = cms.EDAnalyzer(
    "DemoAnalyzer",
    tracks=cms.uint64(tracks.pointer()),  # pass the arrays to C++ as a pointer
    hits=cms.uint64(hits.pointer()))

process.p = cms.Path(process.demo)

# run it in Python

import threading
import libFWCorePythonFramework
import libFWCorePythonParameterSet


class CMSSWThread(threading.Thread):
    def __init__(self, process):
        super(CMSSWThread, self).__init__()
        self.process = process
Ejemplo n.º 14
0
process = cms.Process("BadChannelMerge")
process.MessageLogger = cms.Service(
    "MessageLogger",
    cout=cms.untracked.PSet(threshold=cms.untracked.string('INFO')),
    destinations=cms.untracked.vstring('cout'))
process.load("Configuration.Geometry.GeometryRecoDB_cff")

process.load(
    'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')

from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_data', '')

process.source = cms.Source("EmptyIOVSource",
                            firstValue=cms.uint64(258714),
                            lastValue=cms.uint64(258714),
                            timetype=cms.string('runnumber'),
                            interval=cms.uint64(1))

process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(-1))
process.load(
    "CalibTracker.SiStripESProducers.SiStripBadModuleFedErrESSource_cfi")
from CalibTracker.SiStripESProducers.SiStripBadModuleFedErrESSource_cfi import siStripBadModuleFedErrESSource
siStripBadModuleFedErrESSource.appendToDataLabel = cms.string(
    'BadModules_from_FEDBadChannel')
siStripBadModuleFedErrESSource.FileName = cms.string(
    '/afs/cern.ch/user/d/dutta/work/public/BadChannel/DQM_V0001_R000260576__ZeroBias__Run2015D-PromptReco-v4__DQMIO.root'
)

process.siStripQualityESProducer.ListOfRecordToMerge = cms.VPSet(
Ejemplo n.º 15
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("L1ConfigWritePayloadDummy")

###################### user choices ######################

testKeyL1Menu = cms.string(
    'L1Menu_Commissioning2009_v7/L1T_Scales_20080926_startup/Imp0/0x100f')

###################### end user choices ###################

# number of events and source
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1))
process.source = cms.Source("EmptyIOVSource",
                            timetype=cms.string('runnumber'),
                            firstValue=cms.uint64(4294967295),
                            lastValue=cms.uint64(4294967295),
                            interval=cms.uint64(1))

# Generate dummy L1TriggerKeyList
process.load("CondTools.L1Trigger.L1TriggerKeyListDummy_cff")

# Get configuration data from OMDS.  This is the subclass of L1ConfigOnlineProdBase.
process.load("L1TriggerConfig.L1GtConfigProducers.l1GtTriggerMenuOnline_cfi")

from CondTools.L1Trigger.L1CondDBPayloadWriter_cff import initPayloadWriter
initPayloadWriter(process)
process.L1CondDBPayloadWriter.writeL1TriggerKey = cms.bool(False)

process.load("CondTools.L1Trigger.L1TriggerKeyDummy_cff")
process.L1TriggerKeyDummy.objectKeys = cms.VPSet(
Ejemplo n.º 16
0
                              destinations=cms.untracked.vstring("cout")#,
                              #cout=cms.untracked.PSet(
                              #treshold=cms.untracked.string("INFO")
                              #)
)

##process.load("CondCore.DBCommon.CondDBSetup_cfi")
#from CondCore.DBCommon.CondDBSetup_cfi import *

process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag = 'GR_H_V22::All'
process.GlobalTag.pfnPrefix=cms.untracked.string('frontier://FrontierProd/')

process.source = cms.Source("EmptyIOVSource",
    timetype = cms.string('runnumber'),
    firstValue = cms.uint64(177730),
    lastValue  = cms.uint64(177731),
    interval = cms.uint64(1)
)


#records = ["EcalADCToGeVConstant","EcalChannelStatus","EcalGainRatios","EcalTBWeights","EcalWeightXtalGroups","EcalIntercalibConstants","EcalIntercalibErrors","EcalIntercalibConstantsMC"]
#
#source = []
#
#for i in range (len(records)) :
#
#        recordname = records[i] + 'Rcd'
#        filename   = 'sqlite_file:test' + records[i] + '.db'
#
#        source.append(cms.ESSource("PoolDBESSource",
import FWCore.ParameterSet.Config as cms

process = cms.Process('test')


process.source = cms.Source("EmptyIOVSource",
    timetype = cms.string('runnumber'),
    firstValue = cms.uint64(1),
    lastValue = cms.uint64(1),
    interval = cms.uint64(1)
)


# load the alignment xml file
process.load("CondFormats.CTPPSReadoutObjects.ctppsRPAlignmentCorrectionsDataESSourceXML_cfi")
#process.ctppsRPAlignmentCorrectionsDataESSourceXML.XMLFile = cms.string("CondFormats/CTPPSReadoutObjects/xml/sample_alignment_corrections.xml")
process.ctppsRPAlignmentCorrectionsDataESSourceXML.RealFiles = cms.vstring("CondFormats/CTPPSReadoutObjects/xml/sample_alignment_corrections.xml")
process.ctppsRPAlignmentCorrectionsDataESSourceXML.MeasuredFiles = cms.vstring("CondFormats/CTPPSReadoutObjects/xml/sample_alignment_corrections.xml")
process.ctppsRPAlignmentCorrectionsDataESSourceXML.MisalignedFiles = cms.vstring("CondFormats/CTPPSReadoutObjects/xml/sample_alignment_corrections.xml")


#Database output service
process.load("CondCore.CondDB.CondDB_cfi")
# output database (in this case local sqlite file)
process.CondDB.connect = 'sqlite_file:CTPPSRPAlignment.db'


process.PoolDBOutputService = cms.Service("PoolDBOutputService",
    process.CondDB,
    timetype = cms.untracked.string('runnumber'),
    toPut = cms.VPSet(
Ejemplo n.º 18
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("TEST")
process.source = cms.Source("EmptyIOVSource",
                            lastValue=cms.uint64(4532789567110001000),
                            timetype=cms.string('Time'),
                            firstValue=cms.uint64(4532789567110000000),
                            interval=cms.uint64(20))

process.PoolDBOutputService = cms.Service(
    "PoolDBOutputService",
    DBParameters=cms.PSet(messageLevel=cms.untracked.int32(0),
                          authenticationPath=cms.untracked.string('.')),
    timetype=cms.untracked.string('Time'),
    connect=cms.string('sqlite_file:test.db'),
    toPut=cms.VPSet(
        cms.PSet(record=cms.string('PedestalsRcd'), tag=cms.string('mytest'))))

process.mytest = cms.EDAnalyzer("Timestamp", record=cms.string('PedestalsRcd'))

process.p = cms.Path(process.mytest)
import FWCore.ParameterSet.Config as cms

RPCTwinMuxLinkMapPopConAnalyzer = cms.EDAnalyzer('RPCTwinMuxLinkMapPopConAnalyzer'
                                                 , record = cms.string('RPCTwinMuxLinkMapRcd')
                                                 , Source = cms.PSet(
                                                     identifier = cms.string('RPCTwinMuxLinkMapHandler')
                                                     , dataTag = cms.string('RPCTwinMuxLinkMap_v1')
                                                     , sinceRun = cms.uint64(1)
                                                     # File provided by K. Bunkowski
                                                     , inputFile = cms.FileInPath('CondTools/RPC/data/RPCTwinMuxLinkMapInput.txt')
                                                     , wheelFED = cms.vint32(1395, 1391, 1390, 1393, 1394)
                                                     , wheelSectorAMC = cms.vint64(0x123456789ABC, 0x123456789ABC, 0x123456789ABC, 0x123456789ABC, 0x123456789ABC)
                                                     , txtFile = cms.untracked.string('')
                                                 )
)
Ejemplo n.º 20
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("PVSSIDReader")
process.load("CondCore.DBCommon.CondDBCommon_cfi")

process.CondDBCommon.connect = 'sqlite_file:PVSStoID.db'
process.CondDBCommon.DBParameters.authenticationPath = './'

process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(-1))

process.source = cms.Source("EmptyIOVSource",
                            timetype=cms.string('timestamp'),
                            firstValue=cms.uint64(1233913599),
                            lastValue=cms.uint64(1233913599),
                            interval=cms.uint64(1))

process.rn = cms.ESSource("PoolDBESSource",
                          process.CondDBCommon,
                          timetype=cms.string('timestamp'),
                          toGet=cms.VPSet(
                              cms.PSet(record=cms.string('RPCObPVSSmapRcd'),
                                       tag=cms.string('Imon_v3'))))

process.prod = cms.EDAnalyzer("PVSSIDReader")
process.p = cms.Path(process.prod)
import FWCore.ParameterSet.Config as cms

process = cms.Process("CALIB")
process.MessageLogger = cms.Service("MessageLogger",
    log_O2O = cms.untracked.PSet(
        threshold = cms.untracked.string('INFO')
    ),
    destinations = cms.untracked.vstring('log_O2O.txt')
)

process.source = cms.Source("EmptyIOVSource",
    timetype = cms.string('runnumber'),
    firstValue= cms.uint64(66615), 
    lastValue= cms.uint64(70674),
    interval = cms.uint64(1)
)

process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(30000)
)

#-------------------------------------------------
# Calibration
#-------------------------------------------------
process.load("CondCore.DBCommon.CondDBCommon_cfi")
process.CondDBCommon.connect='frontier://FrontierProd/CMS_COND_21X_STRIP'
process.poolDBESSource=cms.ESSource("PoolDBESSource",
                                    process.CondDBCommon,
                                    BlobStreamerName=cms.untracked.string('TBufferBlobStreamingService'),
                                    toGet           =cms.VPSet(
    cms.PSet(
Ejemplo n.º 22
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("DQM")
process.load("FWCore.MessageLogger.MessageLogger_cfi")

process.load("CondCore.CondDB.CondDB_cfi")
process.BeamSpotDBSource = cms.ESSource(
    "PoolDBESSource",
    process.CondDB,
    toGet=cms.VPSet(
        cms.PSet(record=cms.string('BeamSpotOnlineLegacyObjectsRcd'),
                 tag=cms.string("BeamSpotOnlineLegacy"),
                 refreshTime=cms.uint64(2)),
        cms.PSet(record=cms.string('BeamSpotOnlineHLTObjectsRcd'),
                 tag=cms.string("BeamSpotOnlineHLT"),
                 refreshTime=cms.uint64(2)),
    ),
)
process.BeamSpotDBSource.connect = cms.string(
    'frontier://FrontierProd/CMS_CONDITIONS')
import RecoVertex.BeamSpotProducer.onlineBeamSpotESProducer_cfi as _mod
process.BeamSpotESProducer = _mod.onlineBeamSpotESProducer.clone(
    timeThreshold=
    999999  # for express allow >48h old payloads for replays. DO NOT CHANGE
)

# initialize MessageLogger
process.load("FWCore.MessageLogger.MessageLogger_cfi")

process.MessageLogger.cerr = cms.untracked.PSet(
    enable=cms.untracked.bool(False))
import FWCore.ParameterSet.Config as cms

process = cms.Process("ICALIB")
process.load("DQMServices.Core.DQMStore_cfg")

process.MessageLogger = cms.Service("MessageLogger",
    debugModules = cms.untracked.vstring('*'),
    cout = cms.untracked.PSet(
        threshold = cms.untracked.string('INFO')
    ),
    destinations = cms.untracked.vstring('cout')
)

process.source = cms.Source("EmptyIOVSource",
    firstValue = cms.uint64(146437),
    lastValue = cms.uint64(146437),
    timetype = cms.string('runnumber'),
    interval = cms.uint64(1)
)

process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(1)
)

process.load("Configuration.StandardSequences.Geometry_cff")

process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
process.GlobalTag.globaltag = "GR_E_V13::All" #GR09_R_34X_V2

#to read information of o2o and cabling
process.BadComponentsOnline = cms.ESSource("PoolDBESSource",
Ejemplo n.º 24
0
printPsbSetup = True
#printPsbSetup = False

##########################################################################################

# process

processName = "L1GtTester"
process = cms.Process(processName)

# number of events and source
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1))

process.source = cms.Source("EmptyIOVSource",
                            timetype=cms.string('runnumber'),
                            firstValue=cms.uint64(useRunNumber),
                            lastValue=cms.uint64(useRunNumber),
                            interval=cms.uint64(1))

# import standard configurations, load and configure modules via Global Tag
# https://twiki.cern.ch/twiki/bin/view/CMS/SWGuideFrontierConditions
# retrieve also the HLT menu

process.load('Configuration.StandardSequences.Services_cff')
process.load('FWCore.MessageService.MessageLogger_cfi')
process.load(
    'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')

process.GlobalTag.globaltag = useGlobalTag + '::All'

# records to be printed
                 , VarParsing.VarParsing.varType.string
                 , "Output Data Tag")
options.parseArguments()

process = cms.Process("RPCDCCLinkMapPopConAnalyzer")

process.load("FWCore.MessageService.MessageLogger_cfi")
process.load("CondTools.RPC.RPCDCCLinkMapPopConAnalyzer_cff")

process.CondDB.connect = 'sqlite_file:data/RPCLinkMap.db'
process.RPCDCCLinkMapPopConAnalyzer.Source.dataTag = options.tag;
process.RPCDCCLinkMapPopConAnalyzer.Source.txtFile = cms.untracked.string("RPCDCCLinkMap.txt");

process.source = cms.Source("EmptyIOVSource"
                            , timetype = cms.string('runnumber')
                            , firstValue = cms.uint64(options.sinceRun)
                            , lastValue = cms.uint64(options.sinceRun)
                            , interval = cms.uint64(1)
)

process.MessageLogger.destinations.append("RPCDCCLinkMapPopConAnalyzer_log")
process.MessageLogger.RPCDCCLinkMapPopConAnalyzer_log = cms.untracked.PSet(
    threshold = cms.untracked.string("INFO")
    , FwkReport = cms.untracked.PSet(
        reportEvery = cms.untracked.int32(1)
    )
)

process.MessageLogger.cout.threshold = cms.untracked.string("INFO")

process.PoolDBOutputService = cms.Service("PoolDBOutputService"
Ejemplo n.º 26
0
ivars.register('end',
               mult=ivars.multiplicity.singleton,
               mytype=ivars.varType.int,
               info="for testing")

ivars.parseArguments()
import FWCore.ParameterSet.Config as cms

process = cms.Process("Demo")
process.load("CondCore.DBCommon.CondDBCommon_cfi")
process.load("FWCore.MessageService.MessageLogger_cfi")
process.CondDBCommon.connect = "sqlite_file:" + ivars.outputFile
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1))

process.source = cms.Source("EmptyIOVSource",
                            firstValue=cms.uint64(ivars.begin),
                            lastValue=cms.uint64(ivars.end),
                            timetype=cms.string('runnumber'),
                            interval=cms.uint64(1))

process.PoolDBOutputService = cms.Service(
    "PoolDBOutputService",
    process.CondDBCommon,
    timetype=cms.untracked.string("runnumber"),
    toPut=cms.VPSet(
        cms.PSet(record=cms.string('HeavyIonRPRcd'),
                 tag=cms.string(ivars.outputTag))),
    loadBlobStreamer=cms.untracked.bool(False))

process.MoveFlatParamsToDB = cms.EDAnalyzer(
    'MoveFlatParamsToDB',
Ejemplo n.º 27
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("MagneticFieldWriter")
process.load("CondCore.DBCommon.CondDBCommon_cfi")

# This will read all the little XML files and from
# that fill the DDCompactView. The modules that fill
# the reco part of the database need the DDCompactView.
#process.load('Configuration.Geometry.MagneticFieldGeometry_cff')

#GEOMETRY_VERSION = 90322
#GEOMETRY_VERSION = 120812
GEOMETRY_VERSION = 130503

process.source = cms.Source("EmptyIOVSource",
                            lastValue = cms.uint64(1),
                            timetype = cms.string('runnumber'),
                            firstValue = cms.uint64(1),
                            interval = cms.uint64(1)
                            )

# This reads the big XML file and the only way to fill the
# nonreco part of the database is to read this file.  It
# somewhat duplicates the information read from the little
# XML files, but there is no way to directly build the
# DDCompactView from this.
process.XMLGeometryWriter = cms.EDAnalyzer("XMLGeometryBuilder",
                                           XMLFileName = cms.untracked.string("./mfGeometry_"+str(GEOMETRY_VERSION)+".xml"),
                                           ZIP = cms.untracked.bool(True),
                                           record = cms.untracked.string('MFGeometryFileRcd')
                                           )
Ejemplo n.º 28
0
		cms.bool(True)
process.HcalTPGCoderULUT.LUTGenerationMode = cms.bool(False)
process.emulTPDigis.FG_threshold = cms.uint32(2)
process.emulTPDigis.InputTagFEDRaw = rawTag
process.emulTPDigis.upgradeHF = cms.bool(True)
process.emulTPDigis.upgradeHE = cms.bool(True)
process.emulTPDigis.inputLabel = cms.VInputTag("hcalDigis", "hcalDigis")
process.emulTPDigis.inputUpgradeLabel = cms.VInputTag("hcalDigis", "hcalDigis")
# Enable ZS on emulated TPs, to match what is done in data
process.emulTPDigis.RunZS = cms.bool(True)
process.emulTPDigis.ZS_threshold = cms.uint32(0)
process.hcalDigis.InputLabel = rawTag
process.emulTPDigisNoTDCCut = process.emulTPDigis.clone()
process.emulTPDigisNoTDCCut.parameters = cms.untracked.PSet(
	ADCThresholdHF = cms.uint32(255),
	TDCMaskHF = cms.uint64(0xFFFFFFFFFFFFFFFF)
)

# For sent-received comparison
process.load("L1Trigger.Configuration.L1TRawToDigi_cff")
# For heavy ion runs, need to reconfigure sources for L1TRawToDigi
if isHeavyIon:
	process.csctfDigis.producer = cms.InputTag("rawDataRepacker")
	process.dttfDigis.DTTF_FED_Source = cms.InputTag("rawDataRepacker")
	process.twinMuxStage2Digis.DTTM7_FED_Source = cms.InputTag("rawDataRepacker")
	process.omtfStage2Digis.inputLabel = cms.InputTag("rawDataRepacker")
	process.caloStage1Digis.InputLabel = cms.InputTag("rawDataRepacker") #new
	process.bmtfDigis.InputLabel = cms.InputTag("rawDataRepacker")
	process.emtfStage2Digis.InputLabel = cms.InputTag("rawDataRepacker")
	process.caloLayer1Digis.InputLabel = cms.InputTag("rawDataRepacker") #not sure
	process.caloStage2Digis.InputLabel = cms.InputTag("rawDataRepacker")
Ejemplo n.º 29
0
# PoolDBOutputService for printing out ESRecords
if options.printRSKeys == 1:
    from CondTools.L1TriggerExt.L1RSSubsystemParamsExt_cfi import initL1RSSubsystemsExt
    initL1RSSubsystemsExt( tagBaseVec = initL1O2OTagsExt.tagBaseVec )
    outputDB.toPut.extend(initL1RSSubsystemsExt.params.recordInfo)

process.add_(outputDB)
    
# Source of events
process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(1)
)
process.source = cms.Source("EmptyIOVSource",
    timetype = cms.string('runnumber'),
    firstValue = cms.uint64(options.runNumber),
    lastValue = cms.uint64(options.runNumber),
    interval = cms.uint64(1)
)

# Validation modules
process.load('CondTools.L1TriggerExt.L1O2OTestAnalyzerExt_cfi')
process.L1O2OTestAnalyzerExt.printPayloadTokens = False

if options.printL1TriggerKeyExt == 1:
    process.L1O2OTestAnalyzerExt.printL1TriggerKeyExt = True
else:
    process.L1O2OTestAnalyzerExt.printL1TriggerKeyExt = False

if options.printL1TriggerKeyListExt == 1:
    process.L1O2OTestAnalyzerExt.printL1TriggerKeyListExt = True
Ejemplo n.º 30
0
# CALIBRATION
#-------------------------------------------------
###process.load("DQM.SiStripMonitorSummary.Tags21X_cff")

process.load("DQM.SiStripCommon.TkHistoMap_cff")


#-------------------------------------------------
# DQM
#-------------------------------------------------
process.load("DQM.SiStripMonitorSummary.SiStripMonitorCondData_cfi")
process.load("CalibTracker.Configuration.Tracker_DependentRecords_forGlobalTag_nofakes_cff"
)

process.source = cms.Source("EmptyIOVSource",
                            lastValue = cms.uint64(216000),
                            timetype = cms.string('runnumber'),
                            firstValue = cms.uint64(216000),
                            interval = cms.uint64(1)
                            )


# the DB Geometry is NOT used because in this cfg only one tag is taken from the DB and no GT is used. To be fixed if this is a problem
process.load('Configuration.Geometry.GeometryExtended_cff')
process.TrackerTopologyEP = cms.ESProducer("TrackerTopologyEP")
process.load("Geometry.TrackerGeometryBuilder.trackerParameters_cfi")

process.a = cms.ESSource("PoolDBESSource",
   BlobStreamerName = cms.untracked.string('TBufferBlobStreamingService'),
   DBParameters = cms.PSet(
        messageLevel = cms.untracked.int32(2),
Ejemplo n.º 31
0
process.MessageLogger = cms.Service("MessageLogger",
    statistics = cms.untracked.vstring(),
    destinations = cms.untracked.vstring('cout'),
    cout = cms.untracked.PSet(
        threshold = cms.untracked.string('INFO')
    )
)

# load alignment correction
#process.load("Geometry.VeryForwardGeometryBuilder.ctppsIncludeAlignmentsFromXML_cfi")
#process.ctppsIncludeAlignmentsFromXML.RealFiles = cms.vstring("Geometry/VeryForwardGeometryBuilder/test/sample_alignment_corrections.xml")

# no events to process
process.source = cms.Source("EmptyIOVSource",
    timetype = cms.string('runnumber'),
    firstValue = cms.uint64(runno),
    lastValue = cms.uint64(runno),
    interval = cms.uint64(1)
)
process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(1)
)

#Database output service
process.load("CondCore.CondDB.CondDB_cfi")
# input database (in this case local sqlite file)
process.CondDB.connect = 'sqlite_file:CTPPSRPRealAlignment_table.db'

process.PoolDBESSource = cms.ESSource("PoolDBESSource",
    process.CondDB,
    DumpStat=cms.untracked.bool(True),
Ejemplo n.º 32
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("ProcessOne")

process.load("CondCore.DBCommon.CondDBCommon_cfi")
# process.CondDBCommon.connect = 'oracle://cms_orcoff_prep/CMS_COND_ECAL'
process.CondDBCommon.DBParameters.authenticationPath = '/afs/cern.ch/cms/DB/conddb/'
process.CondDBCommon.connect = 'sqlite_file:DB.db'

process.MessageLogger = cms.Service("MessageLogger",
                                    debugModules=cms.untracked.vstring('*'),
                                    destinations=cms.untracked.vstring('cout'))

process.source = cms.Source("EmptyIOVSource",
                            firstValue=cms.uint64(1000000),
                            lastValue=cms.uint64(1000000),
                            timetype=cms.string('runnumber'),
                            interval=cms.uint64(1))

process.PoolDBESSource = cms.ESSource(
    "PoolDBESSource",
    process.CondDBCommon,
    timetype=cms.untracked.string('runnumber'),
    toGet=cms.VPSet(
        cms.PSet(record=cms.string('EcalDAQTowerStatusRcd'),
                 tag=cms.string('EcalDAQTowerStatus_mc'))))

process.PoolDBOutputService = cms.Service(
    "PoolDBOutputService",
    process.CondDBCommon,
    logconnect=cms.untracked.string('sqlite_file:DBLog.db'),
Ejemplo n.º 33
0

from Configuration.Eras.Era_Run2_2018_cff import Run2_2018
process = cms.Process("Whatever",Run2_2018)

process.load('Configuration.StandardSequences.GeometryRecoDB_cff')  # load from DB
process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff')
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")

from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, '102X_dataRun2_Sep2018Rereco_v1')
print "Using GlobalTag: %s" % process.GlobalTag.globaltag.value()

process.source = cms.Source("EmptyIOVSource",
    timetype = cms.string('runnumber'),
    firstValue = cms.uint64(321988),
    lastValue = cms.uint64(321988),
    interval = cms.uint64(1)
)

process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(1))

process.analyzer1 = cms.EDAnalyzer("MakeCoordLUT",
    # Verbosity level
    verbosity = cms.untracked.int32(1),

    # Output diectory
    outdir = cms.string("./pc_luts/firmware_data/"),

    # Produce "validate.root" to validate the LUTs
    please_validate = cms.bool(True),
Ejemplo n.º 34
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("PIPPO")

process.source = cms.Source("EmptyIOVSource",
    timetype   = cms.string('runnumber'),
    firstValue = cms.uint64(123456),
    lastValue  = cms.uint64(123465),
    interval   = cms.uint64(1)
)


process.testSimpleTree = cms.EDAnalyzer(
    "TestSimpleTree"
)


process.p = cms.Path(process.testSimpleTree)

process.load('Configuration.Geometry.GeometryExtended2016Reco_cff')
process.load('Configuration.Geometry.GeometryExtended2016dev_cff')
# process.load("Configuration.StandardSequences.GeometryRecoDB_cff")
process.load("Configuration.StandardSequences.RawToDigi_Data_cff")
process.load("RecoLocalCalo.Configuration.hcalLocalReco_cff")
process.load("SimCalorimetry.Configuration.hcalDigiSequence_cff")
process.load('SimCalorimetry.HcalTrigPrimProducers.hcaltpdigi_cff')

# process.es_hardcode.toGet.append("HcalTPParametersRcd")

process.simHcalTriggerPrimitiveDigis.inputLabel = cms.VInputTag(
    cms.InputTag('hcalDigis'), cms.InputTag('hcalDigis'))
process.simHcalTriggerPrimitiveDigis.inputUpgradeLabel = cms.VInputTag(
    cms.InputTag('hcalDigis'), cms.InputTag('hcalDigis'))
process.simHcalTriggerPrimitiveDigis.parameters = cms.untracked.PSet(
    TDCMaskHF=cms.uint64(0x8003FFFFFFFFFFFF))
process.simHcalTriggerPrimitiveDigis.FrontEndFormatError = cms.bool(False)
process.simHcalTriggerPrimitiveDigis.upgradeHF = cms.bool(True)

process.TFileService = cms.Service("TFileService",
                                   closeFileFast=cms.untracked.bool(True),
                                   fileName=cms.string('analyze_283657.root'))

process.hcalDigis.InputLabel = cms.InputTag("source")
process.analyzeRAW = cms.EDAnalyzer("AnalyzeTP",
                                    triggerPrimitives=cms.InputTag("hcalDigis", "", ""))
process.analyzeSIM = cms.EDAnalyzer("AnalyzeTP",
                                    triggerPrimitives=cms.InputTag("simHcalTriggerPrimitiveDigis", "", ""))
process.compare = cms.EDAnalyzer("CompareTP",
                                 triggerPrimitives=cms.InputTag("hcalDigis"),
                                 emulTriggerPrimitives=cms.InputTag("simHcalTriggerPrimitiveDigis"),
Ejemplo n.º 36
0
process.SiStripCalib.calibrationMode = cms.untracked.string('XXX_CALMODE_XXX')

if (XXX_PCL_XXX):
    process.SiStripCalib.AlgoMode = cms.untracked.string('PCL')
    process.SiStripCalib.harvestingMode = cms.untracked.bool(True)
    process.SiStripCalib.DQMdir = cms.untracked.string('XXX_DQMDIR_XXX')
    process.source = cms.Source(
        "PoolSource",
        secondaryFileNames=cms.untracked.vstring(),
        fileNames=calibTreeList,
        processingMode=cms.untracked.string('RunsAndLumis'))
else:
    process.SiStripCalib.InputFiles = calibTreeList
    process.source = cms.Source("EmptyIOVSource",
                                timetype=cms.string('runnumber'),
                                interval=cms.uint64(1),
                                firstValue=cms.uint64(XXX_FIRSTRUN_XXX),
                                lastValue=cms.uint64(XXX_LASTRUN_XXX))

process.PoolDBOutputService = cms.Service(
    "PoolDBOutputService",
    BlobStreamerName=cms.untracked.string('TBufferBlobStreamingService'),
    DBParameters=cms.PSet(
        messageLevel=cms.untracked.int32(2),
        authenticationPath=cms.untracked.string('/afs/cern.ch/cms/DB/conddb')),
    timetype=cms.untracked.string('runnumber'),
    connect=cms.string('sqlite_file:Gains_Sqlite.db'),
    toPut=cms.VPSet(
        cms.PSet(record=cms.string('SiStripApvGainRcd'),
                 tag=cms.string('SiStripGainFromParticles'))))
Ejemplo n.º 37
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("HitEff")

process.source = cms.Source("EmptyIOVSource",
    firstValue = cms.uint64(newrun),
    lastValue = cms.uint64(newrun),
    timetype = cms.string('runnumber'),
    interval = cms.uint64(1)
)

process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(1))

process.SiStripHitEff = cms.EDFilter("SiStripHitEffFromCalibTree",
    CalibTreeFilename = cms.string('rfio:newfilelocation'),
    Threshold         = cms.double(0.1),
    nModsMin          = cms.int32(25),
    doSummary         = cms.int32(0),
    ResXSig           = cms.untracked.double(5),
    SinceAppendMode   = cms.bool(True),
    IOVMode           = cms.string('Run'),
    Record            = cms.string('SiStripBadStrip'),
    doStoreOnDB       = cms.bool(True)
)

process.PoolDBOutputService = cms.Service("PoolDBOutputService",
    BlobStreamerName = cms.untracked.string('TBufferBlobStreamingService'),
    DBParameters = cms.PSet(
        authenticationPath = cms.untracked.string('/afs/cern.ch/cms/DB/conddb')
    ),
    timetype = cms.untracked.string('runnumber'),
Ejemplo n.º 38
0
import FWCore.ParameterSet.Config as cms

process = cms.Process('test')

import sys
if len(sys.argv) > 2:
    startrun = int(sys.argv[2])
else:
    startrun = 1
process.source = cms.Source("EmptyIOVSource",
                            timetype=cms.string('runnumber'),
                            firstValue=cms.uint64(startrun),
                            lastValue=cms.uint64(startrun),
                            interval=cms.uint64(1))

# load the alignment xml file
process.load(
    "CalibPPS.ESProducers.ctppsRPAlignmentCorrectionsDataESSourceXML_cfi")
process.ctppsRPAlignmentCorrectionsDataESSourceXML.RealFiles = cms.vstring(
    "CondFormats/PPSObjects/xml/sample_alignment_corrections.xml")
#process.ctppsRPAlignmentCorrectionsDataESSourceXML.RealFiles = cms.vstring(
#    "CondTools/CTPPS/test/RPixGeometryCorrections.xml",
#    "CondTools/CTPPS/test/largeXMLmanipulations/real_alignment_iov"+str(startrun)+".xml"
#    )

process.ctppsRPAlignmentCorrectionsDataESSourceXML.MeasuredFiles = cms.vstring(
    "CondFormats/PPSObjects/xml/sample_alignment_corrections.xml")
process.ctppsRPAlignmentCorrectionsDataESSourceXML.MisalignedFiles = cms.vstring(
    "CondFormats/PPSObjects/xml/sample_alignment_corrections.xml")

#Database output service
Ejemplo n.º 39
0
process.MessageLogger = cms.Service("MessageLogger",
    cout = cms.untracked.PSet(
        threshold = cms.untracked.string('INFO')
    ),
    destinations = cms.untracked.vstring('cout')
)
process.load("Configuration.Geometry.GeometryRecoDB_cff")

process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')

from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_data', '')


process.source = cms.Source("EmptyIOVSource",
    firstValue = cms.uint64(258714),
    lastValue = cms.uint64(258714),
    timetype = cms.string('runnumber'),
    interval = cms.uint64(1)
)

process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(-1)
)
process.load("CalibTracker.SiStripESProducers.SiStripBadModuleFedErrESSource_cfi")
from CalibTracker.SiStripESProducers.SiStripBadModuleFedErrESSource_cfi import siStripBadModuleFedErrESSource
siStripBadModuleFedErrESSource.appendToDataLabel = cms.string('BadModules_from_FEDBadChannel')
siStripBadModuleFedErrESSource.FileName = cms.string('/afs/cern.ch/user/d/dutta/work/public/BadChannel/DQM_V0001_R000260576__ZeroBias__Run2015D-PromptReco-v4__DQMIO.root')

process.siStripQualityESProducer.ListOfRecordToMerge = cms.VPSet(
       cms.PSet(record = cms.string('SiStripBadFiberRcd'), tag = cms.string('')),
Ejemplo n.º 40
0
    refreshEachRun = True
    reconnectEachRun = False
elif options.refresh == 4:
    refreshAlways, refreshOpenIOVs, refreshEachRun = False, False, False
    reconnectEachRun = True

process.GlobalTag = cms.ESSource(
    "PoolDBESSource",
    DBParameters=CondDBParameters,
    connect=cms.string(options.connectionString),
    snapshotTime=cms.string(options.snapshotTime),
    frontierKey=cms.untracked.string('abcdefghijklmnopqrstuvwxyz0123456789'),
    toGet=cms.VPSet(
        cms.PSet(record=cms.string('BeamSpotObjectsRcd'),
                 tag=cms.string(options.tag),
                 refreshTime=cms.uint64(1))),
    RefreshAlways=cms.untracked.bool(refreshAlways),
    RefreshOpenIOVs=cms.untracked.bool(refreshOpenIOVs),
    RefreshEachRun=cms.untracked.bool(refreshEachRun),
    ReconnectEachRun=cms.untracked.bool(reconnectEachRun),
    DumpStat=cms.untracked.bool(True),
)

#TODO: add VarParsing support for adding custom conditions
#process.GlobalTag.toGet.append( cms.PSet( record = cms.string( "BeamSpotObjectsRcd" ),
#                                          tag = cms.string( "firstcollisions" ),
#                                          connect = cms.string( "frontier://FrontierProd/CMS_CONDITIONS" ),
#                                          snapshotTime = cms.string('2014-01-01 00:00:00.000'),
#                                          )
#                                )
import FWCore.ParameterSet.Config as cms
from CondCore.CondDB.CondDB_cfi import *
import CondTools.Ecal.conddb_init as conddb_init

process = cms.Process("ESTimeSampleWeightsPopulator")

process.MessageLogger = cms.Service("MessageLogger",
                                    destinations = cms.untracked.vstring("cout"),
                                    cout = cms.untracked.PSet(threshold = cms.untracked.string("INFO"))
                                    )

process.source = cms.Source("EmptyIOVSource",
                            lastValue = cms.uint64(conddb_init.options.runNumber),
                            timetype = cms.string('runnumber'),
                            firstValue = cms.uint64(conddb_init.options.runNumber),
                            interval = cms.uint64(1)
)

CondDBConnection = CondDB.clone(connect = cms.string(conddb_init.options.destinationDatabase))

process.PoolDBOutputService = cms.Service("PoolDBOutputService",
                                          CondDBConnection,
                                          toPut = cms.VPSet(cms.PSet(record = cms.string("ESTimeSampleWeightsRcd"),
                                                                     tag = cms.string(conddb_init.options.destinationTag)
                                                                     )
                                                            )
                                          )

process.popConESTimeSampleWeights = cms.EDAnalyzer("ESTimeSampleWeightsPopConTransitionAnalyzer",
                                                    SinceAppendMode = cms.bool(True),
                                                    record = cms.string("ESTimeSampleWeightsRcd"),
Ejemplo n.º 42
0
        
        ] );



###################### end user choices ###################

# number of events and source
process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(1)
)

if cmsSource == 'EmptySource' :
    process.source = cms.Source("EmptyIOVSource",
                                timetype = cms.string('runnumber'),
                                firstValue = cms.uint64(firstRunNumber),
                                lastValue = cms.uint64(lastRunNumber),
                                interval = cms.uint64(1)
                                )
else :
    process.source = cms.Source ('PoolSource', fileNames=readFiles, secondaryFileNames=secFiles)
    

# load and configure modules via Global Tag
# https://twiki.cern.ch/twiki/bin/view/CMS/SWGuideFrontierConditions
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag = useGlobalTag + '::All'

# 
process.load('L1Trigger.Configuration.L1GlobalTagTest_cff')
Ejemplo n.º 43
0
        
        ] );



###################### end user choices ###################

# number of events and source
process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(1)
)

if cmsSource == 'EmptySource' :
    process.source = cms.Source("EmptyIOVSource",
                                timetype = cms.string('runnumber'),
                                firstValue = cms.uint64(firstRunNumber),
                                lastValue = cms.uint64(lastRunNumber),
                                interval = cms.uint64(1)
                                )
else :
    process.source = cms.Source ('PoolSource', fileNames=readFiles, secondaryFileNames=secFiles)
    

# load and configure modules via Global Tag
# https://twiki.cern.ch/twiki/bin/view/CMS/SWGuideFrontierConditions
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag = useGlobalTag + '::All'

# 
process.load('L1Trigger.Configuration.L1GlobalTagTest_cff')
Ejemplo n.º 44
0
                 VarParsing.VarParsing.varType.string, "Output Data Tag")
options.parseArguments()

process = cms.Process("RPCTwinMuxLinkMapPopConAnalyzer")

process.load("FWCore.MessageService.MessageLogger_cfi")
process.load("CondTools.RPC.RPCTwinMuxLinkMapPopConAnalyzer_cff")

process.CondDB.connect = 'sqlite_file:data/RPCLinkMap.db'
process.RPCTwinMuxLinkMapPopConAnalyzer.Source.dataTag = options.tag
process.RPCTwinMuxLinkMapPopConAnalyzer.Source.txtFile = cms.untracked.string(
    "RPCTwinMuxLinkMap.txt")

process.source = cms.Source("EmptyIOVSource",
                            timetype=cms.string('runnumber'),
                            firstValue=cms.uint64(options.sinceRun),
                            lastValue=cms.uint64(options.sinceRun),
                            interval=cms.uint64(1))

process.MessageLogger.files.RPCTwinMuxLinkMapPopConAnalyzer_log = cms.untracked.PSet(
    threshold=cms.untracked.string("INFO"),
    FwkReport=cms.untracked.PSet(reportEvery=cms.untracked.int32(1)))

process.MessageLogger.cout.threshold = cms.untracked.string("INFO")

process.PoolDBOutputService = cms.Service(
    "PoolDBOutputService",
    process.CondDB,
    timetype=cms.untracked.string('runnumber'),
    toPut=cms.VPSet(
        cms.PSet(record=cms.string('RPCTwinMuxLinkMapRcd'),
import FWCore.ParameterSet.Config as cms

process = cms.Process("ICALIB")
process.load("DQMServices.Core.DQM_cfg")

process.MessageLogger = cms.Service("MessageLogger",
    debugModules = cms.untracked.vstring('*'),
    cout = cms.untracked.PSet(
        threshold = cms.untracked.string('INFO')
    ),
    destinations = cms.untracked.vstring('cout')
)

process.source = cms.Source("EmptyIOVSource",
    firstValue = cms.uint64(insertRun),
    lastValue = cms.uint64(insertRun),
    timetype = cms.string('runnumber'),
    interval = cms.uint64(1)
)

process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(1)
)

process.load("Configuration.StandardSequences.Geometry_cff")

process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
process.GlobalTag.globaltag = "GR10_E_V5::All" #GR09_R_34X_V2

#to read information of o2o and cabling
process.BadComponentsOnline = cms.ESSource("PoolDBESSource",
Ejemplo n.º 46
0
import FWCore.ParameterSet.Config as cms

process = cms.Process('test')

process.source = cms.Source("EmptyIOVSource",
                            timetype=cms.string('runnumber'),
                            firstValue=cms.uint64(1),
                            lastValue=cms.uint64(1),
                            interval=cms.uint64(1))

#process.maxEvents = cms.untracked.PSet(
#input = cms.untracked.int32(1)
#)

# load a mapping
process.load("CondFormats.PPSObjects.CTPPSPixelDAQMappingESSourceXML_cfi")

#Database output service
process.load("CondCore.CondDB.CondDB_cfi")
# output database (in this case local sqlite file)
process.CondDB.connect = 'sqlite_file:CTPPSPixel_DAQMapping_AnalysisMask.db'

process.PoolDBOutputService = cms.Service(
    "PoolDBOutputService",
    process.CondDB,
    timetype=cms.untracked.string('runnumber'),
    toPut=cms.VPSet(
        cms.PSet(record=cms.string('CTPPSPixelDAQMappingRcd'),
                 tag=cms.string('PixelDAQMapping'),
                 label=cms.string('RPix'))))
Ejemplo n.º 47
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("PVSSIDReader")
process.load("CondCore.DBCommon.CondDBCommon_cfi")

process.CondDBCommon.connect = 'sqlite_file:PVSStoID.db'
process.CondDBCommon.DBParameters.authenticationPath = './'


process.maxEvents = cms.untracked.PSet(
  input = cms.untracked.int32(-1)
)

process.source = cms.Source("EmptyIOVSource",
    timetype = cms.string('timestamp'),
    firstValue = cms.uint64(1233913599),
    lastValue = cms.uint64(1233913599),
    interval = cms.uint64(1)
)



process.rn = cms.ESSource("PoolDBESSource",
    process.CondDBCommon,
    timetype = cms.string('timestamp'),
    toGet = cms.VPSet(cms.PSet(
        record = cms.string('RPCObPVSSmapRcd'),
        tag = cms.string('Imon_v3')
    ))
)
Ejemplo n.º 48
0
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1))

# Check
# print "converting start date = 28/07/2009 08:53:53 to ",
# print packFromString("28/07/2009 08:53:53")
# print "converting end date = 28/07/2009 14:13:31 to ",
# print packFromString("28/07/2009 14:13:31")
print("using an interval of 1 second = ", end=' ')
print(intervalSinceEpoch("01/01/1970 00:00:01"))

process.source = cms.Source(
    "EmptyIOVSource",
    timetype=cms.string('timestamp'),
    # firstValue = cms.uint64(packFromString("28/07/2009 10:53:53")),
    # lastValue = cms.uint64(packFromString("28/07/2009 16:13:31")),
    firstValue=cms.uint64(STARTTIME),
    lastValue=cms.uint64(ENDTIME),

    # One second inverval
    interval=cms.uint64(intervalSinceEpoch("01/01/1970 00:00:01")))

process.poolDBESSource = cms.ESSource(
    "PoolDBESSource",
    BlobStreamerName=cms.untracked.string('TBufferBlobStreamingService'),
    DBParameters=cms.PSet(
        messageLevel=cms.untracked.int32(2),
        authenticationPath=cms.untracked.string('/afs/cern.ch/cms/DB/conddb')),
    connect=cms.string('DATABASE'),
    toGet=cms.VPSet(
        cms.PSet(timetype=cms.untracked.string('timestamp'),
                 record=cms.string('SiStripDetVOffRcd'),
Ejemplo n.º 49
0
print("\tPt hat max: %f" % ptHatMax)


## Add our PhotonIsolationProducer to the analysisSequence. This producer compute pf isolations  for our photons
#process.photonPFIsolation = cms.EDProducer("PhotonIsolationProducer",
#                                          src = cms.InputTag("slimmedPhotons")
#                                     )


process.gammaJet = cms.EDFilter('GammaJetFilter',
                                isMC = cms.untracked.bool(True),
#                                photons = cms.untracked.InputTag("slimmedPhotons"),
                                firstJetPtCut = cms.untracked.bool(False),
                                
                                crossSection = cms.double(crossSection),
                                generatedEvents = cms.uint64(processedEvents),
                                ptHatMin = cms.untracked.double(ptHatMin),
                                ptHatMax = cms.untracked.double(ptHatMax),
                                
                                dumpAllGenParticles = cms.untracked.bool(False),
                                
                                # federico -> ValueMap names from the producer upstream
                                full5x5SigmaIEtaIEtaMap   = cms.InputTag("photonIDValueMapProducer:phoFull5x5SigmaIEtaIEta"),
                                phoChargedIsolation           = cms.InputTag("photonIDValueMapProducer:phoChargedIsolation"),
                                phoNeutralHadronIsolation = cms.InputTag("photonIDValueMapProducer:phoNeutralHadronIsolation"),
                                phoPhotonIsolation             = cms.InputTag("photonIDValueMapProducer:phoPhotonIsolation"), 
                                prescalesTag = cms.InputTag("patTrigger"),  
                                triggerResultsTag = cms.InputTag("TriggerResults", "", "HLT"),  
                                generatorTag = cms.InputTag("generator"),  
                                vertexTag = cms.InputTag("offlineSlimmedPrimaryVertices"),  
                                photonsTag = cms.InputTag("slimmedPhotons"),
Ejemplo n.º 50
0
import FWCore.ParameterSet.Config as cms

hltLevel1Activity = cms.EDFilter("HLTLevel1Activity",
    L1GtReadoutRecordTag  = cms.InputTag('gtDigis'),
    bunchCrossings = cms.vint32( 0, -1, 1),    # BPTX +/- 1 
    ignoreL1Mask   = cms.bool( False ),        # use L1 masks
    daqPartitions  = cms.uint32( 0x01 ),       # used by the definition of the L1 mask
    physicsLoBits  = cms.uint64( 0xFFFFFFFE ), # all physics bits except BPTX (L1_ZeroBias, bit 0)
    physicsHiBits  = cms.uint64( 0xFFFFFFFF ),
    technicalBits  = cms.uint64( 0xFFFFFF00 ), # all technical bits except BPTX (bits 0-7)
    invert         = cms.bool( False )
)
    threshold = cms.untracked.string("INFO"),
    default   = cms.untracked.PSet(limit = cms.untracked.int32(0)),                       
    FwkReport = cms.untracked.PSet(limit = cms.untracked.int32(-1),
                                   reportEvery = cms.untracked.int32(1000)
                                   ),                                                      
    SiPixelFEDChannelContainerTestReader = cms.untracked.PSet( limit = cms.untracked.int32(-1)),
    SiPixelFEDChannelContainer           = cms.untracked.PSet( limit = cms.untracked.int32(-1))
    )
process.MessageLogger.statistics.append('cout')  

##
## Empty Source
##
process.source = cms.Source("EmptyIOVSource",
                            timetype = cms.string('runnumber'),
                            firstValue = cms.uint64(315708),
                            lastValue = cms.uint64(315708),
                            interval = cms.uint64(1)
                            )
##
## Get the payload
##
from CondCore.CondDB.CondDB_cfi import *
CondDBQualityCollection = CondDB.clone(connect = cms.string("sqlite_file:SiPixelStatusScenarios_v1.db"))

process.dbInput = cms.ESSource("PoolDBESSource",
                               CondDBQualityCollection,
                               toGet = cms.VPSet(cms.PSet(record = cms.string('SiPixelStatusScenariosRcd'),
                                                          tag = cms.string('SiPixelFEDChannelContainer_StuckTBM_2018_v1_mc') # choose tag you want
                                                          )
                                                 )
Ejemplo n.º 52
0
from CondTools.L1TriggerExt.L1CondDBIOVWriterExt_cff import initIOVWriterExt

initIOVWriterExt(process,
                 outputDBConnect=options.outputDBConnect,
                 outputDBAuth=options.outputDBAuth,
                 tagBaseVec=initL1O2OTagsExt.tagBaseVec,
                 tscKey='')
process.L1CondDBIOVWriterExt.logKeys = True

if options.forceUpdate == 1:
    process.L1CondDBIOVWriterExt.forceUpdate = True

if options.logTransactions == 1:
    #    initIOVWriterExt.outputDB.logconnect = cms.untracked.string('oracle://cms_orcon_prod/CMS_COND_31X_POPCONLOG')
    initIOVWriterExt.outputDB.logconnect = cms.untracked.string(
        'sqlite_file:l1o2o-log.db')
    process.L1CondDBIOVWriterExt.logTransactions = True

process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1))
process.source = cms.Source("EmptyIOVSource",
                            timetype=cms.string('runnumber'),
                            firstValue=cms.uint64(options.runNumber),
                            lastValue=cms.uint64(options.runNumber),
                            interval=cms.uint64(1))

# CORAL debugging
#process.outputDB.DBParameters.messageLevel = cms.untracked.int32(3)

process.p = cms.Path(process.L1CondDBPayloadWriterExt *
                     process.L1CondDBIOVWriterExt)
Ejemplo n.º 53
0
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff")
process.SiStripDetInfoFileReader = cms.Service("SiStripDetInfoFileReader")

#this block is there to solve issue related to SiStripQualityRcd
process.load("CalibTracker.SiStripESProducers.SiStripQualityESProducer_cfi")
process.load("CalibTracker.SiStripESProducers.fake.SiStripDetVOffFakeESSource_cfi")
process.es_prefer_fakeSiStripDetVOff = cms.ESPrefer("SiStripDetVOffFakeESSource","siStripDetVOffFakeESSource")

process.MessageLogger = cms.Service("MessageLogger",
    cout = cms.untracked.PSet( threshold = cms.untracked.string('ERROR')  ),
    destinations = cms.untracked.vstring('cout')
)

process.source = cms.Source("EmptyIOVSource",
    timetype   = cms.string('runnumber'),
    interval   = cms.uint64(1),
    firstValue = cms.uint64(XXX_FIRSTRUN_XXX),
    lastValue  = cms.uint64(XXX_LASTRUN_XXX)
)

process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(1)
)

process.GlobalTag.globaltag = 'XXX_GT_XXX'

calibTreeList = cms.vstring()
XXX_CALIBTREE_XXX

process.load("CalibTracker.SiStripChannelGain.computeGain_cff")
process.SiStripCalib.InputFiles          = calibTreeList
import FWCore.ParameterSet.Config as cms

process = cms.Process("Test")
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1))

process.source = cms.Source(
    "EmptyIOVSource",
    timetype=cms.string('timestamp'),
    #firstValue = cms.uint64(5565740779852738368),
    #lastValue  = cms.uint64(5565740779852738369),
    #firstValue = cms.uint64(5566459919991846016),
    #lastValue = cms.uint64(5566459919991846017),
    firstValue=cms.uint64(5590608666362382145),
    lastValue=cms.uint64(5590608666362382146),
    interval=cms.uint64(1))

process.TFileService = cms.Service("TFileService",
                                   fileName=cms.string("histo_alloffroot"))

process.MessageLogger = cms.Service(
    "MessageLogger",
    cout=cms.untracked.PSet(threshold=cms.untracked.string('WARNING')),
    destinations=cms.untracked.vstring('cout'))

process.Timing = cms.Service("Timing")

process.load(
    "Configuration/StandardSequences/FrontierConditions_GlobalTag_cff")
process.load("Configuration/StandardSequences/GeometryIdeal_cff")

process.GlobalTag.globaltag = 'START311_V1::All'
Ejemplo n.º 55
0
                                 pfnPrefix=cms.untracked.string(''),   
                                 pfnPostfix=cms.untracked.string('')
                                 )


process.GlobalTag.globaltag = options.globalTag
process.GlobalTag.DumpStat =  True
process.GlobalTag.toGet = cms.VPSet()
process.GlobalTag.toGet.append(
   cms.PSet(record = cms.string("BeamSpotObjectsRcd"),
            snapshotTime = cms.string('2014-01-01 00:00:00.000'),
           )
)



process.source = cms.Source("EmptyIOVSource",
                            lastValue = cms.uint64(options.runNumber+1),
                            timetype = cms.string('runnumber'),
                            firstValue = cms.uint64(options.runNumber-1),
                            interval = cms.uint64(1)
                            )


process.get = cms.EDAnalyzer("EventSetupRecordDataGetter",
                             toGet =  cms.VPSet(),
                             verbose = cms.untracked.bool(True)
                             )

process.p = cms.Path(process.get)
Ejemplo n.º 56
0
import FWCore.ParameterSet.Config as cms

process = cms.Process("CALIB")
process.MessageLogger = cms.Service(
    "MessageLogger",
    cout=cms.untracked.PSet(threshold=cms.untracked.string('INFO')),
    destinations=cms.untracked.vstring('cout'))

process.source = cms.Source("EmptyIOVSource",
                            firstValue=cms.uint64(108597),
                            lastValue=cms.uint64(108597),
                            timetype=cms.string('runnumber'),
                            interval=cms.uint64(1))

# the DB Geometry is NOT used because in this cfg only one tag is taken from the DB and no GT is used. To be fixed if this is a problem
process.load('Configuration.Geometry.GeometryExtended_cff')
process.TrackerTopologyEP = cms.ESProducer("TrackerTopologyEP")
process.load("Geometry.TrackerGeometryBuilder.trackerParameters_cfi")
process.load("Geometry.TrackerGeometryBuilder.trackerGeometry_cfi")
process.trackerGeometry.applyAlignment = False

process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(-1))

process.poolDBESSource = cms.ESSource(
    "PoolDBESSource",
    BlobStreamerName=cms.untracked.string('TBufferBlobStreamingService'),
    DBParameters=cms.PSet(
        messageLevel=cms.untracked.int32(2),
        authenticationPath=cms.untracked.string('/afs/cern.ch/cms/DB/conddb')),
    timetype=cms.untracked.string('runnumber'),
    connect=cms.string('frontier://FrontierProd/CMS_COND_31X_STRIP'),
                
process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(1)
)

process.load("CondCore.CondDB.CondDB_cfi")
process.CondDB.connect = options.outputDBConnect if options.copyNonO2OPayloads == 0 else options.copyDBConnect

# Suppress warnings, not actually used, except for copyNonO2OPayloads
process.outputDB = cms.ESSource("PoolDBESSource",
                                process.CondDB,
                                toGet = cms.VPSet(cms.PSet(
    record = cms.string('L1TriggerKeyListExtRcd'),
    tag = cms.string( "L1TriggerKeyListExt_" + initL1O2OTagsExt.tagBaseVec[ L1CondEnumExt.L1TriggerKeyListExt ] )
    )),
                                RefreshEachRun=cms.untracked.bool(True)
                                )

if options.copyNonO2OPayloads == 0:
    process.outputDB.DBParameters.authenticationPath = options.outputDBAuth
    process.source = cms.Source("EmptySource")
else:
    process.outputDB.DBParameters.authenticationPath = options.copyDBAuth
    process.source = cms.Source("EmptyIOVSource",
                                timetype = cms.string('runnumber'),
                                firstValue = cms.uint64(4294967295),
                                lastValue = cms.uint64(4294967295),
                                interval = cms.uint64(1) )
                            
process.p = cms.Path(process.L1CondDBPayloadWriterExt)
Ejemplo n.º 58
0
process = cms.Process("GeometryWriter")

process.load('CondCore.CondDB.CondDB_cfi')

# This will read all the little XML files and from
# that fill the DDCompactView. The modules that fill
# the reco part of the database need the DDCompactView.
process.load('Configuration.Geometry.GeometryExtended2021_cff')
process.load('Geometry.MuonNumbering.muonNumberingInitialization_cfi')
process.load("Geometry.MuonNumbering.muonGeometryConstants_cff")
process.load('Geometry.CaloEventSetup.CaloGeometryDBWriter_cfi')
process.load('CondTools.Geometry.HcalParametersWriter_cff')

process.source = cms.Source("EmptyIOVSource",
                            lastValue=cms.uint64(1),
                            timetype=cms.string('runnumber'),
                            firstValue=cms.uint64(1),
                            interval=cms.uint64(1))

# This reads the big XML file and the only way to fill the
# nonreco part of the database is to read this file.  It
# somewhat duplicates the information read from the little
# XML files, but there is no way to directly build the
# DDCompactView from this.
process.XMLGeometryWriter = cms.EDAnalyzer(
    "XMLGeometryBuilder",
    XMLFileName=cms.untracked.string("./geSingleBigFile.xml"),
    ZIP=cms.untracked.bool(True))

process.TrackerGeometryWriter = cms.EDAnalyzer("PGeometricDetBuilder",
import FWCore.ParameterSet.Config as cms

process = cms.Process("CALIB")
process.MessageLogger = cms.Service("MessageLogger",
    cout = cms.untracked.PSet(
        threshold = cms.untracked.string('INFO')
    ),
    destinations = cms.untracked.vstring('cout')
)

process.source = cms.Source("EmptyIOVSource",
    firstValue = cms.uint64(1),
    lastValue = cms.uint64(100000),
    timetype = cms.string('runnumber'),
    interval = cms.uint64(1)
)

process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(-1)
)
process.a = cms.ESSource("PoolDBESSource",
    BlobStreamerName = cms.untracked.string('TBufferBlobStreamingService'),
    DBParameters = cms.PSet(
        authenticationPath = cms.untracked.string('/afs/cern.ch/cms/DB/conddb')
    ),
    timetype = cms.string('runnumber'),
    toGet = cms.VPSet(cms.PSet(
        record = cms.string('SiStripBadModuleRcd'),
        tag = cms.string('SiStripBadChannel_v1')
    )),
    connect = cms.string('sqlite_file:dbfile.db')
Ejemplo n.º 60
0
import FWCore.ParameterSet.Config as cms

RPCLBLinkMapPopConAnalyzer = cms.EDAnalyzer('RPCLBLinkMapPopConAnalyzer'
                                            , record = cms.string('RPCLBLinkMapRcd')
                                            , Source = cms.PSet(
                                                identifier = cms.string('RPCLBLinkMapHandler')
                                                , dataTag = cms.string('RPCLBLinkMap_v1')
                                                , sinceRun = cms.uint64(1)
                                                , DBParameters = cms.PSet(
                                                    authenticationPath = cms.untracked.string('/afs/cern.ch/cms/DB/conddb')
                                                    , authenticationSystem = cms.untracked.int32(2)
                                                    , security = cms.untracked.string('')
                                                    , messageLevel = cms.untracked.int32(0)
                                                )
                                                , connect = cms.string('oracle://cms_omds_adg/CMS_RPC_COND')
                                                , txtFile = cms.untracked.string('')
                                            )
)