AliMUONTreeManager.cxx

Go to the documentation of this file.

/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* Permission to use, copy, modify and distribute this software and its   *
* documentation strictly for non-commercial purposes is hereby granted   *
* without fee, provided that the above copyright notice appears in all   *
* copies and that both the copyright notice and this permission notice   *
* appear in the supporting documentation. The authors make no claims     *
* about the suitability of this software for any purpose. It is          *
* provided "as is" without express or implied warranty.                  *
**************************************************************************/

// $Id$

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

#include "AliMUONTreeManager.h"

#include "AliLog.h"
#include "AliMUONObjectPair.h"
#include <TList.h>
#include <TObjString.h>
#include <TTree.h>
#include <TBranch.h>
#include <Riostream.h>

using std::cout;
using std::endl;
ClassImp(AliMUONTreeManager)

//_____________________________________________________________________________
AliMUONTreeManager::AliMUONTreeManager() : TObject()
{
}

//_____________________________________________________________________________
AliMUONTreeManager::~AliMUONTreeManager()
{
}

//_____________________________________________________________________________
void
AliMUONTreeManager::GetEvent(TTree& tree, Int_t event) const
{
  
#ifndef NDEBUG
    TObjArray* branches = tree.GetListOfBranches();
    TIter next(branches);
    TBranch* branch;
    Bool_t error(kFALSE);
    
    while ( ( branch = static_cast<TBranch*>(next()) ) )
    {
      TString bname(branch->GetName());
      if ( branch->GetAddress() == 0 &&
           tree.GetBranchStatus(bname.Data()) == 1 ) 
      {
        AliError(Form("Branch %s has status 1 and no address",bname.Data()));
        error = kTRUE;
      }
    }
    
    if ( error ) 
    {
      ShowStatus(tree);
    }
#endif
  
  tree.GetEvent(event);
}

//_____________________________________________________________________________
void
AliMUONTreeManager::ShowStatus(TTree& tree) const
{
  TObjArray* branches = tree.GetListOfBranches();
  TIter next(branches);
  TBranch* branch;
  
  while ( ( branch = static_cast<TBranch*>(next()) ) )
  {
    TString bname(branch->GetName());
    Int_t status = tree.GetBranchStatus(bname.Data());
    cout << Form("%50s Status %d Address %p",bname.Data(),status,branch->GetAddress()) << endl;
  }
}

//_____________________________________________________________________________
void 
AliMUONTreeManager::AddClassName(TTree& tree, const char* pattern, 
                                 const char* className) const
{
  
  TString test(GetClassName(tree,pattern,kFALSE));
  if ( test.Length() == 0 )
  {
    // not already there
    TList* userInfo = tree.GetUserInfo();
    userInfo->Add(new AliMUONObjectPair(new TObjString(pattern),
                                        new TObjString(className),
                                        kTRUE,kTRUE));
  }
}

//_____________________________________________________________________________
Bool_t
AliMUONTreeManager::MakeBranch(TTree& tree, const char* storeClassName,
                               const char* branchClassName,
                               const char* branchName, 
                               void* address,
                               Int_t bufferSize, Int_t splitLevel) const
{
  AddClassName(tree,branchName,storeClassName);
  TBranch* branch = tree.Branch(branchName,branchClassName,address,bufferSize,splitLevel);
  return ( branch != 0x0 );
}

//_____________________________________________________________________________
Bool_t 
AliMUONTreeManager::SetAddress(TTree& tree, const char* branchName, 
                               void* address) const
{
  TBranch* branch = tree.GetBranch(branchName);
  if (branch)
  {
    branch->SetAddress(address);
    return kTRUE;
  }
  AliError(Form("Did not find branch %s in tree %s",branchName,tree.GetName()));
  return kFALSE;
}

//_____________________________________________________________________________
TObject* 
AliMUONTreeManager::CreateObject(const TTree& tree, const char* detail) const
{
  TString className(GetClassName(tree,detail,kTRUE));
  TClass* classPtr = TClass::GetClass(className.Data());
  if (!classPtr)
  {
    AliError(Form("Could not get class %s",className.Data()));
    return 0x0;
  }
  return reinterpret_cast<TObject*>(classPtr->New());
}

//_____________________________________________________________________________
void 
AliMUONTreeManager::UpdateBranchStatuses(TTree& tree, const char* pattern) const
{
  
  TIter next(tree.GetListOfBranches());
  TBranch* branch;
  
  while ( ( branch = static_cast<TBranch*>(next()) ) )
  {
    TString bname(branch->GetName());
    if ( bname.Contains(pattern) )
    {
      tree.SetBranchStatus(Form("%s*",branch->GetName()),1);
    }
    else
    {
      if ( !branch->GetAddress() )
      {
        tree.SetBranchStatus(Form("%s*",branch->GetName()),0);
      }
    }
  }

}

//_____________________________________________________________________________
TString
AliMUONTreeManager::GetClassName(const TTree& tree, const char* pattern,
                                 Bool_t makeDefault) const
{
  
  TTree& vtree = const_cast<TTree&>(tree); // not pretty, but the GetUserInfo is not const...
  
  TIter next(vtree.GetUserInfo());
  
  TObject* object;
  
  while ( ( object = next() ) )
  {
    AliMUONObjectPair* pair = static_cast<AliMUONObjectPair*>(object);
    TString key = (static_cast<TObjString*>(pair->First()))->String();
    TString value = (static_cast<TObjString*>(pair->Second()))->String();
    if ( key.Contains(pattern,TString::kIgnoreCase) ) 
    {
      return value;
    }
  }
  
  if ( makeDefault ) return DefaultClassName(tree.GetName(),pattern);
  
  return "";
}

//_____________________________________________________________________________
TString
AliMUONTreeManager::DefaultClassName(const char* treeName, const char* pattern) const
{
  
  TString name(treeName);
  TString spattern(pattern);
  spattern.ToUpper();
  
  if ( name == "TreeH" ) 
  {
    return "AliMUONHitStoreV1";
  }
  
  if ( name == "TreeD" || name == "TreeS" ) 
  {
    if ( spattern.Contains("TRIGGER") ) return "AliMUONTriggerStoreV1";
    if ( spattern.Contains("DIGIT") ) return "AliMUONDigitStoreV1";
  }
  
  if ( name == "TreeR" ) 
  {
    if ( spattern.Contains("CLUSTER") ) return "AliMUONClusterStoreV1";
    if ( spattern.Contains("TRIGGER") ) return "AliMUONTriggerStoreV1";
  }
  
  if ( name == "TreeT" ) 
  {
    if ( spattern.Contains("TRIGGER" ) ) return "AliMUONTriggerTrackStoreV1";
    if ( spattern.Contains("TRACK") ) return "AliMUONTrackStoreV1";
  }
  
  AliError(Form("Do not know how to create default class for tree %s pattern %s",
                treeName,pattern));
  return "";
}