Esempio n. 1
0
 def __rdf_from_dataset(self, dataset):
     t_names = [ntuple.directory for ntuple in \
         dataset.ntuples]
     if len(set(t_names)) == 1:
         tree_name = t_names.pop()
     else:
         raise NameError(
             'Impossible to create RDataFrame with different tree names')
     chain = TChain()
     ftag_fchain = {}
     for ntuple in dataset.ntuples:
         chain.Add('{}/{}'.format(ntuple.path, ntuple.directory))
         for friend in ntuple.friends:
             if friend.tag not in ftag_fchain.keys():
                 ftag_fchain[friend.tag] = TChain()
             ftag_fchain[friend.tag].Add('{}/{}'.format(
                 friend.path, friend.directory))
     for ch in ftag_fchain.values():
         chain.AddFriend(ch)
         # Keep friend chains alive
         self.friend_tchains.append(ch)
     if self.nthreads != 1:
         EnableImplicitMT(self.nthreads)
     # Keep main chain alive
     self.tchains.append(chain)
     rdf = RDataFrame(chain)
     rcw = RDataFrameCutWeight(rdf)
     return rcw
Esempio n. 2
0
    def load(self):
        """Loads the process data.

        Returns:
            A TChain for the process.
        """

        chain = TChain(self._tree)
        for f in self._files:
            if not isfile(f):
                raise RuntimeError('file does not exist {0}'.format(f))
            chain.Add(f)

        for friend in self._friends:
            chain.AddFriend(self._load_friend(*friend))

        return chain
Esempio n. 3
0
        def attach_friend_info_if_present(current_range: Ranges.TreeRange,
                                          chain: ROOT.TChain) -> None:
            """
            Adds info about friend trees to the input chain. Also aligns the
            starting and ending entry of the friend chain cache to those of the
            main chain.
            """
            # Gather information about friend trees. Check that we got an
            # RFriendInfo struct and that it's not empty
            if (current_range.friendinfo is not None
                    and not current_range.friendinfo.fFriendNames.empty()):
                # Zip together the information about friend trees. Each
                # element of the iterator represents a single friend tree.
                # If the friend is a TChain, the zipped information looks like:
                # (name, alias), (file1.root, file2.root, ...), (subname1, subname2, ...)
                # If the friend is a TTree, the file list is made of
                # only one filename and the list of names of the sub trees
                # is empty, so the zipped information looks like:
                # (name, alias), (filename.root, ), ()
                zipped_friendinfo = zip(
                    current_range.friendinfo.fFriendNames,
                    current_range.friendinfo.fFriendFileNames,
                    current_range.friendinfo.fFriendChainSubNames)
                for (
                        friend_name, friend_alias
                ), friend_filenames, friend_chainsubnames in zipped_friendinfo:
                    # Start a TChain with the current friend treename
                    friend_chain = ROOT.TChain(str(friend_name))
                    # Add each corresponding file to the TChain
                    # Use zip_longest to address both cases:
                    # - Friend is a TTree, filenames is a vector of length one
                    #   and chainsubnames is an empty vector.
                    # - Friend is a TChain, filenames and chainsubnames are
                    #   vectors of the same length.
                    for filename, chainsubname in zip_longest(
                            friend_filenames, friend_chainsubnames,
                            fillvalue=""):
                        fullpath = filename + "?#" + chainsubname
                        friend_chain.Add(str(fullpath))

                    # Set cache on the same range as the parent TChain
                    friend_chain.SetCacheEntryRange(current_range.globalstart,
                                                    current_range.globalend)
                    # Finally add friend TChain to the parent (with alias)
                    chain.AddFriend(friend_chain, friend_alias)
Esempio n. 4
0
def rdf_from_dataset_helper(dataset):
    t_names = [ntuple.directory for ntuple in \
        dataset.ntuples]
    if len(set(t_names)) == 1:
        tree_name = t_names.pop()
    else:
        raise NameError(
            'Impossible to create RDataFrame with different tree names')
    chain = TChain()
    ftag_fchain = {}
    friend_tchains = []
    for ntuple in dataset.ntuples:
        chain.Add('{}/{}'.format(ntuple.path, ntuple.directory))
        for friend in ntuple.friends:
            if friend.tag not in ftag_fchain.keys():
                ftag_fchain[friend.tag] = TChain()
            ftag_fchain[friend.tag].Add('{}/{}'.format(friend.path,
                                                       friend.directory))
    for ch in ftag_fchain.values():
        chain.AddFriend(ch)
        # Keep friend chains alive
        friend_tchains.append(ch)
    return (chain, friend_tchains)
Esempio n. 5
0
def getRootChain(jobpar,treeName):

    import glob
    # print infiles
    InputRootFiles = glob.glob (jobpar.inputFiles)

    nStep1=0
    nStep1WithPU=0
    tr = TChain(treeName)    
    trFR = TChain("treeFriend")
    for rootfile in InputRootFiles:
        basename=os.path.basename(rootfile)
        print "Adding to chain: ",rootfile,rootfile.find("pnfs")
        if rootfile.find("pnfs")>-1:
            rootfile="dcache:" + rootfile

        ## print "XXX: ", rootfile

        f=TFile.Open(rootfile)
        h1=f.Get('Count')  # get histogram with Step 1 event count
        # print h.GetEntries()
        nStep1 = nStep1 + h1.GetBinContent(1)

        h2=f.Get('CountWithPU')  # get histogram with Step 1 event count
        # print h.GetEntries()
        nStep1WithPU = nStep1WithPU + h2.GetBinContent(1)
        f.Close()

        tr.AddFile(rootfile)

        ## now get friends
        FriendDir=os.path.join(os.path.dirname(rootfile),"NewFriends")
        if jobpar.isData:
            if os.environ.has_key('DATAFRIEND'):
                FriendDir=os.environ['DATAFRIEND']
        else:
            if os.environ.has_key('MCFRIEND'):
                FriendDir=os.environ['MCFRIEND']

        ## if jobpar.ApplyBJetRegressionSubjets:
        friendName=basename[:basename.find(".root")] + "_Friend.root"
        rootFriend=os.path.join(FriendDir,friendName)
            #if not os.path.isfile(rootFriend):
            #    print "Could not find Friend " + rootFriend+ " -- Exiting"
            #    sys.exit(1)

        print "Adding friend ",rootFriend
        trFR.AddFile(rootFriend)


    if (tr.GetEntries() != trFR.GetEntries()):
        print "Number of entries on Main and Friend chains differ -- exiting program"
        sys.exit(1)

    tr.AddFriend(trFR)
    SetOwnership( tr, False )

    print "Number of Step1 events: ", nStep1
    print "Number of Step1 events (pileup weighted): ", nStep1WithPU

    return tr, nStep1, nStep1WithPU
dqdsChain = TChain("dQdSAnalysis")
matchChain = TChain("MatchAnalysis")
eventChain = TChain("EventVertexTree")

for infile in inputFiles:

    vtxChain.Add(infile)
    LEEChain.Add(infile)
    angleChain.Add(infile)
    shapeChain.Add(infile)
    gapChain.Add(infile)
    dqdsChain.Add(infile)
    matchChain.Add(infile)
    eventChain.Add(infile)

vtxChain.AddFriend(LEEChain)
vtxChain.AddFriend(angleChain)
vtxChain.AddFriend(shapeChain)
vtxChain.AddFriend(gapChain)
vtxChain.AddFriend(dqdsChain)
vtxChain.AddFriend(matchChain)

# ------------------------------------------------------------------------------------------------------------------------------------------------- #
FidVolumeCut = True
TwoParticleCut = True
GapCut = True
TwoTrackCut = True
SkipManyVertCut = True

tooManyVerts = 100
binning = 36
class DataReader(Path):
    """Create RooDataSet from a TChain"""
    def __init__(self, cfg):
        """Init"""
        super(DataReader, self).__init__(cfg)
        self.argset = cfg['argset']
        self.reset()
        return

    def reset(self):
        super(DataReader, self).reset()
        self.ch = None
        self.friend = None
        self.dataset = {}

    def __str__(self):
        list_of_files = self.ch.GetListOfFiles()
        next_file = TIter(list_of_files)
        print("Input file list is given below.")
        for f in range(list_of_files.GetEntries()):
            print("\t{0}".format(next_file().GetTitle()))
        print("End of the input file list.")
        return ""

    @classmethod
    def templateConfig(cls):
        cfg = {
            'name': "DataReader",
            'ifile': [],
            'ifriend': [],
            'ifriendIndex': ["Run", "Event"],
            'argset': [],
            'dataset': [],
            'preloadFile': None,
        }
        return cfg

    def createDataSet(self, dname, dcut):
        """Create named dataset"""
        if dname in self.dataset.keys():
            return self.dataset[dname]
        data = RooDataSet(dname, "", self.ch, self.argset, dcut)
        self.dataset[dname] = data
        return data

    def createDataSets(self, cfg):
        """Create named dataset"""
        for name, cut in cfg:
            if self.cfg['preloadFile'] and os.path.exists(
                    self.cfg['preloadFile']):
                file_preload = ROOT.TFile(self.cfg['preloadFile'])
                data = file_preload.Get(name)
                if not data == None:
                    self.dataset[name] = data
                file_preload.Close()
            self.createDataSet(name, cut)
        return self.dataset

    def _runPath(self):
        self.ch = TChain("tree")
        for f in self.cfg['ifile']:
            self.ch.Add(f)
        if len(self.cfg['ifriend']) > 0:
            self.friend = TChain("tree")
            for f in self.cfg['ifriend']:
                self.friend.Add(f)
            self.friend.BuildIndex(*self.cfg['ifriendIndex'])
            self.ch.AddFriend(self.friend)
        self.createDataSets(self.cfg['dataset'])
        pass

    def _addSource(self):
        """Add dataset and arguments to source pool"""
        if self.cfg['preloadFile'] and not os.path.exists(
                self.cfg['preloadFile']):
            file_preload = ROOT.TFile(self.cfg['preloadFile'], 'RECREATE')
            for dname, d in self.dataset.items():
                d.Write()
            file_preload.Close()

        if not 'source' in self.cfg.keys():
            self.cfg['source'] = {}
        self.cfg['source']['{0}.tree'.format(self.name)] = self.ch
        self.cfg['source']['{0}.argset'.format(self.name)] = self.argset
        if len(self.cfg['ifriend']) > 0:
            self.cfg['source']['{0}.friend'.format(self.name)] = self.friend
        for dname, d in self.dataset.items():
            self.cfg['source'][dname] = d
            self.logger.logINFO("{0} events in {1}.".format(
                d.sumEntries(), dname))
        super(DataReader, self)._addSource()
Esempio n. 8
0
                    help="Truth tree name")

args = parser.parse_args()

print("Read trees from", args.inputfiles)

tree_reco = TChain(args.reco_tree)
for infile in args.inputfiles:
    tree_reco.Add(infile)

tree_truth = TChain(args.truth_tree)
for infile in args.inputfiles:
    tree_truth.Add(infile)

# make them friends!
tree_reco.AddFriend(tree_truth)

branches_reco = {}
branches_truth = {}
cuts = "isMatched"

if args.truth_tree == 'parton':
    branches_reco = {
        ('thad', 'pt'): 'klfitter_bestPerm_topHad_pt',
        ('thad', 'eta'): 'klfitter_bestPerm_topHad_eta',
        ('thad', 'y'): 'klfitter_bestPerm_topHad_y',
        ('thad', 'phi'): 'klfitter_bestPerm_topHad_phi',
        ('thad', 'm'): 'klfitter_bestPerm_topHad_m',
        ('thad', 'E'): 'klfitter_bestPerm_topHad_E',
        ('thad', 'pout'): 'klfitter_bestPerm_topHad_pout',
        ('tlep', 'pt'): 'klfitter_bestPerm_topLep_pt',
Esempio n. 9
0
class Plotter(object):
    counter = 0

    def __init__(self, sigFilePath, bgFilePath=None, treeName="jets"):
        self.sigFilePath = sigFilePath
        self.bgFilePath = bgFilePath
        self.treeName = treeName
        self.friends = None
        self.customBins = False

    def AddFriend(self, f):
        if self.friends == None:
            self.friends = [f]
        else:
            self.friends.append(f)

    def makeMIPlot(self, varList, doTruth=True):
        self.chain = TChain(self.treeName)
        self.chain.AddFile(self.bgFilePath)
        self.chain.AddFile(self.sigFilePath)
        fSig = TFile(self.sigFilePath)
        fBg = TFile(self.bgFilePath)
        tSig = fSig.Get(self.treeName)
        tBg = fBg.Get(self.treeName)
        self.fBuffer = TFile('/tmp/buffer.root', 'RECREATE')
        self.truthtree = TTree('truthtree', 'truthtree')
        truth = arr('f', [1])
        self.truthtree.Branch('truth', truth, 'truth/F')
        nEntries = tSig.GetEntries()
        for iE in xrange(nEntries):
            self.truthtree.Fill()
        truth = arr('f', [0])
        nEntries = tBg.GetEntries()
        for iE in xrange(nEntries):
            self.truthtree.Fill()
        self.chain.AddFriend(self.truthtree)
        mi = MutualInformer(self.chain)
        nVars = len(varList)
        hplot = TH2D('mi' + str(Plotter.counter), 'mi' + str(Plotter.counter),
                     nVars, 0, nVars, nVars, 0, nVars)
        Plotter.counter += 1
        for iV in xrange(nVars):
            for jV in xrange(iV):
                varA = varList[iV]
                varB = varList[jV]
                if doTruth:
                    val = mi.MITruth(varA[0], varA[1], varA[2], varA[3],
                                     varB[0], varB[1], varB[2], varB[3])
                else:
                    val = mi.MI(varA[0], varA[1], varA[2], varA[3], varB[0],
                                varB[1], varB[2], varB[3])
                print iV + 1, jV + 1, val
                hplot.SetBinContent(jV + 1, iV + 1, val)
                hplot.SetBinContent(iV + 1, jV + 1, val)
        return hplot

    def makeCorrelationPlot(self, varList1, varList2, cut=""):
        fIn = TFile(self.sigFilePath)
        t = fIn.Get(self.treeName)
        if self.friends is not None:
            for f in self.friends:
                tFriend = fIn.Get(f)
                t.AddFriend(tFriend)
        gROOT.cd()
        c = Correlator(t)
        nVars1 = len(varList1)
        isSymmetric = False
        if varList2 == None:
            varList2 = varList1
            isSymmetric = True
        nVars2 = len(varList2)
        hplot = TH2D('cor' + str(Plotter.counter),
                     'cor' + str(Plotter.counter), nVars1, 0, nVars1, nVars2,
                     0, nVars2)
        Plotter.counter += 1
        xaxis = hplot.GetXaxis()
        yaxis = hplot.GetYaxis()
        matrix = empty([nVars1, nVars2])
        if isSymmetric:
            for iV in xrange(nVars1):
                if self.customBins:
                    xaxis.SetBinLabel(iV + 1, varList1[iV][0])
                    yaxis.SetBinLabel(iV + 1, varList1[iV][0])
                else:
                    xaxis.SetBinLabel(iV + 1, varList1[iV])
                    yaxis.SetBinLabel(iV + 1, varList1[iV])
                for jV in xrange(iV + 1):
                    varA = varList1[iV]
                    varB = varList1[jV]
                    if self.customBins:
                        val = c.pearsonSuperFast(varA[0], varB[0], cut,
                                                 varList1, varA[1], varB[1])
                    else:
                        val = c.pearsonSuperFast(varA, varB, cut, varList1)
                    hplot.SetBinContent(jV + 1, iV + 1, val)
                    hplot.SetBinContent(iV + 1, jV + 1, val)
                    matrix[iV, jV] = val
                    matrix[jV, iV] = val
        else:
            for iV in xrange(nVars1):
                if self.customBins:
                    xaxis.SetBinLabel(iV + 1, varList1[iV][0])
                else:
                    xaxis.SetBinLabel(iV + 1, varList1[iV])
                for jV in xrange(nVars2):
                    if self.customBins:
                        yaxis.SetBinLabel(jV + 1, varList2[jV][0])
                    else:
                        yaxis.SetBinLabel(jV + 1, varList2[jV])
                    varA = varList1[iV]
                    varB = varList2[jV]
                    if self.customBins:
                        val = c.pearsonSuperFast(varA[0], varB[0], cut,
                                                 varA[1], varB[1])
                    else:
                        val = c.pearsonSuperFast(varA, varB, cut, varList1)
                    print iV, jV, val
                    hplot.SetBinContent(iV + 1, jV + 1, val)
                    matrix[iV, jV] = val
        return hplot, matrix

    def makeCovariancePlot(self, varList1, varList2, cut=""):
        fIn = TFile(self.sigFilePath)
        t = fIn.Get(self.treeName)
        gROOT.cd()
        c = Covariator(t)
        nVars1 = len(varList1)
        isSymmetric = False
        if varList2 == None:
            varList2 = varList1
            isSymmetric = True
        nVars2 = len(varList2)
        hplot = TH2D('cov' + str(Plotter.counter),
                     'cov' + str(Plotter.counter), nVars1, 0, nVars1, nVars2,
                     0, nVars2)
        Plotter.counter += 1
        xaxis = hplot.GetXaxis()
        yaxis = hplot.GetYaxis()
        matrix = empty([nVars1, nVars2])
        if isSymmetric:
            for iV in xrange(nVars1):
                xaxis.SetBinLabel(iV + 1, varList1[iV])
                yaxis.SetBinLabel(iV + 1, varList1[iV])
                for jV in xrange(iV + 1):
                    varA = varList1[iV]
                    varB = varList1[jV]
                    val = c.covSuperFast(varA, varB, cut)
                    hplot.SetBinContent(jV + 1, iV + 1, val)
                    hplot.SetBinContent(iV + 1, jV + 1, val)
                    matrix[iV, jV] = val
                    matrix[jV, iV] = val
        else:
            for iV in xrange(nVars1):
                xaxis.SetBinLabel(iV + 1, varList1[iV])
                for jV in xrange(nVars2):
                    yaxis.SetBinLabel(jV + 1, varList2[jV])
                    varA = varList1[iV]
                    varB = varList2[jV]
                    val = c.covSuperFast(varA, varB, cut)
                    hplot.SetBinContent(iV + 1, jV + 1, val)
                    matrix[iV, jV] = val
        return hplot, matrix
Esempio n. 10
0
    CSVChain = TChain(CSVTree)
    CSVChain.Add(input_file)

    TopRecoTree = "likelihood/TopReco"
    TopRecoChain = TChain(TopRecoTree)
    TopRecoChain.Add(input_file)

    NeutrinoTree = "likelihood/Neutrino"
    NeutrinoChain = TChain(NeutrinoTree)
    NeutrinoChain.Add(input_file)

    LikelihoodTree = "TTbar_plus_X_analysis/EPlusJets/Ref selection/LikelihoodReco/Discriminator"
    LikelihoodChain = TChain(LikelihoodTree)
    LikelihoodChain.Add(input_file)

    CSVChain.AddFriend(TopRecoChain)
    CSVChain.AddFriend(NeutrinoChain)
    CSVChain.AddFriend(LikelihoodChain)
    CSVChain.SetBranchStatus("*", 1)

    ########## 			FILL HISTOGRAMS 		##########

    for event in CSVChain:

        Jet_CSV = event.__getattr__("Jets")
        TypeOfJet = event.__getattr__("TypeofJet")  #1 for light, 2 for b

        for JetIndex in range(0, len(TypeOfJet)):
            if (TypeOfJet[JetIndex] == 1):
                LightJetCSVHist.Fill(Jet_CSV[JetIndex])
            if (TypeOfJet[JetIndex] == 2):
Esempio n. 11
0
class DataReader(Path):
    """Create RooDataSet from a TChain"""
    def __init__(self, cfg):
        """Init"""
        super(DataReader, self).__init__(cfg)
        self.argset = cfg['argset']
        self.reset()
        return

    def reset(self):
        super(DataReader, self).reset()
        self.ch = None
        self.friend = None
        self.dataset = {}

    def __str__(self):
        list_of_files = self.ch.GetListOfFiles()
        next_file = TIter(list_of_files)
        self.logger.logDEBUG("Input file list is given below.")
        self.logger.logDEBUG("Absolute path: ",
                             os.path.dirname(next_file.GetTitle()))
        ifile = next_file.Begin()
        for f in range(list_of_files.GetEntries()):
            self.logger.logDEBUG("\t{0}".format(
                os.path.basename(ifile.GetTitle())),
                                 Stamp=False)
            ifile = next_file.Next()
        self.logger.logDEBUG("End of the input file list.")
        return 1

    @classmethod
    def templateConfig(cls):
        cfg = {
            'name': "DataReader",
            'ifile': [],
            'ifriend': [],
            'ifriendIndex': ["Run", "Event"],
            'argset': [],
            'dataset': [],
            'preloadFile': None,
        }
        return cfg

    def createDataSet(self, dname, dcut):
        """Return named dataset, create if not exist"""
        if dname in self.dataset.keys() and not self.process.cfg['args'].force:
            self.logger.logINFO("\033[0;34;47m Dataset: ", dname,
                                " Already Exists! \033[0m. Total Entries:",
                                self.dataset[dname].sumEntries())
            self.logger.logDEBUG(dcut, Stamp=False)
            return 1
        tempfile_preload = ROOT.TFile(tempfile.gettempdir() + "/temp.root",
                                      'RECREATE')  #Pritam
        RooCut = ROOT.RooFit.Cut(dcut)
        Import = ROOT.RooFit.Import(self.ch)
        Range = ROOT.RooFit.CutRange(
            dname.split(".")[2])  # Not taking effect, need review
        Weight = ROOT.RooFit.WeightVar(self.cfg['weight'])
        if self.argset.find("Bmass"):
            self.argset.find(
                "Bmass").removeRange()  # Analysis specific line introduced
        if "dataReader" in dname or "sigMCGENReader" in dname:
            data = RooDataSet(dname, "", self.argset, Import, RooCut, Range)
        else:
            data = RooDataSet(dname, "Weighted dataset", self.argset, Import,
                              RooCut, Range, Weight)

        if self.argset.find("Phimass"):
            self.argset.find("Phimass").setBins(20)
            datahist = ROOT.RooDataHist(
                dname + ".hist", "",
                ROOT.RooArgSet(self.argset.find("Phimass")), data)
            self.dataset[dname + ".hist"] = deepcopy(datahist)
        data.Write()
        self.dataset[dname] = deepcopy(data)
        self.logger.logINFO("\033[0;34;47m Creating Dataset: ", dname,
                            ": \033[0m. Total Entries:", data.sumEntries())
        self.logger.logDEBUG(dcut, Stamp=False)
        tempfile_preload.Close()  #Pritam
        return 1

    def createDataSets(self, dataset):
        """Get named dataset"""
        for name, cut in dataset:
            if self.cfg['preloadFile'] and os.path.exists(
                    self.cfg['preloadFile']):
                file_preload = ROOT.TFile(self.cfg['preloadFile'])
                data = file_preload.Get(name)
                datahist = file_preload.Get(name + '.hist')
                if not data == None:
                    self.dataset[name] = deepcopy(data)
                    if self.argset.find("Phimass"):
                        self.dataset[name + '.hist'] = deepcopy(datahist)
                file_preload.Close()
            self.createDataSet(name, cut)
        return self.dataset

    def _runPath(self):
        self.ch = TChain()
        print("Name: ", self.cfg['name'])
        for f in self.cfg['ifile']:
            self.ch.Add(f)
        if len(self.cfg['ifriend']) > 0:
            self.friend = TChain("tree")
            for f in self.cfg['ifriend']:
                self.friend.Add(f)
            self.friend.BuildIndex(*self.cfg['ifriendIndex'])
            self.ch.AddFriend(self.friend)
        self.createDataSets(self.cfg['dataset'])
        self.__str__()
        pass

    def _addSource(self):
        """Add dataset and arguments to source pool"""
        if self.cfg['preloadFile'] and not os.path.exists(
                self.cfg['preloadFile']):
            file_out = ROOT.TFile.Open(self.cfg['preloadFile'], 'RECREATE')
            for dname, d in self.dataset.items():
                d.Write()
            file_out.Close()
        elif os.path.exists(self.cfg['preloadFile']):
            file_out = ROOT.TFile(self.cfg['preloadFile'], 'UPDATE')
            for dname, d in self.dataset.items():
                if file_out.Get(dname) and self.process.cfg['args'].force:
                    file_out.Delete(dname +
                                    ';*')  # Delete old objects if exists
                    file_out.Delete(
                        'ProcessID*;*')  # Delete old Pids if exists
                    d.Write()
                elif not file_out.Get(dname):
                    print("Freshly booking an object")
                    d.Write()
            file_out.Close()

        if not 'source' in self.cfg.keys():
            self.cfg['source'] = {}
        #self.cfg['source']['{0}.tree'.format(self.name)] = self.ch
        self.cfg['source']['{0}.argset'.format(self.name)] = self.argset
        if len(self.cfg['ifriend']) > 0:
            self.cfg['source']['{0}.friend'.format(self.name)] = self.friend
        for dname, d in self.dataset.items():
            self.cfg['source'][dname] = d
            self.logger.logINFO("{0} events in {1}.".format(
                d.sumEntries(), dname))
        super(DataReader, self)._addSource()