PerInputStream.cxx

Go to the documentation of this file.

//
// PerInputStream
//
// Package: Per (Persistency).
//
// S. Kasahara 04/2001
//
// Purpose: Class for managing an individual input data stream.
//          The user should use the PerInputStreamManager to open and
//          close PerInputStreams.
//

#include <algorithm>

#include "TKey.h"
#include "TTree.h"
#include "TFile.h"
#include "TROOT.h"
#include "TTreeFormula.h"
#include "TBranchElement.h"
#include "TRandom.h"
#include "TFileCacheRead.h"

#include "Persistency/Per.h"
#include "Persistency/PerFile.h"
#include "Persistency/PerFileManager.h"
#include "Persistency/PerInputStream.h"
#include "Conventions/Munits.h"
#include "MessageService/MsgService.h"
#include "MessageService/MsgFormat.h"
#include "Record/RecMinos.h"
#include "Record/RecMinosHdr.h"
#include "Record/RecRecord.h"

std::ostream& operator<<(std::ostream& ms, const PerInputStream& pis) 
                                            { return pis.Print(ms); }

ClassImp(PerInputStream)

//   Definition of static data members
//   *********************************

CVSID("$Id: PerInputStream.cxx,v 1.65 2009/04/29 23:55:53 arms Exp $");


// Definition of methods (alphabetical order)
// ***************************************************


int PerInputStream::AddFile(std::string fullfilepathname, int at) {
  //
  //  Purpose:  Add file to stream file list at position at.
  //
  //  Arguments: fullfilepathname
  //                          at = position in file list (-1 => end of list)
  //             
  //  Return: 1 if successful, 0 if not. For now its always 1, but
  //          may add some error checking later.
  //
  //  Contact:   S. Kasahara
  //  Adapted from M. Messier's IoInputModule::AddFile.

  std::string curf;
  if ( !fIsBOF && fFileList.size() > 0 ) curf = *fFileItr;

  if ( at < 0 ) { 
    fFileList.push_back(fullfilepathname);
  }
  else if ( at == 0 ) {
    fFileList.push_front(fullfilepathname);
  }
  else {
    std::list<std::string>::iterator itr(fFileList.begin());
    std::list<std::string>::iterator itrEnd(fFileList.end());
    for ( int i = 0; (i < at && itr != itrEnd); ++i, ++itr ) continue;
    fFileList.insert(itr,fullfilepathname);
  }

  // insert may have changed file pointed to by fFileItr
  if ( fIsBOF || fFileList.size() == 1 ) {
    fIsBOF = true; // NextFile will move to first file
  }
  else {
    // Find original file in new list
    fFileItr = std::find(fFileList.begin(),fFileList.end(),curf);
    fIsBOF = false;
  } 

  return 1;

}

bool PerInputStream::AdvanceTagsList() {
  //
  //  Purpose:  Advance fTagsList to include next block of records with
  //            common VldContext.
  //
  //  Arguments: none
  //             
  //  Return: true if successful. New record block is stored in fTagsList
  //          PerRecordTags object.
  //
  //  Contact:   S. Kasahara
  // 

  if ( !fTFile ) return 0; // require opened file, but not tree 

  // Find entry corresponding to last data block in tags list.
  TagsListItr itr = fTagsList.end();
  if ( itr != fTagsList.begin() ) itr--;
  Int_t lastIndex = -1;
  VldContext oldVld = Per::GetVldBegin();
  if ( itr != fTagsList.end() ) {
    // the & is critical here to modify *itr contents
    PerRecordTags& oldTags = *itr; 
    if ( oldTags.IsEnd() ) {
      if ( !oldTags.IsComplete() ) {
        oldTags.SetIndexHi(oldTags.GetIndexLo());
        return 1;
      }
      else {
        return 0;
      }
    }
    lastIndex = TMath::Max(oldTags.GetIndexLo(),oldTags.GetIndexHi());
    oldVld = oldTags.GetVldContext();
  }

  // Advance in tree if we have not reached the end
  VldContext newVld = oldVld;
  while ( newVld == oldVld && ++lastIndex <= this->GetNumEntries() ) {
    if ( lastIndex == this->GetNumEntries() && fUpdateMode ) {
      this -> UpdateTree();
    }
    if ( lastIndex < this->GetNumEntries() ) {
      newVld = this -> GetVldContext(lastIndex);
    }
    else {
      // no new entries and update tree has been tried
      if ( !fUpdateMode || IsFileEnd() ) {
        // file is closed by writer or update mode not requested
        newVld = Per::GetVldEnd();  // indicate end of input stream
      }
      else return 0;  // file is open and reading in updatemode
    }
  }


  // Successfully advanced to next Vld block in tree
  // Complete previous Vld block if it exists
  if ( itr != fTagsList.end() ) (*itr).SetIndexHi(lastIndex-1);
  // Start new TagsList entry but indicate its incompleteness
  // by setting indexHi = -2 
  PerRecordTags recordtags("",fTreeName,fFullFilePathName,lastIndex,
                           -2,newVld);
  fTagsList.push_back(recordtags);
  
  this -> CleanTagsList(true);

  return  1;

}


void PerInputStream::CleanTagsList(bool isForward) {
  //
  //  Purpose:  Keep record tags cache to reasonable size as defined by 
  //            fMaxListSize.
  //
  //  Arguments: true means low index records are popped off the list.
  //             false means high index records are popped off the list.
  //             
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  // 

  if ( isForward ) {
    while ( fTagsList.size() > fMaxListSize ) fTagsList.pop_front();
  }
  else {
    while ( fTagsList.size() > fMaxListSize ) fTagsList.pop_back();
  }

  return;

}

void PerInputStream::Close() {
  //
  //  Purpose:  Close the input stream.
  //
  //  Arguments: none.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  // 

  CloseFile();

}

void PerInputStream::CloseFile() {
  //
  //  Purpose:  Close the file attached to the input stream.
  //
  //  Arguments: none.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  // 

  this -> DisableFile(); // disable file but don't actually close it
  PerStream::CloseFile();  // now close it

}

void PerInputStream::DisableFile() {
  //
  //  Purpose:  Disable the file attached to the input stream but don't
  //            actually close it 
  //
  //  Arguments: none.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  // 

  fTagsList.clear();
  fTagsItr = fTagsList.end();
  fFileEnd = true; 
  fTreeCycle = -1;
  if (fTTreeFormula) delete fTTreeFormula; fTTreeFormula = 0;
  fFileEnabled = false;

}

TObject* PerInputStream::GetObject(Int_t entry,bool useselection) {
  //
  //  Purpose:  Retrieve object from current TTree corresponding to given
  //            entry number.  Entries are subject to the selection
  //            cut specified by the user via the
  //            PerInputStream::SetSelection method.  If the entry
  //            fails to pass the selection cut, a null pointer is
  //            returned.
  //
  //  Arguments: entry   Int_t requested entry by number in current TTree.
  //             useselection bool apply selection cuts specified through
  //                               PerInputStream::SetSelection.  If false
  //                               selection cuts will be ignored
  //                               (default = true). 
  //
  //  Return:  pointer to TObject if successful, else (TObject*)0.
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes:  The TObject returned to the user is owned by the user, i.e.
  //          the user has the responsibility of deleting the allocated
  //          memory of this object.
  //          Use IsBegin() or IsEnd() to determine 
  //          if entry range limits of current tree have been reached.

  Reset(true);  // reset contents of object cache

  if ( !IsOpen() ) {
    return (TObject*)0;
  }

  fEntry = entry;  // requested entry becomes current entry

  if ( IsEnd() && fUpdateMode && !IsFileEnd() ) {
    // Attempt to update tree if writer has not yet closed file
    // and user has requested update mode
    UpdateTree();
  }

  if ( IsBegin() || IsEnd() ) {
    // requested entry number exceeds range of stream
    return (TObject*)0;
  }

  // Create new object of class stored in this tree  
  // fTObject = (TObject*)fTClass -> New();
  if ( !fTObject ) {
    fTBranch -> SetAddress(&fTObject); // and set branch address
    if ( fNewTree && fTObject ) {
      fNewTree = false;
      if ( !IsPerOwnedDisabled() ) {
        RecRecord* recrecord = dynamic_cast<RecRecord*>(fTObject);
        if ( recrecord && recrecord->IsClearable()) {
          recrecord->SetPerOwned(true);
          SetPerOwned(true);
        }
      }
    }
  }
  
  if ( !useselection || IsSelected() ) {
    // entry is retrieved and loaded into fTObject
    if (fFileCacheRead) fTTree->GetCurrentFile()->SetCacheRead(fFileCacheRead);
    Int_t nbytes = fTTree->GetEntry(fEntry);
    if (fFileCacheRead) fTTree->GetCurrentFile()->SetCacheRead(0);
    
    if ( nbytes <= 0 ) {
      // An error occured in retrieval of object
      MSG("Per",Msg::kError) << "An error occurred while retrieving\n"
        << "entry " << fEntry << " from tree " << this->GetTreeName() 
        << " in file\n" << this -> GetFullFilePathName() << "." << endl;
      this -> Reset(true);
      if ( GetTestMode() ) return 0;
      else {
        MSG("Per",Msg::kFatal) << "Aborting job due to read of corrupt record."
                               << endl;
        abort();
      }
    }
    // A little too Verbose
    //MSG("Per",Msg::kVerbose) 
    //  << "GetObject retrieved object with " << nbytes << " bytes from tree "
    // << fTreeName << " entry " << fEntry << "." << endl;
  }  
  else {
    this -> Reset(true);
  }

  TObject* objptr = fTObject;
  this -> Reset(); // soft reset of fTObject ptr, must do this now 
  
  return objptr; // caller now owns object 

}


VldContext PerInputStream::GetVldContext(Int_t index) {
  //
  //  Purpose:  Retrieve VldContext of entry for specified tree index.
  //
  //  Arguments: tree index
  //
  //  Return:  VldContext if successful, else Per::GetVldEnd()
  //
  //  Contact:   S. Kasahara
  //
  //  Notes:  Retrieves object from header branch of tree only.
  //

  if ( !IsOpen() ) return Per::GetVldEnd();

  // Otherwise try to find the entry on the tree
  if ( index >= this -> GetNumEntries() || index < 0 ) {
    return Per::GetVldEnd();
  }
  
  bool isOwnedAtEntry = false;
  if ( IsPerOwned() ) isOwnedAtEntry = true;
  
  fTTree -> SetBranchStatus("*",false);
  fTTree -> SetBranchStatus(fTBranch->GetName(),true);
  fTTree -> SetBranchStatus("fHeader*",true);
  
  Int_t saveEntry = fEntry;
  VldContext indexVld = Per::GetVldEnd();
  TObject* object = this -> GetObject(index,false);
  if ( !object ) {
    MSG("Per",Msg::kWarning) << " No object retrieved from\n"
                             << "tree " << this->GetTreeName() << " index "
                             << index << "." << endl;
  }
  else {
    if ( RecMinos* record = dynamic_cast<RecMinos*>(object) ) {
      const RecMinosHdr* header = record -> GetHeader();
      if ( header ) indexVld = header->GetVldContext();
    }
    else if ( RecRecord* record = dynamic_cast<RecRecord*>(object) ) {
      indexVld = (record->GetHeader()).GetVldContext();
    }
    else {
      MSG("Per",Msg::kWarning) << " No VldContext retrieved from\n"
                               << "tree " << this->GetTreeName() << " index "
                               << index << "." << endl;
    }

    // object is owned by this method
    if ( !IsPerOwned() ) {
      delete object; object = 0;
    }
  }
   
  // turn all branches back on
  fTTree -> SetBranchStatus("*",true);
  if ( IsPerOwned() && !isOwnedAtEntry ) {
    if ( fTObject && fTBranch ) fTBranch->SetAddress(&fTObject); 
  }
  
  fEntry = saveEntry;

  return indexVld;

}

const PerRecordTags& PerInputStream::GetTags() {
  //
  //  Purpose:  Return tags containing location of current block of sequential
  //            records of common VldContext.
  //
  //  Arguments: none.
  //             
  //  Return:  PerRecordTags of current set of tags in list.  The 
  //           current position in map is maintained by fTagsItr.
  //           If record tags list is empty but the stream IsOpen(), the 
  //           begin-of-stream PerRecordTags 
  //           is returned.  If the record tags list is not empty, but the 
  //           iterator points to the end of this list,
  //           the end-of-stream PerRecordTags is returned.  Use
  //           PerRecordTags::IsBegin and PerRecordTags::IsEnd to test
  //           for these conditions.
  //
  //  Contact:   S. Kasahara
  // 

  if ( fTagsItr != fTagsList.end() ) {
    return *fTagsItr;
  }

  if ( fTagsList.empty() && this -> IsOpen() ) {
    return fTagsBegin;
  }

  return fTagsEnd;

}

VldContext PerInputStream::GetNextFileVldFromMap() const {
  // Purpose: Retrieve next file vldcontext from fFileVldContextMap
  //          if available.  VldContext is that of the first entry of
  //          the tree stored in the next file.  If not available,
  //          return invalid VldContext.  If no new files in list,
  //          return Per::GetVldEnd().

  VldContext invalidvld;
  
  if ( fFileList.empty() || fFileItr == fFileList.end() 
                         || fIsBOF ) return invalidvld;

  std::list<std::string>::const_iterator fileitr = fFileItr;
  fileitr++;
    
  if ( fileitr == fFileList.end() ) return Per::GetVldEnd();
  std::string fullfilepathname = *fileitr;

  std::map<std::string,VldContext>::const_iterator fv_itr;
  fv_itr = fFileVldContextMap.find(fullfilepathname);
  if (fv_itr == fFileVldContextMap.end()) return invalidvld;

  return fv_itr->second;
  
}
  
int PerInputStream::AdvanceLowerBoundTags(const VldContext& keyVld) {
  //  Purpose:  Advance record tags in Per::kLowerBound streams to
  //            be equal to or less than the keyVld given in the argument.
  //
  //  Argument: none.
  //
  //  Return:  1 if successful, else 0 (=> waiting for new records on streams 
  //           when reading in update mode).   
  //
  //  Contact:   S. Kasahara
  //
  //  Notes: To return successful when in update mode requires that the
  //         method is able to see at least one record set with validity
  //         equal to or greater than the specified input validity, or that
  //         the method can see that the open file has been closed by
  //         the writer.
  //

  PerRecordTags tags = this -> GetTags();
  // Advance until equal to or greater than specified keyVld
  bool isdone = false;
  while ( (tags.IsBegin() || (tags.GetVldContext() < keyVld)
                          || (tags.IsEnd() && !this->IsEndOfFiles()))
                          && !isdone ) {
    tags = this -> NextTags();
    if ( tags.IsEnd() ) {
      if ( fUpdateMode && !this->IsFileEnd() ) return 0; // failure
      else {
        VldContext nextfilevld = GetNextFileVldFromMap();
        if ( nextfilevld != Per::GetVldEnd() && ( !nextfilevld.IsValid() 
                                             || nextfilevld <= keyVld ) ) {
          if ( this->NextFile() ) tags = this -> NextTags();
        }
        else isdone = true;
      }
    }
  }

  // Rewind until one set less or equal to specified input keyVld
  while ( tags.IsEnd() || tags.GetVldContext() > keyVld ) {
    // Rewind one set
    tags = this->PrevTags();
    if ( tags.IsBegin() ) {
      if ( this -> PrevFile() ) tags = this -> PrevTags();
    }
  }

  return 1;

}

static VldTimeStamp make_delta(double t) {
    t /= Munits::s;
    time_t sec = (int)(t);
    int nsec = (int)(1.0e9*(t-sec));
    return VldTimeStamp(sec,nsec);
}

int PerInputStream::AdvanceWindowTags(const VldContext& keyVld) {
  //
  // Purpose: Advance window tags around keyVld in lower/upper window
  //          specified by user.  Records are loaded in fWindowTags
  //          and may be retrieved with GetWindowTags().
  //
  // Return: 1 if successful, else 0 ( => waiting for new records on
  //         streams when reading in update mode).  Success will be
  //         returned even if no records in the window are found.
  //
  // Contacts: B. Viren and S. Kasahara
  //
  // Notes:  To return successful when in update mode requires that the
  //         method is able to see at least one record set with validity
  //         equal to or greater than the specified input validity (+ upper
  //         window), or that the method can see that the open file has
  //         been closed by the writer

  fWindowTags.clear();
  if ( keyVld == Per::GetVldEnd() || keyVld == Per::GetVldBegin() ) return 0;

  // Make vldcontext for latter side of window
  VldTimeStamp top_vt = keyVld.GetTimeStamp();
  top_vt.Add(make_delta(fWindowUpper));
  VldContext topVld(keyVld.GetDetector(),keyVld.GetSimFlag(),top_vt);
  
  PerRecordTags tags = this -> GetTags();
  // Advance until equal to or just greater than specified window
  while ( tags.IsBegin() || ( tags.GetVldContext() < topVld )
                         || ( tags.IsEnd() && !IsEndOfFiles()) ) {
    tags = this -> NextTags();
    if ( tags.IsEnd() ) {
      if ( fUpdateMode && !this -> IsFileEnd() ) return 0; // failure
      else if ( this -> NextFile() ) tags = this -> NextTags();
    }
  }

  // Rewind until one set less or equal to top window edge
  while (  tags.IsEnd() || tags.GetVldContext() > topVld ) {
    tags = this -> PrevTags();
    if ( tags.IsBegin() ) {
      if ( this -> PrevFile() ) {
        tags = this -> PrevTags();
      }
    }
  }
  
  // success, but no tags in window found
  if ( tags.IsBegin() || tags.IsEnd() ) return 1; 
  
  // At this point we have aligned upper tag with upper end of window
  // Move through tags in reverse to find lower limit, but do not
  // cross file boundary.  Current limitation is that all tags in
  // window must be from the same file. 
  VldTimeStamp bot_vt = keyVld.GetTimeStamp();
  bot_vt.Add(make_delta(fWindowLower));
  VldContext botVld(keyVld.GetDetector(),keyVld.GetSimFlag(),bot_vt);

  while ( tags.GetVldContext() > botVld ) {
    fWindowTags.push_back(tags);
    tags = this -> PrevTags();
  }

  return 1;
   
}

int PerInputStream::AdvanceTags() {
  //
  // Purpose: Advance tags according to input order
  //
  // Return: 1 if successful, else 0 ( => waiting for new records on
  //         streams when reading in update mode).
  //
  // Contact: K. Arms
  //
  // Notes:  To return successful when in update mode requires that the
  //         method can see the open file and isn't at the end
  //

  PerRecordTags tags = this -> GetTags();
  /*
  bool inWhile = false;

  while ( tags.IsBegin()                      ||
          ( tags.IsEnd() && !IsEndOfFiles() )  ) {
    inWhile = true;
    //tags = this -> NextTags();
    if ( tags.IsEnd() ) {
      if ( fUpdateMode && !this -> IsFileEnd() ) return 0; // failure
      else if ( this -> NextFile() ) tags = this -> NextTags();
    }
  }

  if (!inWhile) 
  */
  if ( tags.IsEnd() && !IsEndOfFiles() ) {
    if ( fUpdateMode && !this -> IsFileEnd() ) return 0; // failure
    else if ( this -> NextFile() ) tags = this -> NextTags();
  }
  else
    tags = this -> NextTags();

  fSumTags++;

  if ( tags.IsEnd() && IsEndOfFiles() ) return 0;

  return 1;

}

int PerInputStream::GoToFile(int n) {
  //
  // Purpose: Move the stream to the nth file in the list
  //
  // Arguments: file number (0 is first)
  //
  // Return: 1 if successful, 0 if not.  If n is out of range, no
  //         action is taken.
  //
  // Notes: Adapted from M. Messier's IoInputModule::GoToFile
  //

  std::list<std::string>::iterator itr(fFileList.begin());
  int i = 0;
  for ( ; i < n && itr != fFileList.end(); ++i, ++itr ) { continue; }

  if ( i != n || itr == fFileList.end() ) {
    MSG("Per",Msg::kWarning) 
      << " Request to GoToFile ["<< n << "] on stream " << fStreamName 
      << " failed.\n Valid file index range 0-" << fFileList.size()-1 
      << "." << endl;
    return 0;
  } 

  this -> CloseFile();  // close current file
  fFileItr = itr;
  fIsBOF = false;
  
  std::string fullfilepathname = *fFileItr;
  return (this -> SetFile(fullfilepathname,Per::kRead));

}

int PerInputStream::GoToFile(std::string fullfilepathname) {
  //
  // Purpose: Move the stream to the file fullfilepathname in file list.
  //
  // Arguments: file name. If "", move the stream to the first file in the
  //            list. 
  //
  // Return: 1 if successful, 0 if not.  If file not found, no
  //         action is taken.
  //
  // Notes: Adapted from M. Messier's IoInputModule::GoToFile. Note
  //        that this method requires that fullfilepathname have been
  //        added to the stream file list first via the AddFile method.
  //

  if ( fFileList.empty() ) return 0;
  if ( fullfilepathname == "" ) return (this -> GoToFile(0));

  std::list<std::string>::iterator itr;
  for ( itr = fFileList.begin(); itr != fFileList.end(); ++itr ) { 
    if ( fullfilepathname == (*itr) ) { 
      this -> CloseFile();
      fFileItr = itr;
      fIsBOF = false;
      return ( this -> SetFile(fullfilepathname,Per::kRead) );
    }
  }

  // Failed to find file in list
  MSG("Per",Msg::kWarning) << " Request to GoToFile " << fullfilepathname
   << " on stream " << fStreamName << " failed.\n Not found in list." << endl;

  return 0;

}

bool PerInputStream::IsSelected() const {
  //
  //  Purpose:  Apply user's selection cut (if specified) to current
  //            entry of TTree.  User's specify a selection cut via the
  //            PerInputStream::SetSelection method.
  //
  //  Arguments: none.
  //
  //  Return: true if entry passes selection cut.
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes:  This mechanism of applying TTreeFormula to implement user's 
  //          selection cuts is adapted from an application observed in the 
  //          Babar's Pico Analysis Framework. 
  // 

  if ( !IsOpen() ) {
    MSG("Per",Msg::kWarning) 
      << "PerInputStream::IsSelected called on unopened stream " 
      << fStreamName << "." << endl;
    return false;
  }

  bool pass = true;

  // Check to see if user has implemented a selection cut and apply it.
  if ( fTTreeFormula ) {
    // TTree::LoadTree changes to entry of interest - doesn't load data yet 
    fTTree -> LoadTree(fEntry); 
    // Ask the treeformula to evaluate if this entry in the tree would pass
    // or fail the selection cuts.  Only necessary branches will be retrieved.
    if ( fTTreeFormula -> EvalInstance() == 0 ) {
      // if zero, the entry failed the cuts
      pass = false;
    }
  }

  return pass;  

}

std::ostream& PerInputStream::ListFile(std::ostream& os) const {
 //
  //  Purpose:  Print the contents of the fFileList for this stream.
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes:  Adapted from M. Messier's IoInputModule::List() method.
  //

  int idx = 0;
  std::string s;
  s = "index filename\n";
  os << s;
  int len = s.size();
  s = "=====  ";
  os << s;
  for ( int i = s.size()+1; i < len;  ++i) os << "=";
  os << endl;

  MsgFormat ifmt("%3i");
  std::list<std::string>::const_iterator itr;
  for ( itr = fFileList.begin(); itr != fFileList.end(); itr++ ) {
    os << "[" << ifmt(idx++)  << "] ";
    if ( itr == fFileItr ) os << "*";
    else os << " ";
    os << (*itr) << endl;
  }
 
  return os;

}

TObject* PerInputStream::Next(bool seek) {
  //
  //  Purpose:  Retrieve next entry from stream.  Entries are subject
  //            to the selection cut specified by the user via the
  //            PerInputStream::SetSelection method.  If the entry fails to
  //            pass the selection cut, and "seek" is set false, the
  //            a null pointer is returned.  If "seek" is set true,
  //            the method will continue to increment fEntry until it
  //            finds an entry passing the selection cut, or the end of
  //            the stream is reached.
  //
  //  Arguments: seek    bool   set true if user wishes to have stream
  //                            scroll through entries until it finds
  //                            entry passing selection cuts.
  //                            (default = false)
  //
  //  Return: pointer to retrieved TObject.  Returns null pointer if an
  //          error occured, the end of the stream is reached, or entry
  //          failed selection cuts and seek=false was set.
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes:  The TObject returned to the user is owned by the user, i.e.
  //          the user has the responsibility of deleting the allocated
  //          memory of this object.
  //          Use PerInputStream::IsEnd() to determine if Next failed
  //          to retrieve a new entry because end of current tree has been 
  //          reached.   

  Reset(); // reset object cache

  if ( !fTFile ) {
    // No file has been opened
    return (TObject*)0;
  }

  if ( IsEnd() && (!fUpdateMode || IsFileEnd()) ) {
    // Reached end of entries on this stream 
    return (TObject*)0;
  }
 
  TObject* object = 0;
  if ( !seek ) {
    if(!IsEnd())fEntry++; // increment entry number
    object = GetObject(fEntry); 
  }
  else {
    // user has requested to seek for next entry satisfying selection cuts
    while (object == (TObject*)0) {
      if(!IsEnd())fEntry++;  // Increment current entry number
      object = GetObject(fEntry); 
      if (IsEnd()) break;  // this silliness is to give GetObject a chance
      // to update tree before giving up
    }
  }

  return object;  // caller now owns object

}

int PerInputStream::NextFile(int n) {
  //
  //  Purpose:  Move stream forward n files in stream file list.  If n exceeds 
  //            number of files to end of list, ptr is left at eof marker.  
  //
  //  Arguments: number of files to advance.
  //             
  //  Return: 0 if number of requested files not advanced or file not 
  //          successfully opened, else 1. 
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes: Use IsEndOfFiles() to determine if at end of file list.
  //         If the next file in the list does not exist or cannot be 
  //         opened, a warning is issued and the file will be skipped, 
  //         advancing to the next file in the list

  if ( fFileList.empty() || (!fIsBOF && fFileItr == fFileList.end()) ) return 0;

  if ( fSequenceMode == Per::kSequential ||
       fSequenceMode == Per::kRandom      ) {
    if ( fCurrFileRepeat < fMaxFileRepeat &&
         !fTagsList.empty()                ) {
      MSG("Per",Msg::kDebug) << "Reusing file " << *fFileItr << endl;
      fRepeatedFile = true;
      fCurrFileRepeat++;
      return 1;
    } // end if : repeat file for random/sequential streams
    else {
      fCurrFileRepeat = 0;
    } // reset the repeat file counter if it is exceeded or we have no tags
  } // end if kSequential or kRandom sequence mode

  this -> DisableFile(); // disable current file but don't close it yet

  for ( int i = 0; i < n; i++ ) {
    if ( fIsBOF ) {
      fFileItr = fFileList.begin();
      fIsBOF = false;
    }
    else fFileItr++;
    
    // Flag attempts to read past the end of the file list
    if ( fFileItr == fFileList.end() ) {
      // Flag that we've reached the end of the input stream
      return 0;
    }
  }

  this -> CloseFile();
  std::string fullfilepathname = *fFileItr;
  if ( !this -> SetFile(fullfilepathname,Per::kRead) ) {
    // File open failed
    MSG("Per",Msg::kWarning) << "Stream " << GetStreamName() 
        << " failed\nto open file " << fullfilepathname 
        << ". File will be removed from this stream's file list and skipped." 
        << endl;
    this -> PrevFile(); // back up one so not sitting on file to be removed
    this -> RemoveFile(fullfilepathname);
    return this -> NextFile(); // and move to next
  }

  return 1;

}

const PerRecordTags& PerInputStream::NextTags() {
  //
  //  Purpose:  Return tags containing location of next block of sequential
  //            records of common VldContext.
  //
  //  Arguments: none.
  //             
  //  Return:  PerRecordTags of next set of tags in list.  The 
  //           current position in map is maintained by fTagsItr.
  //           If no new records are available, the end-of-stream PerRecordTags
  //           is returned. Use PerRecordTags::IsEnd() to test for this 
  //           condition.  
  //
  //  Contact:   S. Kasahara
  // 

  PerRecordTags currentTags = this->GetTags();

  if ( fTagsItr != fTagsList.end() ) {
    fTagsItr++;
    if ( fTagsItr != fTagsList.end() && (*fTagsItr).IsComplete() ) {
      return *fTagsItr;
    }
  }

  if ( (fSequenceMode == Per::kSequential ||
        fSequenceMode == Per::kRandom      ) &&
       fRepeatedFile                         &&
       fCurrFileRepeat <= fMaxFileRepeat     &&
       !fTagsList.empty()                     ) {
    // shuffle tags list for Per::kRandom sequence mode
    if (fSequenceMode == Per::kRandom) {
      ShuffleTagsList(fRanGen);
    }
    MSG("Per",Msg::kDebug) << "Repeating file in stream " << fStreamName
                           << endl;
    fRepeatedFile = false;
    // put the tags list iterator at the beginning of the list
    fTagsItr = fTagsList.begin();
    return *fTagsItr;
  } // return the beginning of the tags list if we repeat the file

  // Reached end of map, advance and reposition iterator to end of map
  if ( this -> AdvanceTagsList() ) {
    fTagsItr = fTagsList.end();
    fTagsItr--;
    if ( !(*fTagsItr).IsComplete() ) {
      if ( fTagsItr != fTagsList.begin() ) {
        fTagsItr--;
        if ( *fTagsItr == currentTags && currentTags.IsComplete() ) {
          return ( this->NextTags() );
        }
      }
      else return (this -> NextTags() ); //required under special circumstances
    }
    return *fTagsItr;
  }   
  else {
    // Leave iter at previous complete location (open file) or at eof marker
    fTagsItr = fTagsList.end();
    if ( fTagsItr != fTagsList.begin() ) fTagsItr--;
    if (!(*fTagsItr).IsComplete() && fTagsItr != fTagsList.begin()) fTagsItr--;
  }

  return fTagsEnd;

}

PerInputStream::PerInputStream(string treename) :
  PerStream(treename),fIsValidSelectionString(true),fSelection(""),
  fRequired(false),fTTreeFormula(0),
  fTreeCycle(-1),fFileEnd(true),fUpdateMode(false),fFileEnabled(false),
  fNewTree(false),fSequenceMode(Per::kKey),
  fTagsItr(fTagsList.end()),fMaxListSize(100),fFileItr(fFileList.end()),
  fWindowLower(0.0), fWindowUpper(0.0), fWindowTags(),
  fCurrFileRepeat(0), fMaxFileRepeat(0), fMeanMom(1.), fPushRandom(true),
  fRepeatedFile(false), fRanGen(0), fIsBOF(false), fFileCacheRead(0),
  fSumTags(0)
{
  //
  //  Purpose:  Default constructor.
  //
  //  Arguments: 
  //    treename  string   name of input tree served by this stream.
  //
  //  Return:    n/a.
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes: This constructor doesn't do anything except fill in data members.
  //         PerInputStream does not become active until PerInputStream::
  //         SetFile is invoked.
  // 

  MSG("Per",Msg::kDebug) << "PerInputStream normal ctor at " << this 
                         << " for tree " << treename.c_str() << endl;
  
  fLastEntryVld = Per::GetVldBegin();
  fTagsBegin.SetVldContext(Per::GetVldBegin());
  fTagsEnd.SetVldContext(Per::GetVldEnd());

}

PerInputStream::~PerInputStream() {
  //
  //  Purpose:  PerInputStream destructor.  
  //
  //  Contact:   S. Kasahara
  // 

  MSG("Per",Msg::kDebug) << "PerInputStream dtor at " << this 
                         << " for tree " << fTreeName.c_str() << endl;
  if (fRanGen) fRanGen = 0; // (*fRanGen) is owned by PerInputStreamManager !!
  if (fFileCacheRead) delete fFileCacheRead; fFileCacheRead = 0;

  Close();

}

int PerInputStream::PrevFile(int n) {
  //
  //  Purpose:  Move stream back n files in  stream file list.  
  //
  //  Arguments: number of files to rewind.
  //             
  //  Return: 0 if n files not rewound or file not successfully open, else 1.
  //
  //  Contact:   S. Kasahara
  // 

  if ( fFileList.empty() || fIsBOF ) return 0;

  this -> DisableFile(); // disable current file but don't close it yet

  for ( int i = 0; i < n; i++ ) {
    if ( fFileItr == fFileList.begin() ) fIsBOF = true;
    else fFileItr--;

    // Flag attempts to read past the begin of the file list
    if ( fIsBOF ) return 0;
  }

  this -> CloseFile();
  std::string fullfilepathname = *fFileItr;
  return (this -> SetFile(fullfilepathname,Per::kRead));

}

TObject* PerInputStream::Previous(bool seek) {
  //
  //  Purpose:  Retrieve previous entry from stream.  Entries are subject
  //            to the selection cut specified by the user via the
  //            PerInputStream::SetSelection method.  If the entry fails to
  //            pass the selection cut, and "seek" is set false, the
  //            a null pointer is returned.  If "seek" is set true,
  //            the method will continue to decrement fEntry until it
  //            finds an entry passing the selection cut, or the beginning of
  //            the stream is reached.
  //
  //  Arguments: seek   bool   set true if user wishes to have stream 
  //                           scroll through entries until it finds
  //                           entry passing selection cuts.
  //                           (default = false)
  //
  //  Return: pointer to retrieved TObject.  Returns null pointer if an
  //          error occured, the end of the stream is reached, or entry
  //          failed selection cuts and seek=false was set.
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes:  The TObject returned to the user is owned by the user, i.e.
  //          the user has the responsibility of deleting the allocated
  //          memory of this object.
  //          Use PerInputStream::IsBegin() to determine if Previous failed
  //          to retrieve a new entry because beginning of stream has been 
  //          reached.  

  Reset(); // reset object cache

  if ( !IsOpen() ) {
    // No file has been opened
    return (TObject*)0;
  }

  if ( IsBegin() ) {
    return (TObject*)0;
  }

  TObject* object = 0;
  if ( !seek ) {
    fEntry--; // decrement entry number
    object = GetObject(fEntry); 
  }
  else {
    // user has requested to seek for next entry satisfying selection cuts
    while ( !IsBegin() && object == (TObject*)0) {
      fEntry--;  // Decrement current entry number
      object = GetObject(fEntry);
    }
  }

  return object;  // caller now owns object

}


const PerRecordTags& PerInputStream::PrevTags() {
  //
  //  Purpose:  Return tags containing location of previous block of sequential
  //            records of common VldContext.
  //
  //  Arguments: none.
  //             
  //  Return:  PerRecordTags of previous set of tags in list.  The 
  //           current position in map is maintained by fTagsItr.
  //           If no new records are available, a begin of stream
  //           PerRecordTags is returned.  Use PerRecordTags::IsBegin 
  //           to test for this condition.
  //
  //  Contact:   S. Kasahara
  // 

  PerRecordTags currentTags = this -> GetTags();

  if ( fTagsItr != fTagsList.begin() ) {
    fTagsItr--;
    if ( fTagsItr != fTagsList.end() && (*fTagsItr).IsComplete() ) {
      return *fTagsItr;
    }
  }

  // Reached beginning of list, rewind and reposition iterator to start of list
  if ( this -> RewindTagsList() ) {
    fTagsItr = fTagsList.begin();
    if ( !(*fTagsItr).IsComplete() ) {
      fTagsItr++;
      if ( fTagsItr == fTagsList.end() || !(*fTagsItr).IsComplete() || 
           (*fTagsItr == currentTags) ) 
        return ( this-> PrevTags());
    }
    return *fTagsItr;
  }  
  else {
    // Leave iterator at eof marker
    fTagsItr = fTagsList.begin();
  }

  // Failure returns a beginning-of-stream tags
  return fTagsBegin;

}


std::ostream& PerInputStream::Print(std::ostream& ms) const {
  //
  //  Purpose:  Print status of stream on ostream.
  //
  //  Arguments: ms ostream to display on.
  //
  //  Return:  ostream reference.
  //
  //  Contact:   S. Kasahara
  //

  ms << "  PerInput"; 
  PerStream::Print(ms);
  ms << "  The current entry number of this stream is " << fEntry << endl;
  if ( !fSelection.empty() ) {
    ms << "  The selection cut:\n    " << fSelection 
       << "\n  has been specified for this stream.\n " << endl;
  }
  else {
    ms << "  A selection cut has not been specified for this stream." << endl;
  }

  return ms;

}

void PerInputStream::ShuffleTagsList(TRandom* ranGen)
{
  //
  // Purpose: Shuffle the tags list
  //
  // Note: This "swap shuffle" requires at least 3 reshuffles per
  //       call to this function to insure sufficient randomization.
  //       5 reshuffles is extra-safe.
  //
  // Contact: K. Arms
  //

  MSG("Per",Msg::kDebug) << "Shuffling " << fTagsList.size()-1
                         << " tags in stream " << fStreamName << endl;

  // >~ 3 insures a uniform randomization
  const unsigned int kNumRepeatShuffle = 5;

  for (unsigned int rep = 0; rep < kNumRepeatShuffle; rep++) {
    list<PerRecordTags>::iterator forward  = fTagsList.begin();
    list<PerRecordTags>::iterator backward = fTagsList.end();
    backward--; // puts itr at the last entry, which is a dummy

    while ( forward != (fTagsList.end()--) ){
      while ( backward != fTagsList.begin() ){
        backward--;
        bool flip = ranGen->Integer(2);
        if (flip) {
          PerRecordTags temp = *forward;
          *forward  = *backward;
          *backward = temp;
        } // end if       
      } // end while (backward)
      forward++;
    } // end while (forward)
  } // end reshuffle loop
}

int PerInputStream::RemoveFile(std::string fullfilepathname) {
  //
  //  Purpose:  Remove fullfilepathname from the list of input data files.
  //  
  //  Arguments: fullfilepathname  If == "*" (default), all files are removed.
  //             
  //  Return: number of removed files. 
  //
  //  Contact:   S. Kasahara
  //
  //  Notes: If requested file is currentfile, file will be closed.
  //         If fullfilepathname == "*", all files will be closed, and
  //         file iterator will be set to end of list.
  //         Otherwise, only 1 file (first matching) will be removed from
  //         file list, and iterator will be left alone if file is not
  //         currentfile, or incremented to next file if requested file
  //         is currentfile.

  
  if ( fFileList.empty() ) return 0; // nothing to remove

  if ( fullfilepathname == "*" ) {
    int nremoved = fFileList.size();
    if ( !fIsBOF && fFileItr != fFileList.end() ) CloseFile();
    fFileList.erase(fFileList.begin(),fFileList.end());
    fFileItr = fFileList.end();
    fIsBOF = false;
    return nremoved;
  }
  
  std::string currentFile = ""; bool isBegin = false;
  if ( !fIsBOF && fFileItr != fFileList.end() ) currentFile = *fFileItr;
  else if ( fIsBOF ) isBegin = true;
  std::list<std::string>::iterator itr=std::find(fFileList.begin(),
                                       fFileList.end(),fullfilepathname);
  if ( itr == fFileList.end() ) return 0; // requested file not in list
  
  if ( (!fIsBOF) && itr == fFileItr ) {
    // Current file, move forward 
    this -> NextFile();
    if ( fFileItr != fFileList.end() ) currentFile = *fFileItr;
    else currentFile = "";
  }
  
  fFileList.erase(itr);

  // Reset file iterator in revised list
  if ( isBegin && !fFileList.empty() ) fIsBOF = true;
  else { 
    fFileItr = std::find(fFileList.begin(),fFileList.end(),currentFile);
    fIsBOF = false;
  }

  return 1; 
  
 }

bool PerInputStream::RewindTagsList() {
  //
  //  Purpose:  Rewind fTagsList to include previous block of records with
  //            common VldContext.
  //
  //  Arguments: none
  //             
  //  Return: true if successful. New record block is stored in fTagsList
  //          PerRecordTags object.
  //
  //  Contact:   S. Kasahara
  // 



  if ( !IsOpen() ) return 0;

  // Find entry corresponding to first data block in tags list.
  TagsListItr itr = fTagsList.begin();
  Int_t lastIndex = this->GetNumEntries();
  VldContext oldVld = Per::GetVldEnd();
  if ( itr != fTagsList.end() ) {
    // The & is critical here so that can modify *itr contents
    PerRecordTags& oldTags = *itr;
    if ( oldTags.IsBegin() ) {
      if ( !oldTags.IsComplete() ) {
        oldTags.SetIndexLo(oldTags.GetIndexHi());
      // at beginning
        return 1;
      }
      else return 0;
    }
    if ( oldTags.IsComplete() ) lastIndex = oldTags.GetIndexLo();
    else lastIndex = TMath::Max(oldTags.GetIndexLo(),oldTags.GetIndexHi());
    oldVld = oldTags.GetVldContext();
  }

  // Rewind in tree if we have not reached the beginning
  VldContext newVld = oldVld;
  while ( newVld == oldVld && --lastIndex >= -1 ) {
    if ( lastIndex > -1 ) {
      newVld = this -> GetVldContext(lastIndex);
    }
    else {
      // At beginning of stream, lastIndex == -1
      newVld = Per::GetVldBegin();
    }
  }

  // Successfully rewound to previous Vld block in tree
  // Complete previous Vld block if it exists
  if ( itr != fTagsList.end() ) (*itr).SetIndexLo(lastIndex+1);
  PerRecordTags recordtags("",fTreeName,fFullFilePathName,-2,
                           lastIndex,newVld);
  fTagsList.push_front(recordtags);
  
  this -> CleanTagsList(false);

  return  1;

}

bool PerInputStream::SetFile(string fullfilepathname, 
                             Per::EAccessMode accessmode) {
  //
  //  Purpose:  Set new input file for this stream.
  //
  //  Arguments: fullfilepathname string      new filename containing stream.
  //             accessmode Per::EAccessMode  accessmode in which to open file.
  //                                          (default Per::kRead is currently
  //                                           the only allowed access mode
  //                                           for an input stream).
  //
  //  Return:  true if file was opened successfully and 
  //           i)tree of requested name was successfully retrieved OR
  //          ii)fUpdateMode has been set true for this stream and file is 
  //             not yet closed by the writer (and so potential for later 
  //             successful retrieval of tree exists).  This case is useful 
  //             when attempting to read an open file. 
  //
  //  Contact:   S. Kasahara
  //
  //  Notes: If SetFile returns false, PerStream::GetErrorCode can
  //         be used to determine reason for failure.
  //

  MSG("Per",Msg::kVerbose) << "SetFile(" << fullfilepathname << ","
                           << Per::AsString(accessmode) << ") called." << endl;

  // save current working directory so environment is left undisturbed on
  // output
  TDirectory* savedir = gDirectory;

  // Close, if necessary, old TTree and TFile before proceeding.
  CloseFile();

  fErrorCode = Per::kErrSuccess;

  if ( accessmode != Per::kRead ) {
    MSG("Per",Msg::kWarning) 
      << "PerInputStream::SetFile called w/ invalid accessmode "
      << Per::AsString(accessmode) << endl;
    fErrorCode = Per::kErrInvalidAccessMode;
    savedir -> cd();
    return false;
  }

  // Use file manager singleton to open file in requested mode.
  PerFileManager& perfilemanager = PerFileManager::Instance();
  const PerFile* file  = perfilemanager.OpenFile(fullfilepathname,accessmode);
  if ( !file ) {
    // file open failed, load file error in errorcode
    fErrorCode = perfilemanager.GetErrorCode();
    savedir -> cd();
    return false;
  }
  fTFile = file -> GetTFile();
  fFullFilePathName = fullfilepathname;
  fFileEnd = false;

  // Retrieve the requested tree from the file 
  if ( !UpdateTree() && ( !fUpdateMode || IsFileEnd() ) ) {
    // No Tree of requested name was available and writer has closed file
    // or user has not requested update mode
    MSG("Per",Msg::kWarning) << "Stream " << fStreamName.c_str()
                             << " failed to find tree " << fTreeName.c_str() 
                             << " in file " << fFullFilePathName.c_str() 
                             << "." << endl;
    fErrorCode = Per::kErrTreeReadError;
    CloseFile();
    savedir -> cd();
    return false;
  }
  
  savedir -> cd();
  fFileEnabled = true;
  return true;

}

bool PerInputStream::SetSelection(string selection) {
  //
  //  Purpose:  Select certain entries of TTree only according to attributes
  //            of the data stored in the TTree. This method makes use
  //            of the TTreeFormula class to apply the requested selection
  //            to the TTree.
  //
  //  Arguments: selection  string describing selection cut to be applied
  //                        to TTree served by this stream.   
  //                        The form of the selection string is the same
  //                        as that used by the TTree::Draw mechanism, and
  //                        includes the specification of the branchname
  //                        and accessor methods of interest.  3 examples:
  //                      1)"((RawDaqSnarlHeader*)fHeader)->GetSnarl() < 100"
  //                         where fHeader is the name of the header branch
  //                         and GetSnarl() is the header accessor method.
  //                      2)"fComponents -> GetEntries() > 0"
  //                         where fComponents is the name of the TObjArray
  //                         branch and GetEntries() is the TObjArray accessor
  //                         method.
  //                      3)"((RawDaqSnarlHeader*)fHeader)->GetSnarl() < 100 &&
  //                         fComponents -> GetEntries() > 0"
  //                         to illustrate that selection cuts can be applied
  //                         in combination.
  //
  //  Return:  false if application of TTreeFormula to open TTree failed
  //           due to invalid expression.
  //
  //  Contact:   S. Kasahara
  //

  MSG("Per",Msg::kVerbose) << "PerInputStream::SetSelection " << selection
                           << " on stream " << fStreamName << "." << endl;

  // Delete previous fTTreeFormula, if appropriate.
  if ( fTTreeFormula ) delete fTTreeFormula; fTTreeFormula = 0;

  fSelection = selection;
   fIsValidSelectionString = true;

  // If TTree is open, fTTreeFormula is immediately created.  
  // Otherwise, fTTreeFormula will be created at time of TTree creation.
  if ( fTTree && !fSelection.empty() ) {
    fTTreeFormula = new TTreeFormula("PerSelection",fSelection.c_str(),fTTree);
    if (fTTreeFormula -> GetNdim() <= 0) {
      MSG("Per",Msg::kWarning) << "Invalid selection string ignored." << endl;
      delete fTTreeFormula; fTTreeFormula = 0;
      fIsValidSelectionString = false;
      return false;
    }
  }

  return true;

}

bool PerInputStream::UpdateTree() {
  //
  //  Purpose: Retrieve latest TTree of name fTreeName from file.
  //
  //  Arguments: none.
  //
  //  Return:  true if tree was successfully retrieved, else false.
  //
  //  Contact:   S. Kasahara
  //
  //  Notes:  PerInputStream::SetFile must have been previously called to
  //          open the input file.
  //

  if ( !fTFile || this -> IsFileEnd() ) return false;

  bool newtree = false;
  TDirectory* saveDir = gDirectory;
  fTFile -> cd();

  // Retrieve latest set of keys from file and status of file closure
  Int_t nkeys = fTFile -> ReadKeys();
  if ( !nkeys ) {
    if (saveDir) saveDir -> cd();
    return false;
  }

  fFileEnd = PerFileManager::Instance().GetOpenedFile(fFullFilePathName)
                                                   -> HasFileEndKey();

  // The following loop only pulls in a new tree if it differs in cycle
  // number from a previously loaded tree to increase the efficiency in
  // the case of the read of an open ROOT file.
  TKey *key;
  TIter nextkey(fTFile->GetListOfKeys());
  while ((key = (TKey*)nextkey())) {
    if (strcmp(fTreeName.c_str(),key->GetName())==0) {
      // A new tree will be pulled in only if it differs from previous
      if ((fTreeCycle != key -> GetCycle()) || fFileEnd ) {
        TTree* tree = dynamic_cast<TTree*> (key -> ReadObj());
        if ( tree ) {
          // Successfully read in tree. (Failure to read in tree may be due
          // to a collision.)
          // Delete old tree before replacing it with new
          if (fTTree) delete fTTree; fTTree = 0; fTBranch = 0; 
          fTTree = tree;

          fTreeCycle = key -> GetCycle();
          newtree = true;
        }
        else {
          MSG("Per",Msg::kInfo) 
          << "PerInputStream experienced a recoverable collision reading tree "
          << fTreeName << " cycle " << key -> GetCycle() << "\nfrom file " 
          << fFullFilePathName << "." << endl;
        }  
        break;
      }
    }
  }  

  if ( newtree ) {
    // Retrieved tree is new

    if ( !fUpdateMode ) {
      // Not dispatcher 
      // TFile::UseCache broke between version 5.10/00 and 5.12/00
      // Try using SetCacheSize, which was fully implemented in root HEAD
      // on 7/23/2007.  
      if ( gROOT -> GetVersionInt() >= 51200 ) { 
        fTTree -> SetCacheSize(50000000); // per P. Canal instruction
        // The fFileCacheRead must be owned by this input stream to 
        // avoid having a segv on close when reading multiple trees from 
        // the same file.
        if ( fFileCacheRead ) delete fFileCacheRead; fFileCacheRead = 0;
        fFileCacheRead = fTFile -> GetCacheRead(); // store the new cache
        fTFile -> SetCacheRead(0); // ownership is ours! bwahaha
      }
    }

    // Every time we do an UpdateTree do a full delete of object cache
    // because otherwise SetBranchAddress won't be called for new tree
    if ( fTObject ) delete fTObject; fTObject = 0;
    fPerOwned = false;
    fNewTree = true;

    // Retrieve main branch and other data from information stored in TTree.
    // There should only be one main branch in TTree's created with the
    // Persistency package.
    TObjArray* branchlist = fTTree -> GetListOfBranches();
    Int_t nbranch = branchlist -> GetEntriesFast();
    if (nbranch != 1) {
      MSG("Per",Msg::kWarning) << "Unexpected number of main branches in tree "
                  << fTreeName << " from file " << fFullFilePathName << endl;
      delete fTTree; fTTree = 0; fTreeCycle= -1;
    }
    else {
      TBranchElement* branchelement 
                    = dynamic_cast<TBranchElement*>(branchlist -> At(0));
      if ( !branchelement ) {
        MSG("Per",Msg::kWarning) 
          << "Failed to retrieve main TBranchElement from tree" << fTreeName 
          << " from file " << fFullFilePathName << "." << endl;
        delete fTTree; fTTree = 0; fTreeCycle= -1;
      } 
      else {
        //classname&TClass of objects stored there,this is also name of branch.
        fClassName = branchelement -> GetClassName();
        fTBranch   = (TBranch*)branchelement;
 
        // Number of entries in this tree
        Int_t numEntries = this -> GetNumEntries();

        // Check to see if user has specified selection string
        if (!fSelection.empty()) {
          // If existing TTreeFormula, just apply it to new tree
          // This is a workaround until root fixes TTreeFormula memory leak
          if ( fTTreeFormula && fTreeCycle > 1) {
            fTTreeFormula->SetTree(fTTree);
            fTTreeFormula->UpdateFormulaLeaves();
          }
          else {
            this->SetSelection(fSelection); 
          }
        }
  
        // Store VldContext of first & last entry for use by manager in stream 
        // synchronization
        fFileEnabled = true;
        fLastEntryVld = Per::GetVldBegin();
        if ( numEntries > 0 ) { 
          fLastEntryVld = this -> GetVldContext(numEntries-1);
          fFileVldContextMap[fFullFilePathName] = this->GetVldContext(0);
        }
      }
    }
  }
  if ( newtree && fTTree != (TTree*)0) {
    if (fSequenceMode == Per::kSequential ||
        fSequenceMode == Per::kRandom      ) {
      fMaxListSize    = this->GetNumEntries()+1;
      fCurrFileRepeat = 0;
      fTagsList.erase( fTagsList.begin(), (fTagsList.end()--) );
      fRepeatedFile   = (fSequenceMode == Per::kRandom)? true : false;
    } // done setting the cache size to the number of snarls in this file

    MSG("Per",Msg::kDebug) << "\nUpdateTree retrieved tree " << fTreeName 
    << " with " << this->GetNumEntries() << " entries from file " 
    << fFullFilePathName << ". Last entry Vld " << fLastEntryVld << endl;
  }
  
  if (saveDir) saveDir -> cd();

  return (fTTree != (TTree*)0) ? true : false;


}

---