def totalSilence ( lst = [ 'RootCnvSvc' ,
'IOManagerSvc' ,
'RootHistSvc' ,
'LHCb::RawDataCnvSvc' ,
'HcalDet.Quality' ,
'EcalDet.Quality' ,
'MagneticFieldSvc' ,
'PropertyConfigSvc' ,
'ToolSvc.L0DUConfig' ,
'ToolSvc.L0CondDBProvider' ,
'L0MuonFromRaw' ,
'IntegrateBeamCrossing' ] , dod = True ) :
from Configurables import MessageSvc, DataOnDemandSvc, ToolSvc
from Configurables import Gaudi__RootCnvSvc as RootCnvSvc
from Configurables import Gaudi__IODataManager as IODataManager
from Configurables import LHCb__RawDataCnvSvc as RawDataCnvSvc
msg = MessageSvc()
msg.OutputLevel = 5
ToolSvc ( OutputLevel = 5 )
RootCnvSvc ( "RootCnvSvc" , OutputLevel = 6 )
RawDataCnvSvc ( OutputLevel = 6 )
IODataManager ( 'IODataManager' , OutputLevel = 6 ,
AgeLimit = 1 , UseGFAL = False )
if dod :
DataOnDemandSvc ( Dump = True )
else :
DataOnDemandSvc ( Dump = False , OutputLevel = 6 )
msg.setError += [ 'DataOnDemandSvc' ]
msg.setError += lst
def _action():
"""
Reset all DaVinci sequences
"""
from Gaudi.Configuration import allConfigurables
from Gaudi.Configuration import getConfigurable
for seq in ('DaVinciInitSeq', 'DaVinciMainSequence', 'DaVinciSequence',
'MonitoringSequence', 'FilteredEventSeq'):
if not seq in allConfigurables: continue
cSeq = getConfigurable(seq)
if cSeq and hasattr(cSeq, 'Members'):
logger.info('Reset the sequence %s' % cSeq.name())
cSeq.Members = []
## reset the list of top-level algorithms
from Configurables import ApplicationMgr
a = ApplicationMgr()
a.TopAlg = []
a.OutputLevel = options.OutputLevel
from Configurables import MessageSvc
m = MessageSvc(OutputLevel=options.OutputLevel)
from GaudiConf import IOHelper
ioh = IOHelper()
ioh.setupServices()
def configureInput(self):
# No events are read as input
ApplicationMgr().EvtSel = 'NONE'
# Delegate handling of max. number of events to ApplicationMgr
self.setOtherProps(ApplicationMgr(), ["EvtMax"])
# Transient store setup
EventDataSvc().ForceLeaves = True
EventDataSvc().RootCLID = 1
# Suppress warning message from EventLoopMgr
from Configurables import MessageSvc
MessageSvc().setError += ['EventLoopMgr']
def silence ( lst = [ 'HcalDet.Quality' ,
'EcalDet.Quality' ,
'MagneticFieldSvc' ,
'PropertyConfigSvc' ,
'IntegrateBeamCrossing' ,
'ToolSvc.L0DUConfig' ,
'ConfigCDBAccessSvc' ,
'ToolSvc.L0CondDBProvider' ,
'L0MuonFromRaw' ] ) :
"""
Suppress some unnesessary printout from Gaudi
"""
#
logger.info ( 'Suppress some unnesessary Gaudi prints' )
if isinstance ( lst , str ) : lst = [ lst ]
if not isinstance ( lst , list ) : lst = list ( lst )
#
def _silent_action_ () :
from Gaudi.Configuration import allConfigurables
from Gaudi.Configuration import getConfigurable
keys = allConfigurables.keys()
s1 = set( keys )
s2 = set( lst )
s = s1.intersection()
for i in s :
c = getConfigurable( i )
if c and hasattr ( c , 'OutputLevel' ) :
c.OutputLevel = 4
from GaudiPython.Bindings import _gaudi
if not _gaudi :
## use configurables
from Configurables import MessageSvc
msg = MessageSvc()
from Gaudi.Configuration import appendPostConfigAction
appendPostConfigAction ( _silent_action_ )
else :
## use GaudiPython
msg = _gaudi.service('MessageSvc')
#
msg.setWarning += lst
def _configureOnlineMessageSvc(self):
# setup the message service
from Configurables import LHCb__FmcMessageSvc as MessageSvc
if 'MessageSvc' in allConfigurables:
del allConfigurables['MessageSvc']
msg = MessageSvc('MessageSvc')
app = ApplicationMgr()
app.MessageSvcType = msg.getType()
app.SvcOptMapping.append(msg.getFullName())
msg.LoggerOnly = True
if 'LOGFIFO' not in os.environ:
os.environ['LOGFIFO'] = '/tmp/logGaudi.fifo'
log.warning('# WARNING: LOGFIFO was not set -- now set to ' +
os.environ['LOGFIFO'])
msg.fifoPath = os.environ['LOGFIFO']
import OnlineEnv
msg.OutputLevel = OnlineEnv.OutputLevel
#msg.OutputLevel = '2'
msg.doPrintAlways = False
def configMsgSvc(app, msgLevel=None):
import os
if 'LOGFIFO' not in os.environ:
print '# WARNING: LOGFIFO was not set -- not configuring FMCMessageSvc.'
return
from Gaudi.Configuration import allConfigurables
# setup the message service
from Configurables import LHCb__FmcMessageSvc as MessageSvc
if 'MessageSvc' in allConfigurables:
del allConfigurables['MessageSvc']
msg = MessageSvc('MessageSvc')
app.MessageSvcType = msg.getType()
app.SvcOptMapping.append(msg.getFullName())
msg.LoggerOnly = True
msg.fifoPath = os.environ['LOGFIFO']
OnlineEnv = importOnline()
msg.OutputLevel = msgLevel if msgLevel != None else OnlineEnv.OutputLevel
msg.doPrintAlways = False
def configureOutput(self, seq):
# ROOT persistency for histograms
ApplicationMgr().HistogramPersistency = "ROOT"
# Set histogram file name.
histoFile = "Kepler-histos.root"
if (self.isPropertySet("HistogramFile")
and self.getProp("HistogramFile") != ""):
histoFile = self.getProp("HistogramFile")
HistogramPersistencySvc().OutputFile = histoFile
# Set tuple file name.
tupleFile = "Kepler-tuple.root"
if (self.isPropertySet('TupleFile')
and self.getProp("TupleFile") != ""):
tupleFile = self.getProp("TupleFile")
ApplicationMgr().ExtSvc += [NTupleSvc()]
tupleStr = "FILE1 DATAFILE='%s' TYP='ROOT' OPT='NEW'" % tupleFile
NTupleSvc().Output += [tupleStr]
from Configurables import MessageSvc
MessageSvc().setWarning += ['RFileCnv', 'RCWNTupleCnv']
# If requested add TbTupleWriter to the output sequence
if self.getProp("WriteTuples") == True:
from Configurables import TbTupleWriter
seq.Members += [TbTupleWriter()]
tupleConfiguration[ecattag] = TupleConfig (
Decay = "[B+]cc -> ^(J/psi(1S) -> ^e+ ^e-) ^([K+]cc)"
, InputLines = ["Hlt2PIDB2KJPsiEE{}TaggedTurboCalib".format(ecat['TagCharge'])]
, Calibration = ecat['HistName']
, Filter = FilterCut(ecat['Cut'])
, Branches = {
"B" : Branch("^([B+]cc -> (J/psi(1S) -> e+ e-) [ K+]cc)", Type='H')
, "Jpsi" : Branch("[B+]cc -> ^(J/psi(1S) -> e+ e-) [ K+]cc", Type='I')
, "probe": Branch(EBranch[ecat['ProbeCharge']], Type='T', isAlso = ['e'])
, "tag" : Branch(EBranch[ecat['TagCharge']] , Type='T', isAlso = ['e'])
, "K" : Branch("[B+]cc -> (J/psi(1S) -> e+ e-) ^([K+]cc)", Type='T')
}
)
from Configurables import MessageSvc
MessageSvc().Format = "% F%60W%S%7W%R%T %0W%M"
dv = DaVinci (
InputType = "MDST"
, Turbo = True
, RootInTES = "/Event/Turbo"
# , DataType = "2017" #added by me just for this test
, EvtMax = -1
, Lumi = True
, TupleFile = "pidcalib.root"
# , Input = [
#'root://eoslhcb.cern.ch//eos/lhcb/user/p/poluekt/PID/2018_TurCal_DST/00075638_00001238_2.fullturbo.dst',
#'root://eoslhcb.cern.ch//eos/lhcb/user/p/poluekt/PID/2018_TurCal_DST/00075638_00001239_2.fullturbo.dst',
#'root://eoslhcb.cern.ch//eos/lhcb/user/p/poluekt/PID/2018_TurCal_DST/00075638_00001241_2.fullturbo.dst',
#'root://eoslhcb.cern.ch//eos/lhcb/user/p/poluekt/PID/2018_TurCal_DST/00075638_00001242_2.fullturbo.dst',
#'root://eoslhcb.cern.ch//eos/lhcb/user/p/poluekt/PID/2018_TurCal_DST/00075638_00001243_2.fullturbo.dst',
##
## Static Configuration
##
from Gaudi.Configuration import *
from Configurables import (ApplicationMgr, CondDB, HistogramPersistencySvc,
DaVinci, MessageSvc, GaudiSequencer, ANNDispatchSvc,
HltDecReportsDecoder, HltSelReportsDecoder)
CondDB(UseOracle=False, DisableLFC=True)
## More space for output
MessageSvc().Format = "% F%30W%S%15W%R%T %0W%M"
## mDST paths
locationRoot = '/Event'
selectionPath = 'SingleCandidate'
particlePath = selectionPath + '/Particles'
#pvLocation = 'Rec/Vertex/Primary'
p2PVLocation = selectionPath + '/Particle2VertexRelations'
mDST = True
if mDST:
mDSTName = 'SwimmingMDST'
p2PVLocation = '%s/BestPV_%s_P2PV' % (selectionPath, mDSTName)
from MicroDSTConf.TriggerConfUtils import configureL0AndHltDecoding
locationRoot += '/' + mDSTName
configureL0AndHltDecoding(locationRoot)
from Gaudi.Configuration import *
from Configurables import (DaVinci, MessageSvc, FilterDesktop)
from Configurables import EventNodeKiller, ApplicationMgr
appConf = ApplicationMgr()
appConf.ExtSvc += ['DataOnDemandSvc']
enk = EventNodeKiller('KillTrigRawEvent')
enk.Nodes = [
"Hlt", "Hlt1", "Hlt2", "Trig", "Raw", "Trigger/RawEvent", "Trigger"
]
appConf.TopAlg.insert(0, enk.getFullName())
from Configurables import L0App
L0App().TCK = '0x0044'
L0App().ReplaceL0Banks = True
L0App().EvtMax = -1
L0App().DataType = '2012'
L0App().DDDBtag = 'dddb-20130929-1' ## latest strip20 tags as of Jan2013
L0App().CondDBtag = 'sim-20131023-vc-md100'
L0App().Simulation = True
L0App().outputFile = '/tmp/ikomarov/With_new_L0.dst'
from Configurables import EventSelector
EventSelector().PrintFreq = 3
from Configurables import MessageSvc
MessageSvc().OutputLevel = 3
from GaudiConf import IOHelper
IOHelper().inputFiles(["/tmp/ikomarov/Rewrited.dst"])
from Configurables import RootCnvSvc
RootCnvSvc().OutputLevel = 3
from Configurables import MessageSvc
width = 30
MessageSvc().Format = '% F%{0}W%S%7W%R%T %0W%M'.format(width)
Brunel().MCLinksSequence = ["Unpack", "Tr"]
Brunel().MCCheckSequence = ["Pat"]
Brunel().OutputType = "NONE"
Brunel().DataType = "Upgrade"
Brunel().InputType = "DIGI"
Brunel().WithMC = True
Brunel().PrintFreq = 100
Brunel().Simulation = True
Brunel().EvtMax = 200 * 5
Brunel().DatasetName = "seeding-%i%s" % (stereo, "-XOnly" if x_only else "")
Brunel().Detectors = [
'VP', 'UT', 'FT', 'Rich1Pmt', 'Rich2Pmt', 'Spd', 'Prs', 'Ecal', 'Hcal',
'Muon', 'Magnet', 'Tr'
]
MessageSvc().Format = '% F%20W%S%7W%R%T %0W%M'
GaudiSequencer("RecoHLTSeq").Members = ["GaudiSequencer/SeedingSeq"]
seed_seq = GaudiSequencer("SeedingSeq")
decs = []
decs.extend(decodersForBank(DecoderDB, "VP"))
#decs.extend(decodersForBank(DecoderDB,"UT"))
decs.extend(decodersForBank(DecoderDB, "FTCluster"))
createUTLiteClusters = decodersForBank(DecoderDB, "UT")
seed_seq.Members += [d.setup() for d in createUTLiteClusters]
UT = STOfflinePosition('ToolSvc.UTClusterPosition')
UT.DetType = "UT"
def configure(config, colors=False):
"""Configure the application from parser data
"""
#
if config.OutputLevel <= 3 and not config.Quiet:
_vars = vars(config)
_keys = _vars.keys()
_keys.sort()
logger.info('Configuration:')
for _k in _keys:
logger.info(' %15s : %-s ' % (_k, _vars[_k]))
## redefine output level for 'quiet'-mode
if config.OutputLevel > 5:
config.OutputLevel = 5
logger.info('set OutputLevel to be %s ' % config.OutputLevel)
if config.OutputLevel < 0:
config.OutputLevel = 0
logger.info('set OutputLevel to be %s ' % config.OutputLevel)
if config.Quiet and 4 > config.OutputLevel:
config.OutputLevel = 4
logger.info('set OutputLevel to be %s ' % config.OutputLevel)
from BenderTools.Utils import silence
silence()
#
## use coherent C++/Python logging levels
setLogging(config.OutputLevel)
#
# some sanity actions:
#
config.RootInTES = config.RootInTES.strip()
config.files = [i.strip() for i in config.files if i.strip()]
#
## start the actual action:
#
from Configurables import DaVinci
#
## get the file type for the file extension
#
from BenderTools.Parser import dataType
pyfiles = [i for i in config.files if len(i) == 3 + i.rfind('.py')]
files = [i for i in config.files if i not in pyfiles]
from BenderTools.Parser import fileList
for f in config.FileList:
files += fileList(f)
if not files and not config.ImportOptions:
raise AttributeError('No data files are specified!')
## get some info from file names/extensision
dtype, simu, ext = None, None, None
if files:
dtype, simu, ext = dataType(files)
logger.debug('DataType,Simu&extension:"%s",%s,"%s" (from files)' %
(dtype, simu, ext))
elif config.ImportOptions:
from Bender.DataUtils import evtSelInput
ifiles = evtSelInput(config.ImportOptions)
dtype, simu, ext = dataType(ifiles)
logger.debug(
'DataType,Simu&extension:"%s",%s&"%s" (from EventSelector)' %
(dtype, simu, ext))
if '2013' == dtype:
logger.info('Data type 2013 is redefined to be 2012')
dtype = '2012'
#
if ext in ('gen', 'xgen', 'GEN', 'XGEN', 'ldst', 'LDST') and not simu:
simu = True
if dtype and dtype != config.DataType:
logger.info('Redefine DataType from %s to %s ' %
(config.DataType, dtype))
config.DataType = dtype
if simu and not config.Simulation:
logger.info('Redefine Simulation from %s to %s ' %
(config.Simulation, simu))
config.Simulation = simu
if config.Simulation and config.Lumi:
logger.info('suppress Lumi for Simulated data')
config.Lumi = False
## summary information (when available)
from Configurables import LHCbApp
LHCbApp().XMLSummary = 'summary.xml'
daVinci = DaVinci(
DataType=config.DataType,
Simulation=config.Simulation,
Lumi=config.Lumi,
)
if hasattr(config, 'TupleFile') and config.TupleFile:
logger.info('Define TupleFile to be %s' % config.TupleFile)
daVinci.TupleFile = config.TupleFile
if hasattr(config, 'HistoFile') and config.HistoFile:
logger.info('Define HistogramFile to be %s' % config.HistoFile)
daVinci.HistogramFile = config.HistoFile
if config.MicroDST or 'mdst' == ext or 'MDST' == ext or 'uDST' == ext:
logger.info('Define input type as micro-DST')
daVinci.InputType = 'MDST'
#
## try to guess RootInTES
#
from BenderTools.Parser import hasInFile
if hasInFile(files, 'CHARM.MDST') and not config.RootInTES:
config.RootInTES = '/Event/Charm'
logger.info('RootInTES is set according to CHARM.MDST')
daVinci.InputType = 'MDST'
elif hasInFile(files, 'LEPTONIC.MDST') and not config.RootInTES:
config.RootInTES = '/Event/Leptonic'
logger.info('RootInTES is set according to LEPTONIC.MDST')
daVinci.InputType = 'MDST'
elif hasInFile(files, 'BHADRON.MDST') and not config.RootInTES:
config.RootInTES = '/Event/Bhadron'
logger.info('RootInTES is set according to BHADRON.MDST')
daVinci.InputType = 'MDST'
elif hasInFile(files, 'PID.MDST') and not config.RootInTES:
config.RootInTES = '/Event/PID'
logger.info('RootInTES is set according to PID.MDST')
daVinci.InputType = 'MDST'
elif hasInFile(files, 'PSIX.MDST') and not config.RootInTES:
config.RootInTES = '/Event/PSIX'
logger.info('RootInTES is set according to PSIX.MDST')
daVinci.InputType = 'MDST'
elif hasInFile(files, 'PSIX0.MDST') and not config.RootInTES:
config.RootInTES = '/Event/PSIX0'
logger.info('RootInTES is set according to PSIX0.MDST')
daVinci.InputType = 'MDST'
elif hasInFile(files, 'BOTTOM.MDST') and not config.RootInTES:
config.RootInTES = '/Event/BOTTOM'
logger.info('RootInTES is set according to BOTTOM.MDST')
daVinci.InputType = 'MDST'
elif hasInFile(files, 'TURBO.MDST') and not config.RootInTES:
config.RootInTES = '/Event/Turbo'
logger.info('RootInTES is set according to TURBO.MDST')
daVinci.InputType = 'MDST'
elif hasInFile(files, 'ALLSTREAMS.MDST') and not config.RootInTES:
config.RootInTES = '/Event/AllStreams'
logger.info('RootInTES is set according to ALLSTREAMS.MDST')
daVinci.InputType = 'MDST'
if config.RootInTES and 0 != config.RootInTES.find('/Event'):
config.RootInTES = '/Event/' + config.RootInTES
if config.RootInTES and '/' == config.RootInTES[-1]:
config.RootInTES = config.RootInTES[:-1]
if config.RootInTES and '/Event' != config.RootInTES:
daVinci.RootInTES = config.RootInTES
#
## check for Grid-access
#
if config.Grid:
from Bender.DataUtils import hasGridProxy
if not hasGridProxy():
logger.warning(
'GRID proxy is not available, switch off GRID-lookup')
config.Grid = '' ## SWITCH OFF Grid-lookup
if not config.Simulation and config.DataType in ('2010', '2011', '2012',
'2013', '2015'):
#
## try to use the latest available tags:
#
from Configurables import CondDB
## CondDB ( UseLatestTags = [ options.DataType ] )
## logger.info('Use latest tags for %s' % options.DataType )
CondDB(LatestGlobalTagByDataType=config.DataType)
logger.info('Use latest global tag for data type %s' % config.DataType)
if config.Simulation:
#
## try to get the tags from Rec/Header
from BenderTools.GetDBtags import useDBTagsFromData
tags = useDBTagsFromData(files,
castor=config.Castor,
grid=config.Grid,
daVinci=daVinci,
importOpts=config.ImportOptions,
catalogs=config.XmlCatalogs)
if config.IgnoreDQFlags:
logger.info('DataQuality flags will be ignored')
daVinci.IgnoreDQFlags = config.IgnoreDQFlags
## specific action for (x)gen files
if ext in ('gen', 'xgen', 'GEN', 'XGEN'):
from BenderTools.GenFiles import genAction
genAction(ext)
## prepare to copy good/marked/tagged evenst
if hasattr(config, 'OutputFile') and config.OutputFile:
from BenderTools.GoodEvents import copyGoodEvents
if 0 <= config.OutputFile.find('.'):
copyGoodEvents(config.OutputFile)
else:
copyGoodEvents("%s.%s" % (config.OutputFile, ext))
## OutptuLevel
from Configurables import MessageSvc
msgSvc = MessageSvc(OutputLevel=config.OutputLevel)
## import options (if specified)
for i in config.ImportOptions:
logger.info("Import options from file %s'" % i)
from Gaudi.Configuration import importOptions
importOptions(i)
if colors:
logger.debug('Add colorization to MessageSvc')
from Configurables import MessageSvc
msgsvc = MessageSvc(
useColors=True,
errorColorCode=['yellow', 'red'],
warningColorCode=['red'],
fatalColorCode=['blue', 'red'],
)
def _color_pre_start_action_():
logger.debug('Add colorization to MessageSvc')
from GaudiPython.Bindings import AppMgr
_g = AppMgr()
if not _g: return
_s = _g.service('MessageSvc')
if not _s: return
_s.useColors = True
_s.errorColorCode = ['yellow', 'red']
_s.warningColorCode = ['red']
_s.fatalColorCode = ['blue', 'red']
##_s.alwaysColorCode = [ 'blue' ]
##_s.infoColorCode = [ 'green' ]
del _g, _s
from Bender.Utils import addPreInitAction
addPreInitAction(_color_pre_start_action_)
## set input data
from Bender.Utils import setData
setData(
files,
config.XmlCatalogs, ## XML-catalogues
config.Castor, ## use Castor/EOS lookup
config.Grid) ## Use GRID to locate files
return pyfiles
# Work around for Turbo locations being included in the default list of
# relations table locations, which triggers Turbo unpacking and seg. faults
from Configurables import MCMatchObjP2MCRelator
default_rel_locs = MCMatchObjP2MCRelator().getDefaultProperty('RelTableLocations')
rel_locs = [loc for loc in default_rel_locs if 'Turbo' not in loc]
MCTruth.addTool(MCMatchObjP2MCRelator)
MCTruth.MCMatchObjP2MCRelator.RelTableLocations = rel_locs
Jpsi2MuMuTuple.addTool(MCTruth)
from Configurables import DaVinci
DaVinci().EvtMax = -1 # Number of events
DaVinci().HistogramFile = "DVHistos.root"
DaVinci().DataType = "2016"
DaVinci().InputType = "DST"
DaVinci().Simulation = True
DaVinci().TupleFile = "Tuple.root" # Ntuple
DaVinci().UserAlgorithms = [ Jpsi2MuMuTuple
] # The algorithms
# Get Luminosity
DaVinci().Lumi = False
from Configurables import MessageSvc
MessageSvc().setWarning = [ 'RFileCnv' ]
DaVinci().DDDBtag = "dddb-20170721-3"
DaVinci().CondDBtag = "sim-20170721-2-vc-md100"
#####################
from Configurables import MessageSvc
DaVinci().InputType = 'DST'
DaVinci().SkipEvents = 0
DaVinci().PrintFreq = 10000
DaVinci().Lumi = not DaVinci().Simulation
# Debug options
# DaVinci().EvtMax = 300
DaVinci().EvtMax = -1
if has_flag('TRACKER_ONLY'):
MessageSvc().OutputLevel = 6 # Suppress L0 error output
###################################
# Customize DaVinci main sequence #
###################################
from Configurables import ChargedProtoParticleMaker
from Configurables import NoPIDsParticleMaker
from Configurables import TrackScaleState
from Configurables import TrackSmearState
from CommonParticles.Utils import trackSelector, updateDoD
# Provide required information for VELO pions.
ms_all_protos = ChargedProtoParticleMaker(name='MyProtoPMaker')
ms_all_protos.Inputs = ['Rec/Track/Best']
ms_all_protos.Output = 'Rec/ProtoP/MyProtoPMaker/ProtoParticles'
def patchBrunel(true_online_version):
"""
Instantiate the options to run Brunel with raw data
@author M.Frank
"""
import GaudiConf.DstConf
import Brunel.Configuration
from Configurables import CondDB, DstConf, HistogramPersistencySvc, EventLoopMgr, MessageSvc
import OnlineEnv as Online
brunel = Brunel.Configuration.Brunel()
EventLoopMgr().OutputLevel = MSG_INFO
try:
dir(Online).index( "DDDBTag" )
except:
print "DDDBTag not found, use default"
else:
brunel.DDDBtag = Online.DDDBTag
try:
dir(Online).index( "CondDBTag" )
except:
print "CondDBTag not found, use default"
else:
brunel.CondDBtag = Online.CondDBTag
MessageSvc().OutputLevel = MSG_INFO
conddb = CondDB()
conddb.IgnoreHeartBeat = True
brunel.WriteFSR = False # This crashes Jaap's stuff
EventLoopMgr().OutputLevel = MSG_INFO
EventLoopMgr().Warnings = False
if true_online_version:
brunel.OutputLevel = 999
brunel.PrintFreq = -1
if processingType == 'Reprocessing':
GaudiConf.DstConf.DstConf._doWriteMDF = packDST
brunel.PackType = 'MDF'
brunel.OutputType = 'RDST'
brunel.WriteLumi = True
brunel.Histograms = 'None'
print '[WARN] Running brunel with histogram settings:None'
sys.stdout.flush()
else:
#print '[WARN] Running GaudiSerialize!'
from Configurables import Serialisation, ProcessPhase
brunel.WriteLumi = False
brunel.Histograms = 'Online'
print '[WARN] Running brunel with histogram settings:Online'
sys.stdout.flush()
Brunel.Configuration.Brunel.configureOutput = dummy
"""
ProcessPhase("Output").DetectorList += [ 'DST' ]
brunel.setProp( 'DatasetName', 'GaudiSerialize' )
DstConf().Writer = 'DstWriter'
DstConf().DstType = 'DST'
DstConf().PackType = 'NONE'
Serialisation().Writer = 'Writer'
##Serialisation().Explorer = True
Serialisation()._ConfigurableUser__addPassiveUseOf(DstConf())
"""
HistogramPersistencySvc().OutputFile = ""
HistogramPersistencySvc().OutputLevel = MSG_ERROR
return brunel