A++ » INC » AtlSelector

class AtlSelector: public TSelector


 Basic selector for analysis of ATLAS data

 Inherit from this class in order to write your own specific
 analysis selector. See the description of the AtlExampleAnalysis
 class for an example

 Main schema:

 The idea is to have different user analyses by means of inheritance:


                                  AtlSelector
                                       |
                                       |
          +-------------------+--------------------+--------------+
          |                   |                    |              |
          V                   V                    V              V
    UserAnalaysis_1      UserAnalysis_2      UserAnalysis_3      ...


 The selector is mainly used for filling histograms during event
 processing. In addition, it is possible to create and fill an
 output A++ tree (see SetOutputTree()). This option is being used
 for the conversion of D3PDs into A++ files, for instance. The
 output tree as well as the histograms are filled only in case the
 ProcessCut() member function returns kTRUE for the event in
 question. This function can be optionally given by the user (see
 the example above how to do this). The default is to accept every
 event.

 The general picture of the data-flow looks like the following:

  +-------------+
  |             |                                    +-----------------+
  | A++         +----+                         +---->| User Histograms |
  | .root files |    |                         |     +-----------------+
  +-------------+    |      +-------------+    |
                     +----->|             |    |     +-----------------+
        OR                  | AtlSelector +----+---->| Ctrl Histograms |
                     +----->|             |    |     +-----------------+
  +-------------+    |      +-------------+    |
  |             |    |                         |     +-----------------+
  | DPD Ntuples +----+                         +---->|    A++ Tree     |
  |             |                                    +-----------------+
  +-------------+


 Information about the processing status (no. of precessed events
 etc) is continuously printed to std output for non-batch jobs
 testet by gROOT->IsBatch()


 Processing and event selection:

 Flow-chart of user-defined functions

     +-------------------+
     | SetBranchStatus() |
     +--------+----------+
              |
              V
     +-------------------+
     | BookHistograms()  |
     +--------+----------+
              |               +------------------------------+
              V               |                              |
     +-------------------+    V   +------------------+ false |
     |    Event Loop     +--------+ ObjSelectionTool +------>|
     +--------+----------+        +---+--------------+       |
              |                       V                      |
              |                   +------------------+ false |
              |                   | ProcessPreCut()  +------>|
              |                   +---+--------------+       |
              |                       |                      |
              |                   +-----------------+  false |
              |                   |   ProcessCut()  +------->|
              |                   +---+-------------+        |
              |                       |                      |
              |                 true? |    +-----------------++
              |                       +----+ FillHistograms() |
              |                            +------------------+
              V
     +-------------------+
     |    Terminate()    |
     +-------------------+


 Analysis tools:

 There exist a couple of tools (decay finders, ctrl plots,
 b-tagging, trigger etc.) which can be plugged into the analysis at
 different positions. See the class AtlAnalysisTool for details.

 ObjSelection Tool:

 The AtlObjSelectionTool selects the analysis objects (leptons, jets, b-jets)
 and performs cuts. The cuts have to be set with the use of public datamembers.

 Lepton cuts available:
 Pt-cut: fElectron_Pt_min, fMuon_Pt_min

 Jet-Cut:
 Pt-cut:    fJetPt_min
 Eta-Range: fJetEta_min < |eta_jet| < fJetEta_max

 The number of jets in this list defines the Jet Multiplicity
 and the selector will remove any event that does not match the jet multiplicity
 provided via fJetMults.

 Selection cuts:

 Selection cuts are supposed to be stored in public data members of
 the derived classes (eg see Atl_tChannelAnalysis). The default
 values of these cuts are to be given in the virtual member function
 SetCutDefaults(). It is common to enclose an analysis selector
 inside an analysis task. The base class for this is the class
 AtlAppAnalysisTask which in turn is inherited to the various
 analyses. The actual cut values for an analysis should be given
 there via AtlAppAnalysis::SetCut().

 Entry lists:

 Events that passed the ProcessCut() can be stored in a TEntryList. Later on,
 this list can be used to select only these events in a tree or chain.
 The chain has to be the same as when creating the list.
 To enable writing the entry list, use sel->SetWriteEntryList(kTRUE) or
 set it in the task class.
 This list will be created in the output root file with the tree name
 "app_entrylist".
 To apply the list on a chain, you first have to load the list from
 the root file.
 TFile *f = new TFile("outputfile.root","read");
 TEntryList *elist = new TEntryList;
 elist = (TEntryList*)f->Get("app_entrylist");
 Then you can apply it on your chain:
 ch->SetEntryList(elist);
 Running your analysis now will only include the events stored in
 the list.

    Author: Oliver Maria Kind <mailto:kind@mail.desy.de>
    Update: $Id: AtlSelector.cxx,v 1.156 2017/07/13 14:22:05 kind Exp $
    Copyright: 2008 (C) Oliver Maria Kind

Function Members (Methods)

 
    This is an abstract class, constructors will not be documented.
    Look at the header to check for available constructors.

public:
virtual~AtlSelector()
virtual voidTSelector::Abort(const char* why, TSelector::EAbort what = kAbortProcess)
voidTObject::AbstractMethod(const char* method) const
voidAddTool(AtlAnalysisTool* tool)
virtual voidTObject::AppendPad(Option_t* option = "")
AtlSelector(const char* OutputFilename)
AtlSelector(const AtlSelector&)
virtual voidBegin(TTree* tree)
virtual voidBookHistograms()
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidClear(Option_t* otpion = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidFillHistograms()
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual TSelector::EAbortTSelector::GetAbort() const
TTree*GetCurrentTree() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual Int_tGetEntry(Long64_t entry = 0)
AtlEvent*GetEvent() const
virtual const char*TObject::GetIconName() const
virtual TList*TSelector::GetInputList() const
static const char*GetJetMultEnum(UInt_t jetmult)
static const char*GetJetMultLabel(AtlSelector::EJetMult jetmult)
static const char*GetJetMultLabel(Int_t i)
static const char*GetLeptonEnum(UInt_t lep)
static const char*GetLeptonLabel(AtlSelector::ELepChannel lep)
static const char*GetLeptonLabel(Int_t i)
TList*GetListOfTools() const
virtual const char*TObject::GetName() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual const char*TSelector::GetOption() const
TFile*GetOutputFile()
virtual TList*GetOutputList() const
Float_tGetPreTagEvtWeight() const
Int_tGetProcessedEvents() const
static TSelector*TSelector::GetSelector(const char* filename)
virtual Long64_tTSelector::GetStatus() const
Float_tGetTagEvtWeight() const
virtual const char*TObject::GetTitle() const
AtlAnalysisTool*GetTool(const char* ClassName, const char* ToolName = "", Bool_t force = kFALSE)
TTree*GetTree()
virtual UInt_tTObject::GetUniqueID() const
Bool_tGetWriteEntryList() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
Bool_tHasOutputTree() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidInit(TTree* tree = 0)
virtual voidInitEvent()
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
Bool_tIsFirstEvent() const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTObject::IsSortable() const
static Bool_tTSelector::IsStandardDraw(const char* selec)
Bool_tTObject::IsZombie() const
AtlTriggerConf*LoadTriggerConfig()
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tNotify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
voidTObject::operator delete(void* ptr)
voidTObject::operator delete(void* ptr, void* vp)
voidTObject::operator delete[](void* ptr)
voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
AtlSelector&operator=(const AtlSelector&)
virtual voidTObject::Paint(Option_t* option = "")
Bool_tPassedSelection() const
virtual voidTObject::Pop()
virtual voidPrint(Option_t* option = "") const
voidPrintSummary()
virtual Bool_tProcess(Long64_t entry)
virtual Bool_tProcessCut()
virtual voidProcessFill()
voidProcessInfo()
virtual Bool_tProcessPreCut()
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
virtual voidTSelector::ResetAbort()
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidSetBranches()
virtual voidSetBranchStatus()
virtual voidSetCutDefaults()
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetEvtReader(AtlEvtReaderBase* reader)
virtual voidSetInputList(TList* input)
voidSetInputMode(AtlSelector::EIOMode inputMode)
virtual voidSetObject(TObject* obj)
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidSetOption(const char* option)
voidSetOutputTree(const char* name, const char* title)
voidSetPassedSelection(Bool_t result)
voidSetPrintEvent(Bool_t PrintEvent)
voidSetPrintObjectTable(Bool_t PrintObjectTable)
virtual voidTSelector::SetStatus(Long64_t status)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidSetWriteEntryList(Bool_t WriteEntryList)
virtual voidShowMembers(TMemberInspector& insp) const
virtual voidSlaveBegin(TTree* tree)
virtual voidSlaveTerminate()
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
virtual voidTerminate()
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
virtual Int_tVersion() const
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
voidBookJobInfoHistograms()
voidChangeOutputFile()
voidDoBookkeeping(TFile* InputFile)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTObject::MakeZombie()
voidSetSumw2(TDirectory* dir)

Data Members

public:
Bool_tfDoTruthTreeRead and process TruthTree information. Caution: this is a very time-consuming operation (Run2 SgTop-D3PDs only; default=false)
static const Int_tfgNumJetMults
static const Int_tfgNumLepChannels
static AtlSelector::EJetMultk4To6Jets
static TSelector::EAbortTSelector::kAbortFile
static TSelector::EAbortTSelector::kAbortProcess
static AtlSelector::EJetMultkAllJets
static AtlSelector::EIOModekApp
static TObject::(anonymous)TObject::kBitMask
static TObject::EStatusBitsTObject::kCanDelete
static TObject::EStatusBitsTObject::kCannotPick
static TSelector::EAbortTSelector::kContinue
static AtlSelector::EIOModekCustom
static AtlSelector::EIOModekD3PDCKM
static AtlSelector::EIOModekD3PDSgTop
static AtlSelector::EIOModekD3PDSgTop_v2
static AtlSelector::ELepChannelkElectron
static AtlSelector::EJetMultkFiveJet
static AtlSelector::EJetMultkFourJet
static TObject::EStatusBitsTObject::kHasUUID
static TObject::EStatusBitsTObject::kInvalidObject
static TObject::(anonymous)TObject::kIsOnHeap
static TObject::EStatusBitsTObject::kIsReferenced
static AtlSelector::ELepChannelkLepton
static AtlSelector::EIOModekMemNtuple
static AtlSelector::ELepChannelkMuon
static TObject::EStatusBitsTObject::kMustCleanup
static TObject::EStatusBitsTObject::kNoContextMenu
static TObject::(anonymous)TObject::kNotDeleted
static TObject::EStatusBitsTObject::kObjInCanvas
static AtlSelector::EJetMultkOneJet
static AtlSelector::EJetMultkOneOrMoreJets
static TObject::(anonymous)TObject::kOverwrite
static TObject::(anonymous)TObject::kSingleKey
static AtlSelector::EJetMultkSixJet
static AtlSelector::EJetMultkThreeJet
static AtlSelector::EJetMultkThreeOrMoreJets
static AtlSelector::EJetMultkTwoJet
static AtlSelector::EJetMultkTwoOrMoreJets
static TObject::(anonymous)TObject::kWriteDelete
static TObject::(anonymous)TObject::kZombie
protected:
TSelector::EAbortTSelector::fAbortAbort status
Int_tfAcceptedEventsNo. of accepted events (w/o weights) selected by ProcessCut()
Float_tfAcceptedEventsBNo. of accepted events (weighted) selected by ProcessCut()
Float_tfAcceptedEventsWNo. of accepted events (weighted) selected by ProcessCut()
TObjArray*fBookkeepingListList of chain elements needed for bookkeeping
Bool_tfCountUnfilteredEventsCount the no. of all unfiltered events (in case the input A++ file does not contain a JobInfo histogram)
TTree*fCurrentTreeCurrently analysed tree
Long64_tfEntryGlobal entry number of the current event in input chain
TEntryList*fEntryListGlobal entry list for all files in a chain
AtlEvent*fEventPoint to event object in memory
AtlEvtReaderBase*fEvtReaderReader for input events
AtlEvtReaderBase*fEvtReaderUserUser-provided reader for input events (owned!)
AtlEvtWriterBase*fEvtWriterWriter for output event
TH1D*fHistCutflow_NoWeightsSgTopD3PD CutFlow Histogram
TH1D*fHistCutflow_allEventsHFOR_NoWeightsSgTopD3PD CutFlow Histogram
TH1D*fHistCutflow_allEventsHFOR_genWeightsSgTopD3PD CutFlow Histogram
TH1D*fHistCutflow_genWeightsSgTopD3PD CutFlow Histogram
TH1D*fHistCutflow_genXpileupWeightsSgTopD3PD CutFlow Histogram
TH1D*fHistCutflow_genXpileupXzvertexWeightsSgTopD3PD CutFlow Histogram
TH1F*fHistEventsHistogram for no. of processed and accepted events etc.
TH1F*fHistEvtWeightsHistogram of event weights
TList*TSelector::fInputList of objects available during processing
AtlSelector::EIOModefInputModeDefines input file mode
Bool_tfIsChainInput is chain or tree ?
Int_tfJetBinEventsNo. of events in jet bin (w/o weights)
Float_tfJetBinEventsWNo. of events in jet bin (weighted)
TList*fListOfToolsList of analysis tools
MemInfo_t*fMemInfoCurrent memory usage information
Int_tfNBookkeepingNo. of bookkeeping files
TObject*TSelector::fObject! Current object if processing object (vs. TTree)
TStringTSelector::fOptionOption given to TTree::Process
TSelectorList*TSelector::fOutput! List of objects created during processing
TFile*fOutputFileOutput file
TString*fOutputFilenameName of the output file
AtlSelector::EIOModefOutputModeDefines mode for the output tree (if any)
TTree*fOutputTreeA++ output tree (if any)
TString*fOutputTreeNameName of the A++ output tree (if any)
TString*fOutputTreeTitleTitle of the A++ output tree (if any)
TTree*fOutputTriggerConfTreeNeeded for copying the trigger config dbases into the output file in case of written out A++ events
Bool_tfPassedSelectionvariable for storing the selection decisions for the event
Int_tfPreAcceptedEventsNo. of pre-accepted events (w/o weights) selected by ProcessPreCut()
Float_tfPreAcceptedEventsWNo. of pre-accepted events (weighted) selected by ProcessPreCut()
Float_tfPreTaggedEventsNo. of events before b-tagging
Float_tfPreTaggedEventsWNo. of events before b-tagging (weighted)
Bool_tfPrintEventPrint the content of every event (useful for testing/debugging)
Bool_tfPrintObjectTablePrint Root's object table for every event (useful for tracking memory leaks)
ProcInfo_t*fProcInfoCurrent process information
Int_tfProcessedEventsNo. of processed events (w/o weights)
Float_tfProcessedEventsWNo. of processed events (weighted)
Long64_tTSelector::fStatusSelector status
TStopwatchfStopwatchStopwatch used for process monitoring
TTree*fTreePointer to the currently analysed tree or chain
Bool_tfWriteEntryListSwitch for writing an entry list

Class Charts

Inheritance Chart:
TObject
TSelector
AtlSelector
AtlExampleAnalysis
AtlMemNtupleProduction
AtlSgTopEntryListWriter
AtlSgTopFCNC_tZ_Base
AtlSgTopFCNC_tZ_Base3L
AtlSgTopFCNC_tZ_CtrlSM
AtlSgTopFCNC_tZ_CtrlTtbar
AtlSgTopFCNC_tZ_CtrlWZ3L
AtlSgTopFCNC_tZ_CtrlZjets3L
AtlSgTopFCNC_tZ_Multi
 [more...]

Function documentation

AtlSelector(const char* OutputFilename)
 Default constructor

~AtlSelector()
 Default destructor

void SetOutputTree(const char* name, const char* title)
 Set output tree/ntuple

 If the name of the output tree is set it is automatically being
 filled with all events passing the ProcessCut() method.

 The trigger configuration dbase of the used runs is also copied
 from the input files.

 If the size of the output tree exceeds the maximum tree size
 (see TTree::SetMaxTreeSize()) of (currently) 2Gb, Root splits
 the output file automatically. Iin contrast to Root's internal
 mechanism, which writes all histograms to the last of the
 splitted files only, the AtlSelector class splits also the
 histograms and writes them to their corresponding output files
 (see ChangeOutputFile()). The same holds for the trigger
 configuration dbase.

void SetBranches()
 Set branch assignments of the input tree. Here an A++ input
 tree is assumed. For other trees this (virtual) method has to
 be overloaded. See also the GetEntry() method

Int_t GetEntry(Long64_t entry = 0)
 Get entry from current input tree. This (virtual) method can be
 overloaded if needed (different type of input tree)

void Init(TTree* tree = 0)
 The Init() function is called when the selector needs to initialize
 a new tree or chain. Typically here the branch addresses and branch
 pointers of the tree will be set.
 It is normally not necessary to make changes to the generated
 code, but the routine can be extended by the user if needed.
 Init() will be called many times when running on PROOF
 (once per file to be processed).

Bool_t Notify()
 The Notify() function is called when a new file is opened. This
 can be either for a new TTree in a TChain or when a new TTree
 is started when using PROOF.

 Load the configurations (trigger etc.) from the
 newly opened file. In case of writing an event list make sure a
 new one is appended for the current tree.

 At the end of this function, the Notify() functions of the
 current event reader and all active tools are called.

void DoBookkeeping(TFile* InputFile)
 Perform bookkeeping of the cut-flow and job info histograms.
 This is done for every input file.

void Begin(TTree* tree)
 The Begin() function is called at the start of the query.
 When running with PROOF Begin() is only called on the client.
 The tree argument is deprecated (on PROOF 0 is passed).

void SlaveBegin(TTree* tree)
 The SlaveBegin() function is called after the Begin() function.
 When running with PROOF SlaveBegin() is called on each slave server.
 The tree argument is deprecated (on PROOF 0 is passed).

 Function called before starting the event loop
  -it performs some cleanup
  -it creates histograms
  -it sets some initialisation for the event list

Bool_t Process(Long64_t entry)
 The Process() function is called for each entry in the tree (or possibly
 keyed object in the case of PROOF) to be processed. The entry argument
 specifies which entry in the currently loaded tree is to be processed.
 It can be passed to either AtlSelector::GetEntry() or
 TBranch::GetEntry() to read either all or the required parts of
 the data. When processing keyed objects with PROOF, the object
 is already loaded and is available via the fObject pointer.

 This function should contain the "body" of the analysis. It can contain
 simple or elaborate selection criteria, run algorithms on the data
 of the event and typically fill histograms.

 The processing can be stopped by calling Abort().

 Use fStatus to set the return value of TTree::Process().

 The return value is currently not used.

void SlaveTerminate()
 The SlaveTerminate() function is called after all entries or objects
 have been processed. When running with PROOF SlaveTerminate() is called
 on each slave server.

void Terminate()
 The Terminate() function is the last function to be called during
 a query. It always runs on the client, it can be used to present
 the results graphically or save the results to file.
void ProcessFill()
 Event fill routine (histograms etc)

void SetCutDefaults()
 Set Default Values for public member variables.
 When implementing this virtual method in a derived
 Selector class, make sure to call this base method
 as well.
 SetCutDefaults should be called in the ctor of the
 derived class.

 void DerivedSelector::SetCutDefaults(){
   AtlSelector::SetCutDefaults(); // calls base portion
   fFoo = bar; // set default value of fFoo to bar

 }
void ProcessInfo()
 Print information about the current process.  For interactive
 (ie non-batch) jobs continuous output is given while for batch
 jobs only a few out is given to avoid too much junk in the log
 file

void PrintSummary()
 Print summary at end of job

void AddTool(AtlAnalysisTool* tool)
 Add analysis tool to list of tools

AtlAnalysisTool* GetTool(const char* ClassName, const char* ToolName = "", Bool_t force = kFALSE)
 Retrieves Tool from fListOfTools
 If parameter force is true, the method will abort if no tool with
 the description is found
 otherwise it won't bother and simply return 0

AtlTriggerConf* LoadTriggerConfig()
 Load trigger configuration

void BookJobInfoHistograms()
 Book histograms containing information about the analysis job
 like the no. of processed events, the event weights etc.

 The binning for the nevt histogram is as follows:
 Bin  1 : All unfiltered events (unweighted)
 Bin  2 : All unfiltered events (MC weight only)
 Bin  3 : All unfiltered events (all weights)
 Bin  4 : Processed events (unweighted)
 Bin  5 : Processed events (MC weight only)
 Bin  6 : Processed events (all weights)
 Bin  7 : Pre-accepted events by ProcessPreCut() (unweighted)
 Bin  8 : Pre-accepted events by ProcessPreCut() (MC weights only)
 Bin  9 : Pre-accepted events by ProcessPreCut() (all weights)
 Bin 10 : Accepted events by ProcessCut() (unweighted)
 Bin 11 : Accepted events by ProcessCut() (MC weight only)
 Bin 12 : Accepted events by ProcessCut() (all weights)

void ChangeOutputFile()
 This method is used to prevent Root from wrinting all
 histograms only to the last file in case of splited output
 files (see TTree::ChangeFile()). Instead the histograms are
 splitted as well and written to their corresponding output
 file.

const char* GetJetMultLabel(EJetMult jetmult)
 Get Jet Multiplicity label

const char* GetJetMultLabel(Int_t i)
 Returns Jet Multiplicity label ('1', '2', ...)

const char* GetLeptonLabel(ELepChannel lep)
 Get Lepton Label

 Works only for single-leptons

const char* GetLeptonLabel(Int_t i)
 Returns Lepton Channel Label

void Clear(Option_t* otpion = "")
 Clear AtlSelector

 User has to call this function in derived selector

const char* GetJetMultEnum(UInt_t jetmult)
 Get Jet Multiplicity Enum ('kOneJet', 'kTwoJet', ...)

const char* GetLeptonEnum(UInt_t lep)
 Get Lepton Channel Enum ('kElectron', 'kMuon', ...)

void Print(Option_t* option = "") const
 Print configuration of base selector.
 (this function is supposed to be used from inside the user
 analysis Print()

void SetEvtReader(AtlEvtReaderBase* reader)
 Explcitly sets the event reader.
 Ownership of the reader is transferred to AtlSelector!

void SetInputMode(AtlSelector::EIOMode inputMode)
 Sets the input mode.
 Deprecated, please use SetEvtReader() if possible.

AtlSelector(const char* OutputFilename)
Int_t Version() const
{ return 2; }
void SetOption(const char* option)
{ fOption = option; }
void SetObject(TObject* obj)
{ fObject = obj; }
void SetInputList(TList* input)
{ fInput = input; }
TList* GetOutputList() const
{ return fOutput; }
void SetBranchStatus()
void InitEvent()
{;}
void BookHistograms()
void FillHistograms()
TTree* GetTree()
{ return fTree; }
TTree* GetCurrentTree() const
{ return fCurrentTree; }
AtlEvent* GetEvent() const
{ return fEvent; }
Float_t GetPreTagEvtWeight() const
{ return fEvent->GetPreTagEvtWeight(); }
Float_t GetTagEvtWeight() const
{ return fEvent->GetTagEvtWeight(); }
TFile* GetOutputFile()
{ return fOutputFile; }
Bool_t ProcessCut()
{ return kTRUE; }
Bool_t ProcessPreCut()
{ return kTRUE; }
Bool_t GetWriteEntryList() const
{ return fWriteEntryList; }
Bool_t PassedSelection() const
{ return fPassedSelection; }
void SetWriteEntryList(Bool_t WriteEntryList)
{ fWriteEntryList = WriteEntryList; }
TList* GetListOfTools() const
{ return fListOfTools; }
Int_t GetProcessedEvents() const
{ return fProcessedEvents; }
Bool_t HasOutputTree() const
 Is there an A++ tree written to the output .root file ?

Bool_t IsFirstEvent() const
{ return fProcessedEvents == 0; }
void SetPrintEvent(Bool_t PrintEvent)
 Switch for printing every event
 (useful for testing/debugging)

void SetPrintObjectTable(Bool_t PrintObjectTable)
 Switch for printing the Root's object table
 (useful for tracking memory leaks)
void SetPassedSelection(Bool_t result)
{ fPassedSelection = result; }
void SetSumw2(TDirectory* dir)