HiggsAnalysis/HiggsAnalysis-00-01-00/run/HiggsAnalysisNtupleWriter.py

##############################
#
# Author: MDT group, MPI Munich
#
#    run with: athena  -c 'jetcontainer = "Cone4Topo" ; dataset = "5333" ; outputdir = "/.at/mdtraid06/mgroh"' HiggsAnalysisNtupleWriter.py
#
#    for a more detailed description please see at the end of this file
#
##############################

# if values are not given as an argument
# run with default values:

sys.path.append('data')
import datatools
import datetime

#check command line and set default values
if not 'dataset' in dir():
   dataset = "default"

if not 'outputdir' in dir():
   outputdir = ""

if not 'AtlFastFlag' in dir():
   AtlFastFlag = False;
   if (dataset.lower().find('atlfast') != -1):
      AtlFastFlag = True;

if not 'doAODFix1mm' in dir():
   doAODFix1mm = False;

if not 'doEventWeight' in dir():
   doEventWeight = True;
   if (dataset.lower().find('sherpa') != -1):
      doEventWeight = False;

if not 'filenumber' in dir() or filenumber < 0:
   filenumber = 0;
   
if not 'jetcontainer' in dir():
   jetcontainer = "Cone4Topo"

if not 'nevents' in dir():
   nevents = -1

if not 'doTrackParticles' in dir():
   doTrackParticles = False

if not 'doTrackJets' in dir() or AtlFastFlag == True:
   doTrackJets = False

# put the names of the jetcontainers together
jetcontainername =  jetcontainer + "ParticleJets"
namelist = ["H1Topo", "UnCalTopo", "Topo", "Tower"]
truthjetcontainername = ""

for k_string in namelist:
   
   if k_string in jetcontainername:

      truthjetcontainername = jetcontainername.replace(k_string,"Truth")
      trackjetcontainer = jetcontainer.replace(k_string,"Track")
      truthtrackjetcontainer = jetcontainer.replace(k_string,"TruthTrack")
      break


# import the data types 
import EventKernel.ParticleDataType

EventSelector = Service( "EventSelector" )

# load additional libraries for back navigation
from AnalysisExamples.AnalysisFlags import AnalysisFlags

include( "AthenaPoolCnvSvc/ReadAthenaPool_jobOptions.py" )

if AnalysisFlags.DoNavigation:
   include ("RecExCommon/AllDet_detDescr.py")
   EventSelector.BackNavigation = True

# the Dlls
include( "ParticleBuilderOptions/ESD_PoolCnv_jobOptions.py" )
include( "ParticleBuilderOptions/AOD_PoolCnv_jobOptions.py")
include( "ParticleBuilderOptions/McAOD_PoolCnv_jobOptions.py")
include( "EventAthenaPool/EventAthenaPool_joboptions.py" )
include( "TrackIsolationTools/TrackIsolationTool_jobOptions.py" )


if(doTrackJets or doTrackParticles):
   # configure VertexCollectionSvc
   theApp.ExtSvc += [ "VertexCollectionSvc" ]
   VertexCollectionSvc = Service( "VertexCollectionSvc" )
   theApp.TopAlg += [ "MPIHiggsAnalysis::VertexCollector" ]
   VertexCollector = Algorithm( "MPIHiggsAnalysis::VertexCollector" )
   #VertexCollector.VertexCollectionSvc = "MPIHiggsAnalysis::VertexCollector"

if(doTrackJets):
   include( trackjetcontainer+"Jet_jobOptions.py" )
   include( truthtrackjetcontainer+"Jet_jobOptions.py" )


HistogramPersistencySvc = Service( "HistogramPersistencySvc" )
theApp.Dlls += [ "RootHistCnv" ]
theApp.HistogramPersistency = "ROOT"
#HistogramPersistencySvc.OutputFile = "histos.root"


# write out a summary of the time spent
theApp.Dlls += [ "GaudiAud" ]
theAuditorSvc = AuditorSvc()
theAuditorSvc.Auditors  += [ "ChronoAuditor", "MemStatAuditor"]

# User Analysis Dll's
theApp.Dlls   += [ "CBNT_Athena", "CBNT_Utils" ]
theApp.Dlls   += [ "AnalysisTools" ]
theApp.Dlls   += [ "AnalysisExamples" ]

# The algorithms to run
theApp.TopAlg += [ "CBNT_Athena/AOD_ANA" ]
AOD_ANA = Algorithm( "AOD_ANA" )

#init the dataset library 
data_lib = datatools.DataLib()


#check if joboption from default path should be included 
jo_path = ''

if dataset.find('jo:') != -1:
   dataset = dataset.replace('jo:','');
   jo_path = '/.at/mdtraid04/12.0.X_data/data_jo_files/'
   print "Include data from .py file in path: ", jo_path 


#fill the dataset library
include("data/datasetdef.py")
include("data/datasetdef_manfred.py")
include("data/datasetdef_steffen.py")
include("data/datasetdef_thies.py")

#print data_lib

#get the dataset
if dataset == "default":
   datasetname = 'defaultfile' #will be used for the filename
   print '\nError: You have to pass a dataset through the command line'
   print '       or define a default dataset here.\n'
   sys.exit()
  
elif dataset.endswith(".py"):
   include(jo_path + dataset)
   tuple = dataset.rsplit("/",1)
   datasetname = tuple[len(tuple)-1].replace(".py","")

elif dataset.endswith(".root"):
   EventSelector.InputCollections = [ dataset ]
   tuple = dataset.rsplit("/",1)
   datasetname = tuple[len(tuple)-1].replace(".root","")

else:
   ds = data_lib.find_dataset(dataset)
   print ds
   if jo_path == '':
      datatools.include_files(ds.get_path(),EventSelector)
   else:
      include(jo_path + ds.get_long() + '.py')
   datasetname = dataset


if len(outputdir)>0 and not outputdir.endswith("/"):
   outputdir += "/"

#put together filename
filename = outputdir + datasetname + "_" + jetcontainername + ".aan.root"

if filenumber > 0:
   filename = filename.replace(jetcontainername,
                               jetcontainername+"_"+str(filenumber))

if (AtlFastFlag == True) and\
       (datasetname.lower().find('atlfast') == -1):

   filename = filename.replace("_"+jetcontainername,
                               "_atlfast_"+jetcontainername)

if doAODFix1mm == True:
   filename = filename.replace(jetcontainername,
                               jetcontainername+"_1mmFix")

if doTrackJets == True:
   filename = filename.replace(jetcontainername,
                               jetcontainername+"_TrackJets")

if doTrackParticles == True:
   filename = filename.replace(jetcontainername,
                               jetcontainername+"_TrackParticles")

#print configuration
print '\n************************************************************\n'
print " Using the following configuration: "
print "   dataset:           ", dataset
print "   datasetname:       ", datasetname
print "   outputdir:         ", outputdir
print "   AtlFastFlag:       ", AtlFastFlag
print "   doAODFix1mm:       ", doAODFix1mm
print "   doEventWeight:     ", doEventWeight
print "   doTrackParticles:  ", doTrackParticles
print "   doTrackJets:       ", doTrackJets
print "   filenumber:        ", filenumber
print "   nevents:           ", nevents
print "   filename:          ", filename
print "   jetcontainer:      ", jetcontainername  
print "   truthjetcontainer: ", truthjetcontainername
print '\n************************************************************\n'


#do 1mm correction
if doAODFix1mm == True:
   include( "ElectronPhotonAlgs/ElectronPhotonCorrector_jobOptions.py")
   include( "JetMissingEtAlgs/ParticleJet1mmCorrection_jobOptions.py")
   include( "JetMissingEtAlgs/MissingET1mmCorrection_jobOptions.py")


theApp.Dlls   += [ "AnalysisTools" ]
theApp.Dlls   += [ "HiggsAnalysis" ]
CBNTAthenaAware = True
include ("CBNT_Athena/CBNT_AthenaAware_jobOptions.py")
include ("CBNT_Athena/CBNT_EventInfo_jobOptions.py")
CBNT_AthenaAware = Algorithm( "CBNT_AthenaAware" )
CBNT_AthenaAware.Members += [ "HiggsAnalysisNtupleWriter" ]

############# The properties of the HiggsAnalysisNtupleWriter Algorithm

HiggsAnalysisNtupleWriter = Algorithm( "HiggsAnalysisNtupleWriter" )

HiggsAnalysisNtupleWriter.doTrigger        = True
HiggsAnalysisNtupleWriter.doMissingEt      = True
HiggsAnalysisNtupleWriter.doTrackParticles = doTrackParticles
HiggsAnalysisNtupleWriter.doElectrons      = True
HiggsAnalysisNtupleWriter.doPhotons        = True
HiggsAnalysisNtupleWriter.doMuons          = True
HiggsAnalysisNtupleWriter.doJets           = True
HiggsAnalysisNtupleWriter.doTauJets        = True
HiggsAnalysisNtupleWriter.doTruthJets      = True
HiggsAnalysisNtupleWriter.doTruthParticles = True
HiggsAnalysisNtupleWriter.doEventWeight    = doEventWeight

HiggsAnalysisNtupleWriter.doTrackJets      = doTrackJets
HiggsAnalysisNtupleWriter.doVertices       = doTrackJets or doTrackParticles

HiggsAnalysisNtupleWriter.truthparticleMaximumLeptonBarcode = 100000
HiggsAnalysisNtupleWriter.truthparticleNoPDGAbove100        = False

HiggsAnalysisNtupleWriter.AtlFastFlag = AtlFastFlag
HiggsAnalysisNtupleWriter.doAODFix1mm = doAODFix1mm


HiggsAnalysisNtupleWriter.AOD_files = EventSelector.InputCollections


if AtlFastFlag == True:
    
   HiggsAnalysisNtupleWriter.triggerDecisionContainer     = "notAvailable"
   HiggsAnalysisNtupleWriter.photonContainer              = "AtlfastPhotonCollection"
   HiggsAnalysisNtupleWriter.electronContainer            = "AtlfastElectronCollection"
   HiggsAnalysisNtupleWriter.muonContainer                = ["AtlfastMuonCollection"]
   HiggsAnalysisNtupleWriter.jetContainer                 = "AtlfastParticleJetContainer"
   HiggsAnalysisNtupleWriter.taujetContainer              = "AtlfastTauJetContainer"
   HiggsAnalysisNtupleWriter.missingEtContainerCollection = ["AtlfastMissingEt"]
   HiggsAnalysisNtupleWriter.truthparticleContainer       = "SpclMC"
   HiggsAnalysisNtupleWriter.truthjetContainer            = truthjetcontainername
   HiggsAnalysisNtupleWriter.truthmissingEtContainer      = "MET_Truth"
   #HiggsAnalysisNtupleWriter.truthmissingEtContainer      = "not Available"
   HiggsAnalysisNtupleWriter.TrackParticleContainer       = "AtlfastTrackParticles"
   
else:

   HiggsAnalysisNtupleWriter.triggerDecisionContainer     = "MyTriggerDecision"
   HiggsAnalysisNtupleWriter.triggerMuonLVL1Container     = "LVL1_ROI"
   HiggsAnalysisNtupleWriter.triggerMuonLVL2Container     = "CombinedMuonFeature"
   HiggsAnalysisNtupleWriter.triggerMuonEFContainer       = "TrigMuonEFContainer"
   HiggsAnalysisNtupleWriter.triggerMissingEtContainer    = "TrigEFMissingET"
   HiggsAnalysisNtupleWriter.photonContainer              = "PhotonCollection"
   HiggsAnalysisNtupleWriter.electronContainer            = "ElectronCollection"
   HiggsAnalysisNtupleWriter.muonContainer                = ["MuidMuonCollection", "StacoMuonCollection"]
   HiggsAnalysisNtupleWriter.jetContainer                 = jetcontainername
   #HiggsAnalysisNtupleWriter.jetContainer                 = "Cone4TowerParticleJets"
   HiggsAnalysisNtupleWriter.taujetContainer              = "TauJetCollection"
   HiggsAnalysisNtupleWriter.truthjetContainer            = truthjetcontainername
   #HiggsAnalysisNtupleWriter.truthjetContainer           = "Cone4TruthParticleJets"
   HiggsAnalysisNtupleWriter.missingEtContainerCollection = ["MET_Base",
                                                             "MET_Calib",
                                                             "MET_CorrTopo",
                                                             "MET_LocHadTopo",
                                                             "MET_Topo",
                                                             "MET_Muon",
                                                             "MET_MuonBoy",
                                                             "MET_Final",
                                                             "MET_Cryo",
                                                             "MET_CryoCone",
                                                             "MET_RefFinal",
                                                             "MET_RefEle",
                                                             "MET_RefJet",
                                                             "MET_CellOut",
                                                             "MET_LocHadTopoObj",
                                                             "MET_TopoObj",
                                                             "ObjMET_Elec",
                                                             "ObjMET_Muon",
                                                             "ObjMET_Jet",
                                                             "ObjMET_MiniJet",
                                                             "ObjMET_IdTrk",
                                                             "ObjMET_Rest", 
                                                             "ObjMET_Final",
                                                             "MET_RefFinal_1mmCorrection"]
   HiggsAnalysisNtupleWriter.truthmissingEtContainer      = "MET_Truth"
   HiggsAnalysisNtupleWriter.truthparticleContainer       = "SpclMC"
   HiggsAnalysisNtupleWriter.jetTrackContainer            = trackjetcontainer+"Jets"
   HiggsAnalysisNtupleWriter.jetTruthTrackContainer       = truthtrackjetcontainer+"Jets"
   HiggsAnalysisNtupleWriter.TrackParticleContainer       = "TrackParticleCandidate"

# set the file info
HiggsAnalysisNtupleWriter.release    = os.environ.get("AtlasVersion")
HiggsAnalysisNtupleWriter.svnversion = os.popen("svnversion -n .").read()
HiggsAnalysisNtupleWriter.date       = datetime.datetime.now().strftime("%Y-%m-%d/%H:%M:%S")

##########################################
# setup TTree registration Service
# save ROOT histograms and Tuple

#theApp.Dlls += [ "RootHistCnv" ]
#theApp.HistogramPersistency = "ROOT"

THistSvc         = Service ( "THistSvc" )
THistSvc.Output  = ["AANT DATAFILE='"+filename+"' OPT='RECREATE'"]
NTupleSvc        = Service( "NTupleSvc" )
NTupleSvc.Output = [ "FILE1 DATAFILE='"+filename+"' OPT='NEW'" ]
theApp.TopAlg += [ "AANTupleStream" ]
AANTupleStream               = Algorithm( "AANTupleStream" )
AANTupleStream.ExtraRefNames = [ "StreamATLFAST","Stream1" ]
AANTupleStream.OutputName = filename
AANTupleStream.WriteInputDataHeader = True
AANTupleStream.OutputLevel = WARNING

# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
MessageSvc = Service( "MessageSvc" )
MessageSvc.OutputLevel = WARNING
#MessageSvc.OutputLevel = DEBUG
#MessageSvc.OutputLevel = INFO

# Number of Events to process
theApp.EvtMax = nevents

# skip events
if(filenumber > 0):
   EventSelector = Service( "EventSelector" )
   EventSelector.SkipEvents = (filenumber-1) * theApp.EvtMax
   print 'Skip:', EventSelector.SkipEvents, 'Events'

###############################################################
#
#  1) Default:  athena HiggsAnalysisNtupleWriter.py
#      - default values will be used (defined at the beginning of this file)
#      - you have to put 'include("<your_dataset_jo>.py")' in the 'if dataset == "default"' block 
#
#  2) dataset: athena -c 'dataset="description"' HiggsAnalysisNtupleWriter.py
#      a) dataset="path/filename.py": joboptions will be directly included
#      b) dataset="jo:filename.py":   joboptions will be icluded from path: /.at/mdtraid04/12.0.X_data/data_jo_files/
#      c) dataset="filename.root"     the root file will directly be included
#      d) dataset="long/short descr":
#                   - e.g.:  dataset="5200_1206"
#                   - the datset will be searched in the data_lib library
#                   - both the short or long description can be specified, as defined in
#                     data/datasetdef.py
#                   - all files which contain '.root' in the name in the path defined
#                     in the dataset definition will be included
#      e) dataset="jo:5200_1206"                             
#                   - same as d) but instead of looping over all rootfiles the
#                     joboptions from the path: /.at/mdtraid04/12.0.X_data/data_jo_files/ is included
#                   - the name of the joboption is build as: <long descripion of dataset>.py
#    
#  3) outpudir: athena -c 'outputdir="mydata/"' HiggsAnalysisNtupleWriter.py
#      - the path where the file will be written
# 
#  4) AtlFastFlag: athena -c 'AtlFastFlag=1' HiggsAnalysisNtupleWriter.py
#      - specifies if writer will be run on AtlFast containers
#      - default value is False
#      - if dataset is defined in command line an contains a string "atlfast"
#        -> flag will be set to True
#      - this will be overwritten if AtlFastFlag is set in the command line
#      - if true: ouptfilename will contain a string: '_atlfast' 
#
#  5) doEventWeight: athena -c 'doEventWeight=0' HiggsAnalysisNtupleWriter.py 
#      - write EventWeight or not
#      - default value is True
#      - if dataset is defined in command line an contains a string "sherpa"
#        ->  flag will be set to False
#      - this will be overwritten if doEventWeight is set in the command line
#
#  6) doAODFix1mm: athena -c 'doAODFix1mm=1' HiggsAnalysisNtupleWriter.py
#      - default: false
#      - if true 1mm bug corrections will be applied     
#      - will be included in the outputfilename
# 
#
#  7) filenumber: athena -c 'filenumber=3' HiggsAnalysisNtupleWriter.py
#      - default value is 0
#      - if > 0: - (filenumber-1)*nevent will be skipped the nevents ar processed
#                - filenumber will be included in the outputfilename
#
#  8) jetcontainer: athena -c 'jetcontainer="Cone4Tower"' HiggsAnalysisNtupleWriter.py
#     - default: "Cone4Topo"
#     - use this jetcontainer in analysis
#     - the appropriate truthjet container will be used
#     - will be included in the outputfilename  
#
#  9) nevents: athena -c 'nevents="100"' HiggsAnalysisNtupleWriter.py
#     - the number of events which will be processed
#
# 10) Compose:
#     athena  -c 'dataset="5200_1206_tid007900"; nevents=100' HiggsAnalysisNtupleWriter.py
#
#
#################################################################

---