Tutorial for TSelector

tree/treeplayer/inc/TTreeReader.h

@@ -57,7 +57,8 @@ class TTreeReader: public TObject {
 
    TTreeReader():
       fDirectory(0),
-      fEntryStatus(kEntryNoTree)
+      fEntryStatus(kEntryNoTree),
+      fDirector(0)
    {}
 
    TTreeReader(TTree* tree);
@@ -73,7 +74,8 @@ class TTreeReader: public TObject {
    Bool_t IsChain() const { return TestBit(kBitIsChain); }
 
    Bool_t SetNextEntry() { return SetEntry(GetCurrentEntry() + 1) == kEntryValid; }
-   EEntryStatus SetEntry(Long64_t entry);
+   EEntryStatus SetEntry(Long64_t entry) { return SetEntryBase(entry, kFALSE); }
+   EEntryStatus SetLocalEntry(Long64_t entry) { return SetEntryBase(entry, kTRUE); }
 
    EEntryStatus GetEntryStatus() const { return fEntryStatus; }
 
@@ -90,6 +92,8 @@ class TTreeReader: public TObject {
    void RegisterValueReader(ROOT::TTreeReaderValueBase* reader);
    void DeregisterValueReader(ROOT::TTreeReaderValueBase* reader);
 
+   EEntryStatus SetEntryBase(Long64_t entry, Bool_t local);
+
 private:
 
    enum EPropertyBits {

tree/treeplayer/inc/TTreeReaderValue.h

@@ -121,7 +121,11 @@ class TTreeReaderValue: public ROOT::TTreeReaderValueBase {
    TTreeReaderValue(TTreeReader& tr, const char* branchname):
       TTreeReaderValueBase(&tr, branchname, TDictionary::GetDictionary(typeid(T))) {}
 
-   T* Get() { 
+   T* Get() {
+      if (!fProxy){
+         Error("Get()", "Value reader not properly initialized, did you remember to call TTreeReader.Set(Next)Entry()?");
+         return 0;
+      }
       void *address = GetAddress(); // Needed to figure out if it's a pointer
       return fProxy->IsaPointer() ? *(T**)address : (T*)address; }
    T* operator->() { return Get(); }

tree/treeplayer/src/TBranchProxy.cxx

@@ -207,7 +207,7 @@ Bool_t ROOT::TBranchProxy::Setup()
 
       // This is not sufficient for following pointers
 
-   } else if (!fBranch || fCurrentTreeNumber != fDirector->GetTree()->GetTreeNumber()) {
+   } else if (!fBranch || fCurrentTreeNumber != fDirector->GetTree()->GetTreeNumber() || fLastTree != fDirector->GetTree()) {
 
       // This does not allow (yet) to precede the branch name with
       // its mother's name

tree/treeplayer/src/TTreeReader.cxx

@@ -85,6 +85,8 @@ void TTreeReader::Initialize()
 
 //______________________________________________________________________________
 Long64_t TTreeReader::GetCurrentEntry() const {
+   //Returns the index of the current entry being read
+
    if (!fDirector) return 0;
    Long64_t currentTreeEntry = fDirector->GetReadEntry();
    if (fTree->IsA() == TChain::Class() && currentTreeEntry >= 0) {
@@ -94,7 +96,7 @@ Long64_t TTreeReader::GetCurrentEntry() const {
 }
 
 //______________________________________________________________________________
-TTreeReader::EEntryStatus TTreeReader::SetEntry(Long64_t entry)
+TTreeReader::EEntryStatus TTreeReader::SetEntryBase(Long64_t entry, Bool_t local)
 {
    // Load an entry into the tree, return the status of the read.
    // For chains, entry is the global (i.e. not tree-local) entry number.
@@ -103,19 +105,27 @@ TTreeReader::EEntryStatus TTreeReader::SetEntry(Long64_t entry)
       fEntryStatus = kEntryNoTree;
       return fEntryStatus;
    }
-   Int_t treeNumInChain = fTree->GetTreeNumber();
 
    TTree* prevTree = fDirector->GetTree();
 
-   int loadResult = fTree->LoadTree(entry);
-   if (loadResult == -2) {
-      fEntryStatus = kEntryNotFound;
-      return fEntryStatus;
-   }
+   int loadResult;
+   if (!local){
+      Int_t treeNumInChain = fTree->GetTreeNumber();
 
-   Int_t currentTreeNumInChain = fTree->GetTreeNumber();
-   if (treeNumInChain != currentTreeNumInChain) {
-         fDirector->SetTree(fTree->GetTree());
+      loadResult = fTree->LoadTree(entry);
+
+      if (loadResult == -2) {
+         fEntryStatus = kEntryNotFound;
+         return fEntryStatus;
+      }
+
+      Int_t currentTreeNumInChain = fTree->GetTreeNumber();
+      if (treeNumInChain != currentTreeNumInChain) {
+            fDirector->SetTree(fTree->GetTree());
+      }
+   }
+   else {
+      loadResult = entry;
    }
    if (!prevTree || fDirector->GetReadEntry() == -1) {
       // Tell readers we now have a tree
@@ -150,6 +160,10 @@ void TTreeReader::SetTree(TTree* tree)
    if (!fDirector) {
       Initialize();
    }
+   else {
+      fDirector->SetTree(fTree);
+      fDirector->SetReadEntry(-1);
+   }
 }
 
 //______________________________________________________________________________

tree/treeplayer/src/TTreeReaderArray.cxx

@@ -166,7 +166,10 @@ namespace {
    // Reader interface for leaf list
    // SEE TTreeProxyGenerator.cxx:1319: '//We have a top level raw type'
    class TObjectArrayReader: public ROOT::TVirtualCollectionReader {
+   private:
+      Int_t basicTypeSize;
    public:
+      TObjectArrayReader() : basicTypeSize(-1) { }
       ~TObjectArrayReader() {}
       TVirtualCollectionProxy* GetCP(ROOT::TBranchProxy* proxy) {
          if (!proxy->Read()){
@@ -185,15 +188,26 @@ namespace {
       virtual void* At(ROOT::TBranchProxy* proxy, size_t idx) {
          if (!proxy->Read()) return 0;
 
+         Int_t objectSize;
          void *array = (void*)proxy->GetStart();
-         TClass *myClass = proxy->GetClass();
-         if (!myClass){
-            Error("At()", "Cannot get class info from branch proxy.");
-            return 0;
+
+         if (basicTypeSize == -1){
+            TClass *myClass = proxy->GetClass();
+            if (!myClass){
+               Error("At()", "Cannot get class info from branch proxy.");
+               return 0;
+            }
+            objectSize = myClass->GetClassSize();
+         }
+         else {
+            objectSize = basicTypeSize;
          }
-         Int_t objectSize = myClass->GetClassSize();
          return (void*)((Byte_t*)array + (objectSize * idx));
       }
+
+      void SetBasicTypeSize(Int_t size){
+         basicTypeSize = size;
+      }
    };
 
    class TArrayParameterSizeReader : public TObjectArrayReader {
@@ -525,16 +539,25 @@ void ROOT::TTreeReaderArrayBase::CreateProxy()
          }
       }
    } else if (branch->IsA() == TBranch::Class()) {
-      printf("TBranch\n"); // TODO: Remove (necessary because of gdb bug)
+      TLeaf *topLeaf = branch->GetLeaf(branch->GetName());
+      Int_t size = 0;
+      TLeaf *sizeLeaf = topLeaf->GetLeafCounter(size);
+      if (!sizeLeaf) {
+         fImpl = new TArrayFixedSizeReader(size);
+      }
+      else {
+         fImpl = new TArrayParameterSizeReader(fTreeReader, sizeLeaf->GetName());
+      }
+      ((TObjectArrayReader*)fImpl)->SetBasicTypeSize(((TDataType*)fDict)->Size());
    } else if (branch->IsA() == TBranchClones::Class()) {
-      printf("TBranchClones\n"); // TODO: Remove (necessary because of gdb bug)
+      Error("CreateProxy", "Support for branches of type TBranchClones not implemented");
    } else if (branch->IsA() == TBranchObject::Class()) {
-      printf("TBranchObject\n"); // TODO: Remove (necessary because of gdb bug)
+      Error("CreateProxy", "Support for branches of type TBranchObject not implemented");
    } else if (branch->IsA() == TBranchSTL::Class()) {
-      printf("TBranchSTL\n"); // TODO: Remove (necessary because of gdb bug)
+      Error("CreateProxy", "Support for branches of type TBranchSTL not implemented");
       fImpl = new TSTLReader();
    } else if (branch->IsA() == TBranchRef::Class()) {
-      printf("TBranchRef\n"); // TODO: Remove (necessary because of gdb bug)
+      Error("CreateProxy", "Support for branches of type TBranchRef not implemented");
    }
 }
 
@@ -702,6 +725,16 @@ const char* ROOT::TTreeReaderArrayBase::GetBranchContentDataType(TBranch* branch
       const char* dataTypeName = branch->GetClassName();
       if ((!dataTypeName || !dataTypeName[0])
           && branch->IsA() == TBranch::Class()) {
+         TLeaf *myLeaf = branch->GetLeaf(branch->GetName());
+         if (myLeaf){
+            TDictionary *myDataType = TDictionary::GetDictionary(myLeaf->GetTypeName());
+            if (myDataType->IsA() == TDataType::Class()){
+               dict = TDataType::GetDataType((EDataType)((TDataType*)myDataType)->GetType());
+               contentTypeName = myLeaf->GetTypeName();
+               return 0;
+            }
+         }
+
          // leaflist. Can't represent.
          Error("GetBranchContentDataType()", "The branch %s was created using a leaf list and cannot be represented as a C++ type. Please access one of its siblings using a TTreeReaderValueArray:", branch->GetName());
          TIter iLeaves(branch->GetListOfLeaves());

tree/treeplayer/src/TTreeReaderValue.cxx

@@ -70,6 +70,9 @@ ROOT::TTreeReaderValueBase::~TTreeReaderValueBase()
 //______________________________________________________________________________
 ROOT::TTreeReaderValueBase::EReadStatus
 ROOT::TTreeReaderValueBase::ProxyRead() {
+   // Try to read the value from the TBranchProxy, returns
+   // the status of the read.
+
    if (!fProxy) return kReadNothingYet;
    if (fProxy->Read()) {
       fReadStatus = kReadSuccess;
@@ -81,6 +84,8 @@ ROOT::TTreeReaderValueBase::ProxyRead() {
 
 //______________________________________________________________________________
 TLeaf* ROOT::TTreeReaderValueBase::GetLeaf() { 
+   // If we are reading a leaf, return the corresponding TLeaf.
+
    if (fLeafName.Length() > 0){
 
       Long64_t newChainOffset = fTreeReader->GetTree()->GetChainOffset();
@@ -119,6 +124,8 @@ TLeaf* ROOT::TTreeReaderValueBase::GetLeaf() {
 
 //______________________________________________________________________________
 void* ROOT::TTreeReaderValueBase::GetAddress() {
+   // Returns the memory address of the object being read.
+
    if (ProxyRead() != kReadSuccess) return 0;
 
    if (fLeafName.Length() > 0){
@@ -317,6 +324,16 @@ const char* ROOT::TTreeReaderValueBase::GetBranchDataType(TBranch* branch,
       const char* dataTypeName = branch->GetClassName();
       if ((!dataTypeName || !dataTypeName[0])
           && branch->IsA() == TBranch::Class()) {
+         TLeaf *myLeaf = branch->GetLeaf(branch->GetName());
+         if (myLeaf){
+            TDictionary *myDataType = TDictionary::GetDictionary(myLeaf->GetTypeName());
+            if (myDataType->IsA() == TDataType::Class()){
+               dict = TDataType::GetDataType((EDataType)((TDataType*)myDataType)->GetType());
+               return myLeaf->GetTypeName();
+            }
+         }
+
+
          // leaflist. Can't represent.
          Error("GetBranchDataType()", "The branch %s was created using a leaf list and cannot be represented as a C++ type. Please access one of its siblings using a TTreeReaderValueArray:", branch->GetName());
          TIter iLeaves(branch->GetListOfLeaves());