# ak4 jets
# ==================

process.ak4Jets = cms.EDProducer("fourVectorProducer",
                                   particleCollection = cms.untracked.InputTag("GoodJets"),
                                   debug = cms.untracked.bool(False)
                                   )

process.ak4JetsRaw = cms.EDProducer("fourVectorProducer",
                                    particleCollection = cms.untracked.InputTag("slimmedJets"),
                                    debug = cms.untracked.bool(False)
                                    )

from AllHadronicSUSY.Utils.jetproperties_cfi import jetproperties
process.JetsPropertiesRaw = jetproperties.clone(JetTag  = cms.InputTag('slimmedJets'),
                                                BTagInputTag	        = cms.string('combinedInclusiveSecondaryVertexV2BJetTags'),
                                                METTag  = cms.InputTag("slimmedMETs"),
                                                )


process.TreeMaker2.VectorTLorentzVector.append("ak4Jets")
process.TreeMaker2.VectorTLorentzVector.append("ak4JetsRaw")
process.TreeMaker2.VectorInt.append("GoodJets:passJetID(ak4Jets_passedJetID)")

process.TreeMaker2.VectorDouble.append("JetsProperties:bDiscriminator(ak4Jets_CSVdisc)")
process.TreeMaker2.VectorDouble.append("JetsProperties:chargedHadronEnergyFraction(ak4Jets_chargeHadEfrac)")
process.TreeMaker2.VectorDouble.append("JetsProperties:neutralHadronEnergyFraction(ak4Jets_neutralHadEfrac)")
process.TreeMaker2.VectorDouble.append("JetsProperties:photonEnergyFraction(ak4Jets_photonEfrac)")
process.TreeMaker2.VectorInt.append("JetsProperties:chargedHadronMultiplicity(ak4Jets_chargedHadMult)")
process.TreeMaker2.VectorInt.append("JetsProperties:neutralHadronMultiplicity(ak4Jets_neutralHadMult)")
process.TreeMaker2.VectorInt.append("JetsProperties:photonMultiplicity(ak4Jets_photonMult)")
process.TreeMaker2.VectorInt.append("JetsProperties:flavor(ak4Jets_flavor)")
def makeTreeFromMiniAOD(
process,
outFileName,
reportEveryEvt=10,
testFileName="",
Global_Tag="",
numProcessedEvt=1000,
lostlepton=False,
gammajets=False,
tagandprobe=False,
applybaseline=False,
doZinv=False,
):

    process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
    process.GlobalTag.globaltag = Global_Tag
    
    # define if mt cut should be applied and the value (less than 0 means no cut)
    mtcut = cms.double(100)
    if tagandprobe:
      mtcut=-100
      print "Doing tagandprobe"
    print "Calulation with mtcut: "+ str(mtcut)


    ## --- Log output ------------------------------------------------------
    process.load("FWCore.MessageService.MessageLogger_cfi")
    process.MessageLogger.cerr = cms.untracked.PSet(
        placeholder = cms.untracked.bool(True)
        )
    process.MessageLogger.cout = cms.untracked.PSet(
        INFO = cms.untracked.PSet(reportEvery = cms.untracked.int32(reportEveryEvt))
        )
    process.options = cms.untracked.PSet(
        wantSummary = cms.untracked.bool(True)
        ) 


    ## --- Files to process ------------------------------------------------
    process.maxEvents = cms.untracked.PSet(
        input = cms.untracked.int32(numProcessedEvt)
        )
    process.source = cms.Source("PoolSource",

        fileNames = cms.untracked.vstring(testFileName)
 #       fileNames = cms.untracked.vstring(
 #		'file:/nfs/dust/cms/user/csander/LHE/workdir/simulation_test/T1qqqqHV/output_66.root'
#		)
        )
        
    ## --- Output file -----------------------------------------------------
    process.TFileService = cms.Service(
        "TFileService",
        fileName = cms.string(outFileName+".root")
        )
    # config of producers
    RecoCandVector = cms.vstring() 
    VarsDouble = cms.vstring()
    VarsInt = cms.vstring()
    VarsBool = cms.vstring()
    # baseline producers
    process.Baseline = cms.Sequence(
    )
    #special sequences
    #lost-lepton variables
    process.LostLepton = cms.Sequence(
      
    )
    #gamma+jet variables
    process.GammaJet = cms.Sequence(
      
    )
    # basic producers
    ## --- Setup WeightProducer -------------------------------------------
    from AllHadronicSUSY.WeightProducer.getWeightProducer_cff import getWeightProducer
    process.WeightProducer = getWeightProducer(testFileName)
    process.WeightProducer.Lumi                       = cms.double(4000)
    process.WeightProducer.PU                         = cms.int32(0) # PU S10 3 for S10 2 for S7
    process.WeightProducer.FileNamePUDataDistribution = cms.string("NONE")
    print process.WeightProducer.PU
    process.Baseline += process.WeightProducer
    VarsDouble.extend(['WeightProducer:weight(Weight)'])
    from AllHadronicSUSY.Utils.primaryverticies_cfi import primaryverticies
    process.NVtx = primaryverticies.clone(
    VertexCollection  = cms.InputTag('offlineSlimmedPrimaryVertices'),
    )
    process.Baseline += process.NVtx
    VarsInt.extend(['NVtx'])
    ## isotrack producer
    from AllHadronicSUSY.Utils.trackIsolationMaker_cfi import trackIsolationFilter
    from AllHadronicSUSY.Utils.trackIsolationMaker_cfi import trackIsolationCounter
    
    process.IsolatedElectronTracksVeto = trackIsolationFilter.clone(
      doTrkIsoVeto= False,
      vertexInputTag = cms.InputTag("offlineSlimmedPrimaryVertices"),
      pfCandidatesTag = cms.InputTag("packedPFCandidates"),
      dR_ConeSize         = cms.double(0.3),
      dz_CutValue         = cms.double(0.1),
      minPt_PFCandidate   = cms.double(5.0),
      isoCut              = cms.double(0.2),
      pdgId               = cms.int32(11),
      etaCut=cms.double(2.5),
      mTCut=mtcut,
      )

    process.IsolatedMuonTracksVeto = trackIsolationFilter.clone(
      doTrkIsoVeto= False,
      vertexInputTag = cms.InputTag("offlineSlimmedPrimaryVertices"),
      pfCandidatesTag = cms.InputTag("packedPFCandidates"),
      dR_ConeSize         = cms.double(0.3),
      dz_CutValue         = cms.double(0.1),
      minPt_PFCandidate   = cms.double(5.0),
      isoCut              = cms.double(0.2), 
      pdgId               = cms.int32(13),
      etaCut=cms.double(2.5),
      mTCut=mtcut,
      )

    process.IsolatedPionTracksVeto = trackIsolationFilter.clone(
      doTrkIsoVeto= False,
      vertexInputTag = cms.InputTag("offlineSlimmedPrimaryVertices"),
      pfCandidatesTag = cms.InputTag("packedPFCandidates"),
      dR_ConeSize         = cms.double(0.3),
      dz_CutValue         = cms.double(0.1),
      minPt_PFCandidate   = cms.double(10.0),
      isoCut              = cms.double(0.1),
      pdgId               = cms.int32(211),
      etaCut=cms.double(2.5),
      mTCut=mtcut,
      )

    process.Baseline += process.IsolatedElectronTracksVeto
    process.Baseline += process.IsolatedMuonTracksVeto
    process.Baseline += process.IsolatedPionTracksVeto

    VarsInt.extend(['IsolatedElectronTracksVeto:isoTracks(isoElectronTracks)'])
    VarsInt.extend(['IsolatedMuonTracksVeto:isoTracks(isoMuonTracks)'])
    VarsInt.extend(['IsolatedPionTracksVeto:isoTracks(isoPionTracks)'])

    #done with isolated track vetos stuff
    ########################################################
    
    from AllHadronicSUSY.Utils.leptonproducer_cfi import leptonproducer
    process.LeptonsNew = leptonproducer.clone(
      MuonTag = cms.InputTag('slimmedMuons'),
      ElectronTag = cms.InputTag('slimmedElectrons'),
      PrimaryVertex = cms.InputTag('offlineSlimmedPrimaryVertices'),
      minElecPt								  = cms.double(10),
      maxElecEta								  = cms.double(2.5),
      minMuPt								  = cms.double(10),
      maxMuEta								  = cms.double(2.4),
      UseMiniIsolation = cms.bool(True),
      muIsoValue								  = cms.double(0.2),
      elecIsoValue								  = cms.double(0.1), # only has an effect when used with miniIsolation
      METTag = cms.InputTag('slimmedMETs'), 
      )
    process.Baseline += process.LeptonsNew
    VarsInt.extend(['LeptonsNew(Leptons)'])
    process.LeptonsNewTag = leptonproducer.clone(
      MuonTag = cms.InputTag('slimmedMuons'),
      ElectronTag = cms.InputTag('slimmedElectrons'),
      PrimaryVertex = cms.InputTag('offlineSlimmedPrimaryVertices'),
      minElecPt								  = cms.double(20),
      maxElecEta								  = cms.double(2.5),
      minMuPt								  = cms.double(20),
      maxMuEta								  = cms.double(2.4),
      muIsoValue								  = cms.double(0.2),
      elecIsoValue								  = cms.double(0.1), # only has an effect when used with miniIsolation
      UseMiniIsolation = cms.bool(True),
      METTag = cms.InputTag('slimmedMETs'), 
      )
    process.Baseline += process.LeptonsNewTag
    VarsInt.extend(['LeptonsNewTag(TagLeptonHighPT)'])

    ####### good photons
    process.goodPhotons = cms.EDProducer("PhotonIDisoProducer",
                                         photonCollection = cms.untracked.InputTag("slimmedPhotons"),
                                         rhoCollection = cms.untracked.InputTag("fixedGridRhoFastjetAll"), 
                                         debug = cms.untracked.bool(False)
                                         )
    process.Baseline += process.goodPhotons
    ######  done with photons -- good photon tag is InputTag('goodPhotons','bestPhoton')
    #################################

    ####### good jets -- the start of everything   
    JECPatch = cms.string('sqlite_file:PHYS14_V4_MC.db')
    #if gridcontrol: 
    if os.getenv('GC_CONF'): 
      JECPatch = cms.string('sqlite_file:../src/PHYS14_V4_MC.db')

    ####### JECs
    # get the JECs
    # this requires the user to download the .db file from this twiki
    # https://twiki.cern.ch/twiki/bin/viewauth/CMS/JECDataMC
######
    #from CondCore.DBCommon.CondDBSetup_cfi import *
    #process.jec = cms.ESSource("PoolDBESSource",CondDBSetup,
                               ##connect = cms.string('sqlite_file:../src/PHYS14_V4_MC.db'),
                               #connect = JECPatch,
                               ##connect = cms.string('AllHadronicSUSY/TreeMaker/test/PHYS14_V4_MC.db'),
                               #toGet = cms.VPSet(
            #cms.PSet(record = cms.string("JetCorrectionsRecord"),
                     #tag = cms.string("JetCorrectorParametersCollection_PHYS14_V4_MC_AK4PFchs"),
                     #label= cms.untracked.string("AK4PFchs")
                     #)
            #)
                               #)
    #process.es_prefer_jec = cms.ESPrefer("PoolDBESSource","jec")
    
    #from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff import patJetCorrFactorsUpdated
    #process.patJetCorrFactorsReapplyJEC = patJetCorrFactorsUpdated.clone(
        #src = cms.InputTag("slimmedJets"),
        #levels = ['L1FastJet', 
                  #'L2Relative', 
                  #'L3Absolute'],
        #payload = 'AK4PFchs' ) # Make sure to choose the appropriate levels and payload here!
    
    #from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff import patJetsUpdated
    #process.patJetsReapplyJEC = patJetsUpdated.clone(
        #jetSource = cms.InputTag("slimmedJets"),
        #jetCorrFactorsSource = cms.VInputTag(cms.InputTag("patJetCorrFactorsReapplyJEC"))
        #)
########

    ###### THIS IS JUST TEMPORARY, THESE SHOULD BE INCLUDED!!!!
    #process.Baseline += process.patJetCorrFactorsReapplyJEC
    #process.Baseline += process.patJetsReapplyJEC

    ############
    from AllHadronicSUSY.Utils.goodjetsproducer_cfi import GoodJetsProducer
    process.GoodJets = GoodJetsProducer.clone(
      TagMode = cms.bool(True),
      JetTag= cms.InputTag('slimmedJets'),
      #JetTag= cms.InputTag('patJetsReapplyJEC'),
      maxJetEta = cms.double(5.0),
      maxMuFraction = cms.double(2),
      minNConstituents = cms.double(2),
      maxNeutralFraction = cms.double(0.90),
      maxPhotonFraction = cms.double(0.95),
      minChargedMultiplicity = cms.double(0),
      minChargedFraction = cms.double(0),
      maxChargedEMFraction = cms.double(0.99),
      jetPtFilter = cms.double(30),
      ExcludeLepIsoTrackPhotons = cms.bool(True),
      JetConeSize = cms.double(0.04),
      MuonTag = cms.InputTag('LeptonsNew:IdIsoMuon'),
      ElecTag = cms.InputTag('LeptonsNew:IdIsoElectron'),
      IsoElectronTrackTag = cms.InputTag('IsolatedElectronTracksVeto'),
      IsoMuonTrackTag = cms.InputTag('IsolatedMuonTracksVeto'),
      IsoPionTrackTag = cms.InputTag('IsolatedPionTracksVeto'),
      PhotonTag = cms.InputTag('goodPhotons','bestPhoton'),
      )
    process.Baseline += process.GoodJets
    VarsBool.extend(['GoodJets(JetID)'])
    #### done with good jets
    ###########################################
    
    ####### Tag And Probe
    from AllHadronicSUSY.Utils.selectpfcandidates_cfi import SelectPFCandidates
    process.SelectedPFCandidatesProbeCands5 = SelectPFCandidates.clone(
    PackedPFCandidatesTag               = cms.InputTag('packedPFCandidates'),
    MinPt								  = cms.double(5),
    MaxEta								  = cms.double(2.5),
    )
    process.SelectedPFCandidatesProbeCands10 = SelectPFCandidates.clone(
    PackedPFCandidatesTag               = cms.InputTag('packedPFCandidates'),
    MinPt								  = cms.double(10),
    MaxEta								  = cms.double(2.5),
    )
    process.SelectedPFElecCandidates = SelectPFCandidates.clone(
    PackedPFCandidatesTag               = cms.InputTag('packedPFCandidates'),
    MinPt								  = cms.double(5),
    MaxEta								  = cms.double(2.5),
    SelectpdgIDTyp							  = cms.int32(11), 
    )
    process.SelectedPFMuCandidates = SelectPFCandidates.clone(
    PackedPFCandidatesTag               = cms.InputTag('packedPFCandidates'),
    MinPt								  = cms.double(5),
    MaxEta								  = cms.double(2.4),
    SelectpdgIDTyp							  = cms.int32(13), 
    )
    process.SelectedPFPionCandidates = SelectPFCandidates.clone(
    PackedPFCandidatesTag               = cms.InputTag('packedPFCandidates'),
    MinPt                                                                 = cms.double(10),
    MaxEta                                                                = cms.double(2.4),
    SelectpdgIDTyp                                                        = cms.int32(211), 
    )
    ###########################################################################################
    # mu iso
    from AllHadronicSUSY.Utils.activityProducer_cfi import activityProducer
    process.MuonIsoTag = activityProducer.clone(
    objectSource   = cms.InputTag('LeptonsNew:IdMuon'), # probe source
    objectMatchSource   = cms.InputTag('LeptonsNew:IdIsoMuon'), # to be matched to collection  (IDIsoMuons)
    objectTyp = cms.int32(1),
    activityTyp = cms.int32(0),
    maxDeltaR = cms.double(1.0),
    jetSrc = cms.InputTag('HTJets'),
    TagObjectForMTWComputation = cms.InputTag('LeptonsNew:IdIsoMuon'),
    )
    process.tpPairs = cms.EDProducer("CandViewShallowCloneCombiner",
    decay = cms.string("LeptonsNewTag:IdIsoMuon@+ LeptonsNew:IdMuon@-"), # charge coniugate states are implied
    cut   = cms.string("0.0 < mass < 13000.0"),
    )
    process.muonIsoEffs = cms.EDAnalyzer("TagProbeFitTreeProducer",
    # pairs
    tagProbePairs = cms.InputTag("tpPairs"),
    #arbitration   = cms.string("OneProbe"),
    arbitration   = cms.string("None"),
    massForArbitration = cms.double(91),
    # variables to use
    variables = cms.PSet(
    ## methods of reco::Candidate
    eta = cms.string("eta"),
    pt  = cms.string("pt"),
    #muonsMiniIso = cms.string("muonsMiniIso"),
    #miniIso = cms.string("miniIso"),
    ## a method of the reco::Muon object (thanks to the 3.4.X StringParser)
    #nsegm = cms.string("numberOfMatches"), 
    ## this one is an external variable
    #drj = cms.InputTag("drToNearestJet"),
    #nGV = cms.InputTag("goodVertices.size()"),
    #miniIso = cms.InputTag("probeMuons","muonsMiniIso"),
    #miniIso = cms.InputTag("probeMuons","miniIso"),
    activity = cms.InputTag("MuonIsoTag","Activity"),
    Passing = cms.InputTag("MuonIsoTag","Passing"),
    Pt = cms.InputTag("MuonIsoTag","Pt"),
    Eta = cms.InputTag("MuonIsoTag","Eta"),
    MTW = cms.InputTag("MuonIsoTag","MTW"),
    MTWClean = cms.InputTag("MuonIsoTag","MTWClean"),
    RecomputedMET = cms.InputTag("MuonIsoTag","RecomputedMET"),
    TagObjectsNum = cms.InputTag("MuonIsoTag","TagObjectsNum"),
    Weight = cms.InputTag("MuonIsoTag","Weight"),
    HT = cms.InputTag("MuonIsoTag","HT"),
    MHT = cms.InputTag("MuonIsoTag","MHT"),
    NJets = cms.InputTag("MuonIsoTag","NJets"),
    ),
    # choice of what defines a 'passing' probe
    flags = cms.PSet(
    ## one defined by an external collection of passing probes
    #passingCal = cms.InputTag("probesPassingCal"), 
    ## two defined by simple string cuts
    #   passingGlb = cms.string("isGlobalMuon"),
    passingIso = cms.InputTag("LeptonsNew:IdMuon"),
    #passingIso2 = cms.InputTag("MuonIsoTag:PassingProbes"),
    #passingGlb = cms.string("Passing<0.5"),
    #passingIso = cms.InputTag("MuonIsoTag","Passing"),
    #passingIso = cms.InputTag("probePassingIso"),
    ),
    # mc-truth info
    isMC = cms.bool(False),
    motherPdgId = cms.vint32(22,23),
    #makeMCUnbiasTree = cms.bool(True),
    #checkMotherInUnbiasEff = cms.bool(True),
    #tagMatches = cms.InputTag("muMcMatch"),
    #probeMatches  = cms.InputTag("muMcMatch"),
    #allProbes     = cms.InputTag("probeMuons"),
    )
    ###########################################################################################
    # mu reco
    process.MuonRecoTag = activityProducer.clone(
    #objectSource   = cms.InputTag('SelectedPFCandidatesProbeCands10'), # probe source
    objectSource   = cms.InputTag('SelectedPFMuCandidates'), # probe source
    objectMatchSource   = cms.InputTag('LeptonsNew:IdMuon'), # to be matched to collection  (IDIsoMuons)
    objectTyp = cms.int32(11),
    activityTyp = cms.int32(0),
    maxDeltaR = cms.double(1.0),
    jetSrc = cms.InputTag('HTJets'),
    TagObjectForMTWComputation = cms.InputTag('LeptonsNew:IdIsoMuon'),
    )
    process.tpPairsMuReco = cms.EDProducer("CandViewShallowCloneCombiner",
    #decay = cms.string("LeptonsNewTag:IdIsoMuon@+ SelectedPFCandidatesProbeCands10@-"), # charge coniugate states are implied
    decay = cms.string("LeptonsNewTag:IdIsoMuon@+ SelectedPFMuCandidates@-"), # charge coniugate states are implied
    cut   = cms.string("0.0 < mass < 13000.0"),
    )
    process.muonRecoEffs = cms.EDAnalyzer("TagProbeFitTreeProducer",
    # pairs
    tagProbePairs = cms.InputTag("tpPairsMuReco"),
    #arbitration   = cms.string("OneProbe"),
    arbitration   = cms.string("None"),
    massForArbitration = cms.double(91),
    # variables to use
    variables = cms.PSet(
    ## methods of reco::Candidate
    eta = cms.string("eta"),
    pt  = cms.string("pt"),
    #muonsMiniIso = cms.string("muonsMiniIso"),
    #miniIso = cms.string("miniIso"),
    ## a method of the reco::Muon object (thanks to the 3.4.X StringParser)
    #nsegm = cms.string("numberOfMatches"), 
    ## this one is an external variable
    #drj = cms.InputTag("drToNearestJet"),
    #nGV = cms.InputTag("goodVertices.size()"),
    #miniIso = cms.InputTag("probeMuons","muonsMiniIso"),
    #miniIso = cms.InputTag("probeMuons","miniIso"),
    activity = cms.InputTag("MuonRecoTag","Activity"),
    Passing = cms.InputTag("MuonRecoTag","Passing"),
    Pt = cms.InputTag("MuonRecoTag","Pt"),
    Eta = cms.InputTag("MuonRecoTag","Eta"),
    MTW = cms.InputTag("MuonRecoTag","MTW"),
    MTWClean = cms.InputTag("MuonRecoTag","MTWClean"),
    RecomputedMET = cms.InputTag("MuonRecoTag","RecomputedMET"),
    TagObjectsNum = cms.InputTag("MuonRecoTag","TagObjectsNum"),
    Weight = cms.InputTag("MuonRecoTag","Weight"),
    HT = cms.InputTag("MuonRecoTag","HT"),
    MHT = cms.InputTag("MuonRecoTag","MHT"),
    NJets = cms.InputTag("MuonRecoTag","NJets"),
    ),
    # choice of what defines a 'passing' probe
    flags = cms.PSet(
    ## one defined by an external collection of passing probes
    #passingCal = cms.InputTag("probesPassingCal"), 
    ## two defined by simple string cuts
    #   passingGlb = cms.string("isGlobalMuon"),
    passingIso = cms.InputTag("LeptonsNew:IdMuon"),
    #passingGlb = cms.string("Passing<0.5"),
    #passingIso = cms.InputTag("MuonIsoTag","Passing"),
    #passingIso = cms.InputTag("probePassingIso"),
    ),
    # mc-truth info
    isMC = cms.bool(False),
    motherPdgId = cms.vint32(22,23),
    #makeMCUnbiasTree = cms.bool(True),
    #checkMotherInUnbiasEff = cms.bool(True),
    #tagMatches = cms.InputTag("muMcMatch"),
    #probeMatches  = cms.InputTag("muMcMatch"),
    #allProbes     = cms.InputTag("probeMuons"),
    )
    ###########################################################################################
    # elec iso
    from AllHadronicSUSY.Utils.activityProducer_cfi import activityProducer
    process.ElectronIsoTag = activityProducer.clone(
    objectSource   = cms.InputTag('LeptonsNew:IdElectron'), # probe source
    objectMatchSource   = cms.InputTag('LeptonsNew:IdIsoElectron'), # to be matched to collection  (IDIsoMuons)
    objectTyp = cms.int32(2), ## change here for differnt lepton isotrack typ
    activityTyp = cms.int32(0),
    maxDeltaR = cms.double(1.0),
    jetSrc = cms.InputTag('HTJets'),
    TagObjectForMTWComputation = cms.InputTag('LeptonsNew:IdIsoElectron'),
    )
    process.tpPairsElecIso = cms.EDProducer("CandViewShallowCloneCombiner",
    decay = cms.string("LeptonsNewTag:IdIsoElectron@+ LeptonsNew:IdElectron@-"), # charge coniugate states are implied
    cut   = cms.string("0.0 < mass < 13000.0"),
    )
    process.elecIsoEffs = cms.EDAnalyzer("TagProbeFitTreeProducer",
    # pairs
    tagProbePairs = cms.InputTag("tpPairsElecIso"),
    #arbitration   = cms.string("OneProbe"),
    arbitration   = cms.string("None"),
    massForArbitration = cms.double(91),
    # variables to use
    variables = cms.PSet(
    ## methods of reco::Candidate
    eta = cms.string("eta"),
    pt  = cms.string("pt"),
    #muonsMiniIso = cms.string("muonsMiniIso"),
    #miniIso = cms.string("miniIso"),
    ## a method of the reco::Muon object (thanks to the 3.4.X StringParser)
    #nsegm = cms.string("numberOfMatches"), 
    ## this one is an external variable
    #drj = cms.InputTag("drToNearestJet"),
    #nGV = cms.InputTag("goodVertices.size()"),
    #miniIso = cms.InputTag("probeMuons","muonsMiniIso"),
    #miniIso = cms.InputTag("probeMuons","miniIso"),
    activity = cms.InputTag("ElectronIsoTag","Activity"),
    Passing = cms.InputTag("ElectronIsoTag","Passing"),
    Pt = cms.InputTag("ElectronIsoTag","Pt"),
    Eta = cms.InputTag("ElectronIsoTag","Eta"),
    MTW = cms.InputTag("ElectronIsoTag","MTW"),
    MTWClean = cms.InputTag("ElectronIsoTag","MTWClean"),
    RecomputedMET = cms.InputTag("ElectronIsoTag","RecomputedMET"),
    TagObjectsNum = cms.InputTag("ElectronIsoTag","TagObjectsNum"),
    Weight = cms.InputTag("ElectronIsoTag","Weight"),
    HT = cms.InputTag("ElectronIsoTag","HT"),
    MHT = cms.InputTag("ElectronIsoTag","MHT"),
    NJets = cms.InputTag("ElectronIsoTag","NJets"),
    ),
    # choice of what defines a 'passing' probe
    flags = cms.PSet(
    ## one defined by an external collection of passing probes
    #passingCal = cms.InputTag("probesPassingCal"), 
    ## two defined by simple string cuts
    #   passingGlb = cms.string("isGlobalMuon"),
    passingIso = cms.InputTag("LeptonsNew:IdElectron"),
    #passingGlb = cms.string("Passing<0.5"),
    #passingIso = cms.InputTag("MuonIsoTag","Passing"),
    #passingIso = cms.InputTag("probePassingIso"),
    ),
    # mc-truth info
    isMC = cms.bool(False),
    motherPdgId = cms.vint32(22,23),
    #makeMCUnbiasTree = cms.bool(True),
    #checkMotherInUnbiasEff = cms.bool(True),
    #tagMatches = cms.InputTag("muMcMatch"),
    #probeMatches  = cms.InputTag("muMcMatch"),
    #allProbes     = cms.InputTag("probeMuons"),
    )
    ###########################################################################################
    # elec reco
    process.ElectronRecoTag = activityProducer.clone(
    objectSource   = cms.InputTag('slimmedPhotons'), # probe source
    objectMatchSource   = cms.InputTag('LeptonsNew:IdElectron'), # to be matched to collection  (IDIsoMuons)
    objectTyp = cms.int32(22),
    activityTyp = cms.int32(0),
    maxDeltaR = cms.double(1.0),
    jetSrc = cms.InputTag('HTJets'),
    TagObjectForMTWComputation = cms.InputTag('LeptonsNew:IdIsoElectron'),
    )
    process.tpPairsElecReco = cms.EDProducer("CandViewShallowCloneCombiner",
    decay = cms.string("LeptonsNewTag:IdIsoElectron@+ slimmedPhotons"), # charge coniugate states are implied
    cut   = cms.string("0.0 < mass < 13000.0"),
    )
    process.elecRecoEffs = cms.EDAnalyzer("TagProbeFitTreeProducer",
    # pairs
    tagProbePairs = cms.InputTag("tpPairsElecReco"),
    #arbitration   = cms.string("OneProbe"),
    arbitration   = cms.string("None"),
    massForArbitration = cms.double(91),
    # variables to use
    variables = cms.PSet(
    ## methods of reco::Candidate
    eta = cms.string("eta"),
    pt  = cms.string("pt"),
    #muonsMiniIso = cms.string("muonsMiniIso"),
    #miniIso = cms.string("miniIso"),
    ## a method of the reco::Muon object (thanks to the 3.4.X StringParser)
    #nsegm = cms.string("numberOfMatches"), 
    ## this one is an external variable
    #drj = cms.InputTag("drToNearestJet"),
    #nGV = cms.InputTag("goodVertices.size()"),
    #miniIso = cms.InputTag("probeMuons","muonsMiniIso"),
    #miniIso = cms.InputTag("probeMuons","miniIso"),
    activity = cms.InputTag("ElectronRecoTag","Activity"),
    Passing = cms.InputTag("ElectronRecoTag","Passing"),
    Pt = cms.InputTag("ElectronRecoTag","Pt"),
    Eta = cms.InputTag("ElectronRecoTag","Eta"),
    MTW = cms.InputTag("ElectronRecoTag","MTW"),
    MTWClean = cms.InputTag("ElectronRecoTag","MTWClean"),
    RecomputedMET = cms.InputTag("ElectronRecoTag","RecomputedMET"),
    TagObjectsNum = cms.InputTag("ElectronRecoTag","TagObjectsNum"),
    Weight = cms.InputTag("ElectronRecoTag","Weight"),
    HT = cms.InputTag("ElectronRecoTag","HT"),
    MHT = cms.InputTag("ElectronRecoTag","MHT"),
    NJets = cms.InputTag("ElectronRecoTag","NJets"),
    ),
    # choice of what defines a 'passing' probe
    flags = cms.PSet(
    ## one defined by an external collection of passing probes
    #passingCal = cms.InputTag("probesPassingCal"), 
    ## two defined by simple string cuts
    #   passingGlb = cms.string("isGlobalMuon"),
    passingIso = cms.InputTag("LeptonsNew:IdMuon"),
    #passingGlb = cms.string("Passing<0.5"),
    #passingIso = cms.InputTag("MuonIsoTag","Passing"),
    #passingIso = cms.InputTag("probePassingIso"),
    ),
    # mc-truth info
    isMC = cms.bool(False),
    motherPdgId = cms.vint32(22,23),
    #makeMCUnbiasTree = cms.bool(True),
    #checkMotherInUnbiasEff = cms.bool(True),
    #tagMatches = cms.InputTag("muMcMatch"),
    #probeMatches  = cms.InputTag("muMcMatch"),
    #allProbes     = cms.InputTag("probeMuons"),
    )
    ###########################################################################################
    # isolated track muons
    process.IsoTrackMuonTag = activityProducer.clone(
    #objectSource   = cms.InputTag('SelectedPFCandidatesProbeCands5'), # probe source
    objectSource   = cms.InputTag('SelectedPFMuCandidates'), # probe source
    objectMatchSource   = cms.InputTag('IsolatedMuonTracksVeto'), # to be matched to collection  (IDIsoMuons)
    objectTyp = cms.int32(3),
    activityTyp = cms.int32(0),
    maxDeltaR = cms.double(1.0),
    jetSrc = cms.InputTag('HTJets'),
    TagObjectForMTWComputation = cms.InputTag('LeptonsNew:IdIsoMuon'),
    METTag = cms.InputTag('slimmedMETs'), 
    )
    process.tpPairsIsoTrackMu = cms.EDProducer("CandViewShallowCloneCombiner",
    decay = cms.string("LeptonsNew:IdIsoMuon@+ SelectedPFMuCandidates@-"), # charge coniugate states are implied
    #decay = cms.string("LeptonsNewTag:IdIsoMuon@+ SelectedPFCandidatesProbeCands5@-"), # charge coniugate states are implied
    cut   = cms.string("0.0 < mass < 13000.0"),
    )
    process.IsoTrackMuonIsoEffs = cms.EDAnalyzer("TagProbeFitTreeProducer",
    # pairs
    tagProbePairs = cms.InputTag("tpPairsIsoTrackMu"),
    #arbitration   = cms.string("OneProbe"),
    arbitration   = cms.string("None"),
    massForArbitration = cms.double(91),
    # variables to use
    variables = cms.PSet(
    ## methods of reco::Candidate
    eta = cms.string("eta"),
    pt  = cms.string("pt"),
    #muonsMiniIso = cms.string("muonsMiniIso"),
    #miniIso = cms.string("miniIso"),
    ## a method of the reco::Muon object (thanks to the 3.4.X StringParser)
    #nsegm = cms.string("numberOfMatches"), 
    ## this one is an external variable
    #drj = cms.InputTag("drToNearestJet"),
    #nGV = cms.InputTag("goodVertices.size()"),
    #miniIso = cms.InputTag("probeMuons","muonsMiniIso"),
    #miniIso = cms.InputTag("probeMuons","miniIso"),
    activity = cms.InputTag("IsoTrackMuonTag","Activity"),
    Passing = cms.InputTag("IsoTrackMuonTag","Passing"),
    Pt = cms.InputTag("IsoTrackMuonTag","Pt"),
    Eta = cms.InputTag("IsoTrackMuonTag","Eta"),
    MTW = cms.InputTag("IsoTrackMuonTag","MTW"),
    MTWClean = cms.InputTag("IsoTrackMuonTag","MTWClean"),
    RecomputedMET = cms.InputTag("IsoTrackMuonTag","RecomputedMET"),
    TagObjectsNum = cms.InputTag("IsoTrackMuonTag","TagObjectsNum"),
    Weight = cms.InputTag("IsoTrackMuonTag","Weight"),
    HT = cms.InputTag("IsoTrackMuonTag","HT"),
    MHT = cms.InputTag("IsoTrackMuonTag","MHT"),
    NJets = cms.InputTag("IsoTrackMuonTag","NJets"),
    ),
    # choice of what defines a 'passing' probe
    flags = cms.PSet(
    ## one defined by an external collection of passing probes
    #passingCal = cms.InputTag("probesPassingCal"), 
    ## two defined by simple string cuts
    #   passingGlb = cms.string("isGlobalMuon"),
    passingIso = cms.InputTag("LeptonsNew:IdMuon"),
    #passingIso2 = cms.InputTag("MuonIsoTag:PassingProbes"),
    #passingGlb = cms.string("Passing<0.5"),
    #passingIso = cms.InputTag("MuonIsoTag","Passing"),
    #passingIso = cms.InputTag("probePassingIso"),
    ),
    # mc-truth info
    isMC = cms.bool(False),
    motherPdgId = cms.vint32(22,23),
    #makeMCUnbiasTree = cms.bool(True),
    #checkMotherInUnbiasEff = cms.bool(True),
    #tagMatches = cms.InputTag("muMcMatch"),
    #probeMatches  = cms.InputTag("muMcMatch"),
    #allProbes     = cms.InputTag("probeMuons"),
    )
    ###########################################################################################
    # isolated track electrons
    process.IsoTrackElecTag = activityProducer.clone(
    objectSource   = cms.InputTag('SelectedPFElecCandidates'), # probe source
    #objectSource   = cms.InputTag('SelectedPFCandidatesProbeCands5'), # probe source
    objectMatchSource   = cms.InputTag('IsolatedElectronTracksVeto'), # to be matched to collection  (IDIsoMuons)
    objectTyp = cms.int32(4),
    activityTyp = cms.int32(0),
    maxDeltaR = cms.double(1.0),
    jetSrc = cms.InputTag('HTJets'),
    TagObjectForMTWComputation = cms.InputTag('LeptonsNew:IdIsoElectron'),
    METTag = cms.InputTag('slimmedMETs'), 
    )
    process.tpPairsIsoTrackElec = cms.EDProducer("CandViewShallowCloneCombiner",
    decay = cms.string("LeptonsNew:IdIsoElectron@+ SelectedPFElecCandidates@-"), # charge coniugate states are implied
    #decay = cms.string("LeptonsNewTag:IdIsoElectron@+ SelectedPFCandidatesProbeCands5@-"), # charge coniugate states are implied
    cut   = cms.string("0.0 < mass < 13000.0"),
    )
    process.IsoTrackElecIsoEffs = cms.EDAnalyzer("TagProbeFitTreeProducer",
    # pairs
    tagProbePairs = cms.InputTag("tpPairsIsoTrackElec"),
    #arbitration   = cms.string("OneProbe"),
    arbitration   = cms.string("None"),
    massForArbitration = cms.double(91),
    # variables to use
    variables = cms.PSet(
    ## methods of reco::Candidate
    eta = cms.string("eta"),
    pt  = cms.string("pt"),
    #muonsMiniIso = cms.string("muonsMiniIso"),
    #miniIso = cms.string("miniIso"),
    ## a method of the reco::Muon object (thanks to the 3.4.X StringParser)
    #nsegm = cms.string("numberOfMatches"), 
    ## this one is an external variable
    #drj = cms.InputTag("drToNearestJet"),
    #nGV = cms.InputTag("goodVertices.size()"),
    #miniIso = cms.InputTag("probeMuons","muonsMiniIso"),
    #miniIso = cms.InputTag("probeMuons","miniIso"),
    activity = cms.InputTag("IsoTrackElecTag","Activity"),
    Passing = cms.InputTag("IsoTrackElecTag","Passing"),
    Pt = cms.InputTag("IsoTrackElecTag","Pt"),
    Eta = cms.InputTag("IsoTrackElecTag","Eta"),
    MTW = cms.InputTag("IsoTrackElecTag","MTW"),
    MTWClean = cms.InputTag("IsoTrackElecTag","MTWClean"),
    RecomputedMET = cms.InputTag("IsoTrackElecTag","RecomputedMET"),
    TagObjectsNum = cms.InputTag("IsoTrackElecTag","TagObjectsNum"),
    Weight = cms.InputTag("IsoTrackElecTag","Weight"),
    HT = cms.InputTag("IsoTrackElecTag","HT"),
    MHT = cms.InputTag("IsoTrackElecTag","MHT"),
    NJets = cms.InputTag("IsoTrackElecTag","NJets"),
    ),
    # choice of what defines a 'passing' probe
    flags = cms.PSet(
    ## one defined by an external collection of passing probes
    #passingCal = cms.InputTag("probesPassingCal"), 
    ## two defined by simple string cuts
    #   passingGlb = cms.string("isGlobalMuon"),
    passingIso = cms.InputTag("LeptonsNew:IdMuon"),
    #passingIso2 = cms.InputTag("MuonIsoTag:PassingProbes"),
    #passingGlb = cms.string("Passing<0.5"),
    #passingIso = cms.InputTag("MuonIsoTag","Passing"),
    #passingIso = cms.InputTag("probePassingIso"),
    ),
    # mc-truth info
    isMC = cms.bool(False),
    motherPdgId = cms.vint32(22,23),
    #makeMCUnbiasTree = cms.bool(True),
    #checkMotherInUnbiasEff = cms.bool(True),
    #tagMatches = cms.InputTag("muMcMatch"),
    #probeMatches  = cms.InputTag("muMcMatch"),
    #allProbes     = cms.InputTag("probeMuons"),
    )
    # isolated track pion
    process.IsoTrackPionTag = activityProducer.clone(
    objectSource   = cms.InputTag('SelectedPFPionCandidates'), # probe source
    #objectSource   = cms.InputTag('SelectedPFCandidatesProbeCands5'), # probe source
    objectMatchSource   = cms.InputTag('IsolatedPionTracksVeto'), # to be matched to collection  (IDIsoMuons)
    objectTyp = cms.int32(5),
    activityTyp = cms.int32(0),
    maxDeltaR = cms.double(1.0),
    jetSrc = cms.InputTag('HTJets'),
    TagObjectForMTWComputation = cms.InputTag('IsolatedPionTracksVeto'),
    METTag = cms.InputTag('slimmedMETs'), 
    )
    process.tpPairsIsoTrackPion = cms.EDProducer("CandViewShallowCloneCombiner",
    decay = cms.string("IsolatedPionTracksVeto@+ SelectedPFPionCandidates@-"), # charge coniugate states are implied
    #decay = cms.string("LeptonsNewTag:IdIsoElectron@+ SelectedPFCandidatesProbeCands5@-"), # charge coniugate states are implied
    cut   = cms.string("0.0 < mass < 13000.0"),
    )
    process.IsoTrackPionIsoEffs = cms.EDAnalyzer("TagProbeFitTreeProducer",
    # pairs
    tagProbePairs = cms.InputTag("tpPairsIsoTrackPion"),
    #arbitration   = cms.string("OneProbe"),
    arbitration   = cms.string("None"),
    massForArbitration = cms.double(91),
    # variables to use
    variables = cms.PSet(
    ## methods of reco::Candidate
    eta = cms.string("eta"),
    pt  = cms.string("pt"),
    #muonsMiniIso = cms.string("muonsMiniIso"),
    #miniIso = cms.string("miniIso"),
    ## a method of the reco::Muon object (thanks to the 3.4.X StringParser)
    #nsegm = cms.string("numberOfMatches"), 
    ## this one is an external variable
    #drj = cms.InputTag("drToNearestJet"),
    #nGV = cms.InputTag("goodVertices.size()"),
    #miniIso = cms.InputTag("probeMuons","muonsMiniIso"),
    #miniIso = cms.InputTag("probeMuons","miniIso"),
    activity = cms.InputTag("IsoTrackPionTag","Activity"),
    Passing = cms.InputTag("IsoTrackPionTag","Passing"),
    Pt = cms.InputTag("IsoTrackPionTag","Pt"),
    Eta = cms.InputTag("IsoTrackPionTag","Eta"),
    MTW = cms.InputTag("IsoTrackPionTag","MTW"),
    RecomputedMET = cms.InputTag("IsoTrackPionTag","RecomputedMET"),
    TagObjectsNum = cms.InputTag("IsoTrackPionTag","TagObjectsNum"),
    Weight = cms.InputTag("IsoTrackPionTag","Weight"),
    HT = cms.InputTag("IsoTrackPionTag","HT"),
    MHT = cms.InputTag("IsoTrackPionTag","MHT"),
    NJets = cms.InputTag("IsoTrackPionTag","NJets"),
    ),
    # choice of what defines a 'passing' probe
    flags = cms.PSet(
    ## one defined by an external collection of passing probes
    #passingCal = cms.InputTag("probesPassingCal"), 
    ## two defined by simple string cuts
    #   passingGlb = cms.string("isGlobalMuon"),
    passingIso = cms.InputTag("LeptonsNew:IdMuon"),
    #passingIso2 = cms.InputTag("MuonIsoTag:PassingProbes"),
    #passingGlb = cms.string("Passing<0.5"),
    #passingIso = cms.InputTag("MuonIsoTag","Passing"),
    #passingIso = cms.InputTag("probePassingIso"),
    ),
    # mc-truth info
    isMC = cms.bool(False),
    motherPdgId = cms.vint32(22,23),
    #makeMCUnbiasTree = cms.bool(True),
    #checkMotherInUnbiasEff = cms.bool(True),
    #tagMatches = cms.InputTag("muMcMatch"),
    #probeMatches  = cms.InputTag("muMcMatch"),
    #allProbes     = cms.InputTag("probeMuons"),
    )
    from AllHadronicSUSY.Utils.subJetSelection_cfi import SubJetSelection
    process.HTJets = SubJetSelection.clone(
    JetTag  = cms.InputTag('GoodJets'),
    MinPt								  = cms.double(30),
    MaxEta								  = cms.double(2.4),
    )
    process.Baseline += process.HTJets
    from AllHadronicSUSY.Utils.htdouble_cfi import htdouble
    process.HT = htdouble.clone(
    JetTag  = cms.InputTag('HTJets'),
    )
    process.Baseline += process.HT
    VarsDouble.extend(['HT'])
    from AllHadronicSUSY.Utils.doublefilter_cfi import DoubleFilter
    process.HTFilter = DoubleFilter.clone(
    DoubleTag          = cms.InputTag('HT'),
    CutValue	= cms.double('500'),
    )
    from AllHadronicSUSY.Utils.njetint_cfi import njetint
    process.NJets = njetint.clone(
    JetTag  = cms.InputTag('HTJets'),
    )
    process.Baseline += process.NJets
    VarsInt.extend(['NJets'])
    from AllHadronicSUSY.Utils.btagint_cfi import btagint
    process.BTags = btagint.clone(
    JetTag  = cms.InputTag('HTJets'),
    BTagInputTag	        = cms.string('combinedInclusiveSecondaryVertexV2BJetTags'),
    BTagCutValue					= cms.double(0.814)
    )
    process.Baseline += process.BTags
    VarsInt.extend(['BTags'])
    from AllHadronicSUSY.Utils.subJetSelection_cfi import SubJetSelection
    process.MHTJets = SubJetSelection.clone(
    JetTag  = cms.InputTag('GoodJets'),
    MinPt								  = cms.double(30),
    MaxEta								  = cms.double(5.0),
    )
    process.Baseline += process.MHTJets
    from AllHadronicSUSY.Utils.mhtdouble_cfi import mhtdouble
    process.MHT = mhtdouble.clone(
    JetTag  = cms.InputTag('MHTJets'),
    )
    process.Baseline += process.MHT
    VarsDouble.extend(['MHT:Pt(MHT)','MHT:Phi(MHT_Phi)'])
    process.MHTFilter = DoubleFilter.clone(
    DoubleTag          = cms.InputTag('MHT:Pt'),
    CutValue	= cms.double('100'),
    )
    if applybaseline:
			process.Baseline += process.HTFilter
			process.Baseline += process.MHTFilter
    from AllHadronicSUSY.Utils.deltaphidouble_cfi import deltaphidouble
    process.DeltaPhi = deltaphidouble.clone(
    DeltaPhiJets  = cms.InputTag('HTJets'),
    MHTJets  = cms.InputTag("MHTJets"),
    )
    process.Baseline += process.DeltaPhi
    VarsDouble.extend(['DeltaPhi:DeltaPhi1','DeltaPhi:DeltaPhi2','DeltaPhi:DeltaPhi3'])
    from AllHadronicSUSY.Utils.metdouble_cfi import metdouble
    process.MET = metdouble.clone(
    METTag  = cms.InputTag("slimmedMETs"),
    JetTag  = cms.InputTag('HTJets'),
    )
    process.Baseline += process.MET
    VarsDouble.extend(['MET:minDeltaPhiN','MET:DeltaPhiN1','MET:DeltaPhiN2','MET:DeltaPhiN3','MET:Pt(METPt)','MET:Phi(METPhi)'])
    #lost-lepton producers
    from AllHadronicSUSY.Utils.jetproperties_cfi import jetproperties
    process.JetsProperties = jetproperties.clone(
    JetTag  = cms.InputTag('HTJets'),
    BTagInputTag	        = cms.string('combinedInclusiveSecondaryVertexV2BJetTags'),
    METTag  = cms.InputTag("slimmedMETs"),
    )
    process.Baseline += process.JetsProperties
    from AllHadronicSUSY.Utils.genLeptonRecoCand_cfi import genLeptonRecoCand
    process.GenLeptons = genLeptonRecoCand.clone(
    PrunedGenParticleTag  = cms.InputTag("prunedGenParticles"),
    )
    process.LostLepton += process.GenLeptons
    process.SelectedPFCandidates = SelectPFCandidates.clone(
    PackedPFCandidatesTag               = cms.InputTag('packedPFCandidates'),
    MinPt								  = cms.double(4),
    MaxEta								  = cms.double(5.0),
    )
    process.LostLepton += process.SelectedPFCandidates
    #gamma+jet producers




    #define sequences
    
    #baseline RA2/b variables default shared variables
    RecoCandVector.extend(['LeptonsNew:IdIsoMuon(Muons)','LeptonsNew:IdIsoElectron(Electrons)'])




    ## --- Final paths ----------------------------------------------------

    # put together final sequence with optional producers
    process.AdditionalSequence = cms.Sequence()
    if lostlepton:
      print "Adding LostLepton calculations to final path and tree"
      process.AdditionalSequence += process.LostLepton 
      process.AdditionalSequence += process.SelectedPFElecCandidates
      process.AdditionalSequence += process.SelectedPFMuCandidates
      process.AdditionalSequence += process.SelectedPFPionCandidates
    #  VarsRecoCand = cms.vstring('selectedIDIsoMuons','selectedIDMuons','selectedIDIsoElectrons','selectedIDMuons','IsolatedTracks','HTJets'),
   #   RecoCandVector.extend(['selectedIDIsoMuons','selectedIDMuons','selectedIDIsoElectrons','selectedIDElectrons','IsolatedTracks']),
      RecoCandVector.extend(['IsolatedElectronTracksVeto|IsolatedElectronTracksVeto:MT(F_MT)','IsolatedMuonTracksVeto|IsolatedMuonTracksVeto:MT(F_MT)','IsolatedPionTracksVeto|IsolatedPionTracksVeto:MT(F_MT)','LeptonsNew:IdIsoMuon(selectedIDIsoMuons)|LeptonsNew:MuIDIsoMTW(F_MTW)','LeptonsNew:IdMuon(selectedIDMuons)|LeptonsNew:MuIDMTW(F_MTW)','LeptonsNew:IdIsoElectron(selectedIDIsoElectrons)|LeptonsNew:ElecIDIsoMTW(F_MTW)','LeptonsNew:IdElectron(selectedIDElectrons)|LeptonsNew:ElecIDMTW(F_MTW)','SelectedPFCandidates|SelectedPFCandidates:Charge(I_Charge)|SelectedPFCandidates:Typ(I_Typ)']),
      RecoCandVector.extend(['GenLeptons:Boson(GenBoson)|GenLeptons:BosonPDGId(I_GenBosonPDGId)','GenLeptons:Neutrino(Neutrino)','GenLeptons:Muon(GenMu)|GenLeptons:MuonTauDecay(I_GenMuFromTau)' ,'GenLeptons:Electron(GenElec)|GenLeptons:ElectronTauDecay(I_GenElecFromTau)','GenLeptons:Tau(GenTau)|GenLeptons:TauHadronic(I_GenTauHad)'] ) # gen information on leptons
      RecoCandVector.extend(['GenLeptons:TauDecayCands(TauDecayCands)|GenLeptons:TauDecayCandspdgID(I_pdgID)|GenLeptons:TauDecayCandsCharge(I_Charge)'])
      RecoCandVector.extend(['LeptonsNewTag:IdIsoMuon(selectedIDIsoMuonsNoMiniIso)','LeptonsNewTag:IdIsoElectron(selectedIDIsoElectronsNoMiniIso)'] ) # gen information on leptons
      RecoCandVector.extend(['JetsProperties(Jets)|JetsProperties:bDiscriminatorUser(F_bDiscriminator)|JetsProperties:chargedEmEnergyFraction(F_chargedEmEnergyFraction)|JetsProperties:chargedHadronEnergyFraction(F_chargedHadronEnergyFraction)|JetsProperties:chargedHadronMultiplicity(I_chargedHadronMultiplicity)|JetsProperties:electronMultiplicity(I_electronMultiplicity)|JetsProperties:jetArea(F_jetArea)|JetsProperties:muonEnergyFraction(F_muonEnergyFraction)|JetsProperties:muonMultiplicity(I_muonMultiplicity)|JetsProperties:neutralEmEnergyFraction(F_neutralEmEnergyFraction)|JetsProperties:neutralHadronMultiplicity(I_neutralHadronMultiplicity)|JetsProperties:photonEnergyFraction(F_photonEnergyFraction)|JetsProperties:photonMultiplicity(I)'] ) # jet information on various variables
      RecoCandVector.extend(['slimmedElectrons','slimmedMuons'])
      RecoCandVector.extend(['SelectedPFElecCandidates','SelectedPFMuCandidates','SelectedPFPionCandidates'])

    if gammajets:
      print "Adding Gamma+Jet calculations to final path and tree"
      process.AdditionalSequence += process.GammaJet 
    # configure treemaker
    from AllHadronicSUSY.TreeMaker.treeMaker import TreeMaker
    process.TreeMaker2 = TreeMaker.clone(
    	TreeName          = cms.string("PreSelection"),
    	VarsRecoCand = RecoCandVector, 
    	VarsDouble  	  = VarsDouble,
    	VarsInt = VarsInt,
    	VarsBool = VarsBool,

    	)
    process.dump = cms.EDAnalyzer("EventContentAnalyzer")
    #tag and probe
    if tagandprobe:
	#		process.Baseline += process.dump 
			process.Baseline += process.SelectedPFCandidatesProbeCands5
			process.Baseline += process.SelectedPFCandidatesProbeCands10
			process.Baseline += process.SelectedPFElecCandidates
			process.Baseline += process.SelectedPFMuCandidates
			process.Baseline += process.SelectedPFPionCandidates
			process.Baseline += process.GenLeptons
			process.Baseline += process.JetsProperties
			process.Baseline += process.SelectedPFCandidates
			process.Baseline += process.MuonIsoTag
			process.Baseline += process.tpPairs
			process.Baseline += process.muonIsoEffs
			process.Baseline += process.MuonRecoTag
			process.Baseline += process.tpPairsMuReco
			process.Baseline += process.muonRecoEffs
			process.Baseline += process.ElectronIsoTag
			process.Baseline += process.tpPairsElecIso
			process.Baseline += process.elecIsoEffs
			process.Baseline += process.ElectronRecoTag
			process.Baseline += process.tpPairsElecReco
			process.Baseline += process.elecRecoEffs
			process.Baseline += process.IsoTrackMuonTag
			process.Baseline += process.tpPairsIsoTrackMu
			process.Baseline += process.IsoTrackMuonIsoEffs
			process.Baseline += process.IsoTrackElecTag
			process.Baseline += process.tpPairsIsoTrackElec
			process.Baseline += process.IsoTrackElecIsoEffs
			process.Baseline += process.IsoTrackPionTag
                        process.Baseline += process.tpPairsIsoTrackPion
                        process.Baseline += process.IsoTrackPionIsoEffs
			RecoCandVector.extend(['slimmedPhotons'])

			### begin Zinv stuff ###
    if doZinv:   
			
			process.ZinvClean = cms.Sequence()
			
			from AllHadronicSUSY.Utils.zproducer_cfi import ZProducer
			process.maketheZs = ZProducer.clone(
			ElectronTag = cms.InputTag('LeptonsNew:IdIsoElectron'),
			MuonTag = cms.InputTag('LeptonsNew:IdIsoMuon')
			)
			process.ZinvClean += process.maketheZs
			VarsInt.extend(['maketheZs:ZNum'])
			process.TreeMaker2.VectorTLorentzVector.append("maketheZs:Zp4")
			
			from AllHadronicSUSY.Utils.jetcleaner_cfi import JetCleaner
			process.cleanTheJets = JetCleaner.clone(
			JetTag  = cms.InputTag('GoodJets'),
			ElectronTag = cms.InputTag('LeptonsNew:IdIsoElectron'),
			ElectronR = cms.double(0.4),
			MuonTag = cms.InputTag('LeptonsNew:IdIsoMuon'),
			MuonR = cms.double(0.4),
			PhotonTag = cms.InputTag('goodPhotons', 'bestPhoton'),
			PhotonR = cms.double(0.4)
			)
			process.ZinvClean += process.cleanTheJets
			
			from AllHadronicSUSY.Utils.subJetSelection_cfi import SubJetSelection
			process.HTJetsclean = SubJetSelection.clone(
			JetTag = cms.InputTag('cleanTheJets', 'GoodJetsclean'),
			MinPt = cms.double(30),
			MaxEta = cms.double(2.4),
			)
			process.ZinvClean += process.HTJetsclean
			
			from AllHadronicSUSY.Utils.htdouble_cfi import htdouble
			process.HTclean = htdouble.clone(
			JetTag = cms.InputTag('HTJetsclean'),
			)
			process.ZinvClean += process.HTclean
			VarsDouble.extend(['HTclean'])
			
			from AllHadronicSUSY.Utils.njetint_cfi import njetint
			process.NJetsclean = njetint.clone(
			JetTag = cms.InputTag('HTJetsclean'),
			)
			process.ZinvClean += process.NJetsclean
			VarsInt.extend(['NJetsclean'])
			
			from AllHadronicSUSY.Utils.btagint_cfi import btagint
			process.BTagsclean = btagint.clone(
			JetTag = cms.InputTag('HTJetsclean'),
			BTagInputTag = cms.string('combinedInclusiveSecondaryVertexV2BJetTags'),
			BTagCutValue = cms.double(0.814)
			)
			process.ZinvClean += process.BTagsclean
			VarsInt.extend(['BTagsclean'])
			
			from AllHadronicSUSY.Utils.subJetSelection_cfi import SubJetSelection
			process.MHTJetsclean = SubJetSelection.clone(
			JetTag = cms.InputTag('cleanTheJets', 'GoodJetsclean'),
			MinPt = cms.double(30),
			MaxEta = cms.double(5.0),
			)
			process.ZinvClean += process.MHTJetsclean
			
			from AllHadronicSUSY.Utils.mhtdouble_cfi import mhtdouble
			process.MHTclean = mhtdouble.clone(
			JetTag = cms.InputTag('MHTJetsclean'),
			)
			process.ZinvClean += process.MHTclean
			VarsDouble.extend(['MHTclean'])
			
			from AllHadronicSUSY.Utils.metdouble_cfi import metdouble
			process.METclean = metdouble.clone(
			METTag = cms.InputTag("slimmedMETs"),
			JetTag = cms.InputTag('HTJetsclean'),
			cleanTag = cms.untracked.VInputTag(cms.InputTag('LeptonsNew:IdIsoElectron'), cms.InputTag('LeptonsNew:IdIsoMuon'), cms.InputTag('goodPhotons', 'bestPhoton'))
			)
			process.ZinvClean += process.METclean
			VarsDouble.extend(['METclean:minDeltaPhiN(minDeltaPhiNclean)', 'METclean:Pt(METPtclean)'])
			
			process.AdditionalSequence += process.ZinvClean
			### end Zinv stuff ###

    process.WriteTree = cms.Path(
      process.Baseline *
      process.AdditionalSequence *
     # process.dump *
    	process.TreeMaker2
    )
# ==================

process.ak4Jets = cms.EDProducer(
    "fourVectorProducer",
    particleCollection=cms.untracked.InputTag("GoodJets"),
    debug=cms.untracked.bool(False))

process.ak4JetsRaw = cms.EDProducer(
    "fourVectorProducer",
    particleCollection=cms.untracked.InputTag("slimmedJets"),
    debug=cms.untracked.bool(False))

from AllHadronicSUSY.Utils.jetproperties_cfi import jetproperties
process.JetsPropertiesRaw = jetproperties.clone(
    JetTag=cms.InputTag('slimmedJets'),
    BTagInputTag=cms.string('combinedInclusiveSecondaryVertexV2BJetTags'),
    METTag=cms.InputTag("slimmedMETs"),
)

process.TreeMaker2.VectorTLorentzVector.append("ak4Jets")
process.TreeMaker2.VectorTLorentzVector.append("ak4JetsRaw")
process.TreeMaker2.VectorInt.append("GoodJets:passJetID(ak4Jets_passedJetID)")

process.TreeMaker2.VectorDouble.append(
    "JetsProperties:bDiscriminator(ak4Jets_CSVdisc)")
process.TreeMaker2.VectorDouble.append(
    "JetsProperties:chargedHadronEnergyFraction(ak4Jets_chargeHadEfrac)")
process.TreeMaker2.VectorDouble.append(
    "JetsProperties:neutralHadronEnergyFraction(ak4Jets_neutralHadEfrac)")
process.TreeMaker2.VectorDouble.append(
    "JetsProperties:photonEnergyFraction(ak4Jets_photonEfrac)")