core/include/SCycleBaseNTuple.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
// $Id: SCycleBaseNTuple.h 283 2011-11-14 18:22:40Z krasznaa $
/***************************************************************************
 * @Project: SFrame - ROOT-based analysis framework for ATLAS
 * @Package: Core
 *
 * @author Stefan Ask       <Stefan.Ask@cern.ch>           - Manchester
 * @author David Berge      <David.Berge@cern.ch>          - CERN
 * @author Johannes Haller  <Johannes.Haller@cern.ch>      - Hamburg
 * @author A. Krasznahorkay <Attila.Krasznahorkay@cern.ch> - CERN/Debrecen
 *
 ***************************************************************************/

#ifndef SFRAME_CORE_SCycleBaseNTuple_H
#define SFRAME_CORE_SCycleBaseNTuple_H

// STL include(s):
#include <vector>
#include <map>
#include <string>
#include <list>

// Local include(s):
#include "ISCycleBaseConfig.h"
#include "ISCycleBaseNTuple.h"
#include "SCycleBaseBase.h"
#include "SError.h"

// Forward declaration(s):
class TTree;
class TFile;
class TBranch;
class SInputData;

class SCycleBaseNTuple : public virtual ISCycleBaseConfig,
                         public virtual ISCycleBaseNTuple,
                         public virtual SCycleBaseBase {

public:
   SCycleBaseNTuple();
   virtual ~SCycleBaseNTuple();

   virtual void SetNTupleOutput( TList* output );
   virtual TList* GetNTupleOutput() const;

   template< typename T >
   bool ConnectVariable( const char* treeName, const char* branchName,
                         T& variable ) throw ( SError );
   template< typename T, size_t size >
   bool ConnectVariable( const char* treeName, const char* branchName,
                         T ( &variable )[ size ] ) throw( SError );
   template< typename T >
   bool ConnectVariable( const char* treeName, const char* branchName,
                         T*& variable ) throw( SError );

   template< class T >
   TBranch* DeclareVariable( T& obj, const char* name,
                             const char* treeName = 0 ) throw( SError );

   virtual TTree* GetMetadataTree( const char* name ) const throw( SError );
   virtual TTree* GetInputMetadataTree( const char* name ) const throw( SError );
   virtual TTree* GetOutputMetadataTree( const char* name ) const throw( SError );
   virtual TTree* GetInputTree( const char* treeName ) const throw( SError );
   virtual TTree* GetOutputTree( const char* treeName ) const throw( SError );

protected:
   //                                                      //
   //          Functions called by the framework:          //
   //                                                      //

   void CreateOutputTrees( const SInputData& id,
                           std::vector< TTree* >& outTrees,
                           TFile* outputFile = 0 ) throw( SError );
   void SaveOutputTrees( TDirectory* output ) throw( SError );
   void LoadInputTrees( const SInputData& id, TTree* main_tree,
                        TFile*& inputFile ) throw( SError );
   void GetEvent( Long64_t entry ) throw( SError );
   Double_t CalculateWeight( const SInputData& inputData, Long64_t entry );
   void ClearCachedTrees();

private:
   static const char* RootType( const char* typeid_type ) throw( SError );
   static const char* TypeidType( const char* root_type ) throw( SError );
   void RegisterInputBranch( TBranch* br ) throw( SError );
   void DeleteInputVariables();
   TDirectory* MakeSubDirectory( const TString& path, TDirectory* dir ) const throw( SError );

   //
   // These are the objects used to handle the input and output data:
   //
   std::vector< TTree* >   m_inputTrees; // List of input TTree pointers
   std::vector< TBranch* > m_inputBranches; // vector of input branch pointers
                                            // registered for the current cycle
   std::list< TObject* >   m_inputVarPointers; // Pointers storing the input objects
                                               // created by ConnectVariable(...)

   std::vector< TTree* > m_outputTrees;
   std::vector< TTree* > m_metaInputTrees;
   std::vector< TTree* > m_metaOutputTrees;

   // We have to keep the pointers to the output variables defined by the user.
   // ROOT keeps track of the objects by storing pointers to pointers to the
   // objects. Since the user probably wants to use the output objects directly
   // and not through pointers, the base class has to take care of this
   // pointer issue by itself...
   std::list< void* > m_outputVarPointers;

   TList* m_output; 

#ifndef DOXYGEN_IGNORE
   ClassDef( SCycleBaseNTuple, 0 );
#endif // DOXYGEN_IGNORE

}; // class SCycleBaseNTuple

// Don't include the templated function(s) when we're generating
// a dictionary:
#ifndef __CINT__
#include "SCycleBaseNTuple.icc"
#endif

#endif // SFRAME_CORE_SCycleBaseNTuple_H