#include <SimpleLoopBase.hxx>

Inheritance diagram for SimpleLoopBase:

Public Member Functions
	SimpleLoopBase (int argc, char *argv[])

void	Loop (int nmax=0, int imin=0)

void	Execute ()

Public Member Functions inherited from OutputManager
virtual bool	InitializeEntry ()

void	InitializeTrees (bool iniVars=true)

void	InitializeTree (Int_t tree_index, bool iniVars=true)

void	InitializeTree ()

std::string	GetString (int a)

std::string	GetSize (const std::string &counter_name, unsigned int size)

const std::string &	GetVarName (Int_t tree_index, Int_t var_index) const
	Returns the variable name.

const std::string &	GetVarName (Int_t var_index) const

const std::string &	GetCounterName (Int_t tree_index, Int_t counter_index) const
	Returns the counter name.

const std::string &	GetCounterName (Int_t counter_index) const

void	AddCounter (Int_t tree_index, Int_t index, Int_t counter_index, const std::string &counter_name, int size=-1)

void	AddCounter (Int_t tree_index, Int_t counter_index, const std::string &counter_name, int size=-1)

void	InitializeCounter (Int_t tree_name, Int_t counter_index)

void	InitializeCounter (Int_t counter_index)

void	ResizeCounter (Int_t tree_index, Int_t counter_index, Int_t size)

void	ResizeCounter (Int_t counter_index, int size)

bool	HasCounter (Int_t tree_name, Int_t counter_index)

bool	CheckCounterType (Int_t counter_index, Int_t indx, Int_t var_index)

void	IncrementCounter (Int_t counter_index)

void	IncrementCounterForVar (Int_t index)

Int_t	GetCounterIndexForVar (Int_t index)

Int_t	GetCounterValue (Int_t counter_index)

Int_t	GetCounterValue (Int_t tree_index, Int_t counter_index)

Int_t	GetCounterValueForVar (Int_t index)

Int_t	GetCounterValueForVar (Int_t tree_index, Int_t index)

bool	GetFirstIndexFromCounter (Int_t index, Int_t &indx1)

void	DeleteVar (Int_t tree_index, Int_t index)

void	AddVar (Int_t index, const std::string &name, const std::string &type, const std::string &doc, double ini=-9999)
	Add a single variable to all trees.

void	AddVar (Int_t tree_index, Int_t index, const std::string &name, const std::string &type, const std::string &doc, double ini=-9999)
	Add a single variable to a specific tree.

void	AddVectorVar (Int_t index, const std::string &name, const std::string &type, const std::string &doc, Int_t counter_index, const std::string &counter_name, Int_t size=-MAXVECTORSIZE)
	Add a vector variable to all trees.

void	AddVectorVar (Int_t tree_index, Int_t index, const std::string &name, const std::string &type, const std::string &doc, Int_t counter_index, const std::string &counter_name, Int_t size=-MAXVECTORSIZE)
	Add a vector variable to a specific tree.

void	AddVectorVar (Int_t index, const std::string &name, const std::string &type, const std::string &doc, const int size)
	Add a vector variable to all trees.

void	AddVectorVar (Int_t tree_index, Int_t index, const std::string &name, const std::string &type, const std::string &doc, const int size)
	Add a vector variable to a specific tree.

void	AddMatrixVar (Int_t index, const std::string &name, const std::string &type, const std::string &doc, Int_t counter_index, const std::string &counter_name, int size1=-MAXVECTORSIZE, int size2=-1)
	Add a matrix variable to all trees.

void	AddMatrixVar (Int_t tree_index, Int_t index, const std::string &name, const std::string &type, const std::string &doc, Int_t counter_index, const std::string &counter_name, int size1=-MAXVECTORSIZE, int size2=-1)
	Add a matrix variable to a specific tree.

void	AddMatrixVar (Int_t index, const std::string &name, const std::string &type, const std::string &doc, int size1=-MAXVECTORSIZE, int size2=-1)
	Add a matrix variable to all trees.

void	AddMatrixVar (Int_t tree_index, Int_t index, const std::string &name, const std::string &type, const std::string &doc, int size1=-MAXVECTORSIZE, int size2=-1)
	Add a matrix variable to a specific tree.

void	Add3DMatrixVar (Int_t index, const std::string &name, const std::string &type, const std::string &doc, Int_t counter_index, const std::string &counter_name, int size1=-MAXVECTORSIZE, int size2=-1, int size3=-1)
	Add a 3D matrix variable to all trees.

void	Add3DMatrixVar (Int_t tree_index, Int_t index, const std::string &name, const std::string &type, const std::string &doc, Int_t counter_index, const std::string &counter_name, int size1=-MAXVECTORSIZE, int size2=-1, int size3=-1)
	Add a 3D matrix variable to a specific tree.

void	AddToyVar (Int_t index, const std::string &name, const std::string &type, const std::string &docstring)
	Add a single analysis variable to all trees.

void	AddToyVar (Int_t tree_index, Int_t index, const std::string &name, const std::string &type, const std::string &docstring)
	Add a single analysis variable to a specific tree.

void	AddToyVectorVar (Int_t index, const std::string &name, const std::string &type, const std::string &docstring, int ncomp)
	Add a vector analysis variable to all trees.

void	AddToyVectorVar (Int_t tree_index, Int_t index, const std::string &name, const std::string &type, const std::string &docstring, int ncomp)
	Add a vector analysis variable to a specific tree.

void	AddToyMatrixVar (Int_t index, const std::string &name, const std::string &type, const std::string &docstring, int ncomp1, int ncomp2)
	Add a matrix analysis variable to all trees.

void	AddToyMatrixVar (Int_t tree_index, Int_t index, const std::string &name, const std::string &type, const std::string &docstring, int ncomp1, int ncomp2)
	Add a matrix analysis variable to a specific tree.

void	InitializeVar (Int_t index, Double_t ini)

void	InitializeVectorVar (Int_t index, Double_t ini)

void	InitializeMatrixVar (Int_t index, Double_t ini)

void	FillVar (Int_t index, Float_t var)
	Fill a single variable.

void	FillVar (Int_t index, Double_t var)

void	FillVar (Int_t index, Int_t var)

void	FillVar (Int_t index, const std::string &var)

Float_t	GetVarValueF (Int_t index)
	Get the value of a var already filled (so to be used in another package)

Double_t	GetVarValueD (Int_t index)

Int_t	GetVarValueI (Int_t index)

void	FillVectorVar (Int_t index, Float_t var, Int_t indx=-1)
	Fill a vector variable.

void	FillVectorVar (Int_t index, Int_t var, Int_t indx=-1)

void	FillVectorVar (Int_t index, Double_t var, Int_t indx=-1)

void	FillVectorVar (Int_t index, const std::string &var, Int_t indx=-1)

void	FillVectorVarFromArray (Int_t index, const Double_t var[], UInt_t size)
	Fill a vector variable from array.

void	FillVectorVarFromArray (Int_t index, const Float_t var[], UInt_t size)

void	FillVectorVarFromArray (Int_t index, const Int_t var[], UInt_t size)

void	FillVectorVarFromArray (Int_t index, const std::string var[], UInt_t size)

Float_t	GetVectorVarValueF (Int_t index, Int_t i1)
	Get the value of a var already filled (so to be used in another package)

Double_t	GetVectorVarValueD (Int_t index, Int_t i1)

Int_t	GetVectorVarValueI (Int_t index, Int_t i1)

void	FillMatrixVar (Int_t index, Float_t var, Int_t indx1, Int_t indx2)
	Fill a matrix variable.

void	FillMatrixVar (Int_t index, Int_t var, Int_t indx1, Int_t indx2)

void	FillMatrixVar (Int_t index, Double_t var, Int_t indx1, Int_t indx2)

void	FillMatrixVarFromArray (Int_t index, const Double_t var[], Int_t indx1, UInt_t size)
	Fill a matrix variable from array.

void	FillMatrixVarFromArray (Int_t index, const Float_t var[], Int_t indx1, UInt_t size)

void	FillMatrixVarFromArray (Int_t index, const Int_t var[], Int_t indx1, UInt_t size)

void	FillMatrixVarFromArray (Int_t index, const Double_t var[], UInt_t size)
	Fill a matrix variable from array.

void	FillMatrixVarFromArray (Int_t index, const Float_t var[], UInt_t size)

void	FillMatrixVarFromArray (Int_t index, const Int_t var[], UInt_t size)

Float_t	GetMatrixVarValueF (Int_t index, Int_t i1, Int_t i2)
	Get the value of a var already filled (so to be used in another package)

Double_t	GetMatrixVarValueD (Int_t index, Int_t i1, Int_t i2)

Int_t	GetMatrixVarValueI (Int_t index, Int_t i1, Int_t i2)

void	Fill3DMatrixVar (Int_t index, Float_t var, Int_t indx1, Int_t indx2, Int_t indx3)
	Fill a 3D matrix variable.

void	Fill3DMatrixVar (Int_t index, Int_t var, Int_t indx1, Int_t indx2, Int_t indx3)

void	Fill3DMatrixVar (Int_t index, Double_t var, Int_t indx1, Int_t indx2, Int_t indx3)

void	Fill3DMatrixVarFromArray (Int_t index, const Double_t var[], Int_t indx1, Int_t indx2, UInt_t size)
	Fill a 3D matrix variable from array.

void	Fill3DMatrixVarFromArray (Int_t index, const Float_t var[], Int_t indx1, Int_t indx2, UInt_t size)

void	Fill3DMatrixVarFromArray (Int_t index, const Int_t var[], Int_t indx1, Int_t indx2, UInt_t size)

void	FillToyVar (Int_t index, Int_t var)
	Fill a single analysis variable.

void	FillToyVar (Int_t index, Float_t var)

void	FillToyVar (Int_t index, Double_t var)

Float_t	GetToyVarValueF (Int_t index)
	Get the value of a var already filled (so to be used in another package)

Double_t	GetToyVarValueD (Int_t index)

Int_t	GetToyVarValueI (Int_t index)

void	FillToyVectorVar (Int_t index, Int_t var, Int_t comp)
	Fill a vector analysis variable.

void	FillToyVectorVar (Int_t index, Float_t var, Int_t comp)

void	FillToyVectorVar (Int_t index, Double_t var, Int_t comp)

Float_t	GetToyVectorVarValueF (Int_t index, Int_t i1)
	Get the value of a var already filled (so to be used in another package)

Double_t	GetToyVectorVarValueD (Int_t index, Int_t i1)

Int_t	GetToyVectorVarValueI (Int_t index, Int_t i1)

void	FillToyMatrixVar (Int_t index, Int_t var, Int_t comp1, Int_t comp2)
	Fill a matrix analysis variable.

void	FillToyMatrixVar (Int_t index, Float_t var, Int_t comp1, Int_t comp2)

void	FillToyMatrixVar (Int_t index, Double_t var, Int_t comp1, Int_t comp2)

void	InitializeAnalysisVar (Int_t index, Double_t ini)

void	InitializeAnalysisVectorVar (Int_t index, Double_t ini)

void	FillTree (Int_t tree_index)
	Fill a specific tree.

void	FillTree ()
	Fill the current tree.

void	WriteTree (const std::string &file, const std::string &conf)
	Write a specific tree into a file.

void	WriteTrees (const std::string &file)
	Write all trees into a file.

void	AddTreeWithName (Int_t tree_index, const std::string &tree_name, TTree *tree=NULL)
	Add a tree provided its index and name.

bool	OpenOutputFile (const std::string &file)
	open the output file

void	CloseOutputFile ()
	close the output file

bool	ValidateVarNameAndIndex (Int_t tree_index, Int_t var_index, const std::string &var_name)

bool	IsSpecialTree (Int_t tree_index)

void	SetToyIndex (Int_t index)
	Set and gets the index of the current toy experiment.

Int_t	GetToyIndex ()

void	SetNToys (Int_t tree_index, int ntoys)
	Sets and gets the number of toy experiments for a given configuration.

UInt_t	GetNToys (Int_t tree_index)
	Get the number of toys for a given tree.

UInt_t	GetNToys ()
	Get the number of toys for the current tree.

void	AddToyWeight (Double_t w)

void	FillMicroTrees ()

void	SetFillSingleTree (Int_t tree_index)

void	SetFillAllTrees ()

void	CheckVariableType (Int_t index, const std::string &dim, const std::string &type, Bool_t exist)

void	SetDocStringManager (DocStringManager *doc)

DocStringManager &	docstrings ()

Public Member Functions inherited from TreeManager
std::vector< TTree *> &	GetTrees ()
	Returns the map of trees.

TTree *	GetTree (Int_t index)
	Returns the a tree with a given index.

TTree *	GetTree (const std::string &name)
	Returns the a tree with a given name.

TTree *	GetTree ()
	Returns the a tree set as current.

void	ReadTree (const std::string &file, Int_t index)
	Read a tree from a file provided the index.

void	ReadTree (const std::string &file, const std::string &name)
	Read a tree from a file provided the name.

void	ReadFile (const std::string &file)
	Read all trees from a file.

Int_t	GetTreeIndex (const std::string &tree_name)
	Retuns the tree index provided the name.

std::string	GetTreeName (Int_t index)
	Retuns the tree name provided the index.

Int_t	GetCurrentTree () const
	Retuns the current tree index.

std::string	GetCurrentTreeName ()
	Retuns the current tree name.

void	SetCurrentTree (Int_t index)
	Sets the current tree provided the index.

void	SetCurrentTree (const std::string &tree_name)
	Sets the current tree provided the name.

bool	HasTree (Int_t index)
	Check the existence of a tree provided the index.

bool	HasTree (const std::string &tree_name)
	Check the existence of a tree provided the name.

Protected Member Functions
void	PrintUsage (const std::string &programName)
	Print the program's usage statement.

virtual bool	Initialize ()

virtual bool	InitializeSpill ()

virtual void	Finalize ()

virtual void	FinalizeSpill ()
	Finalize each spill, including cleaning up data read from the input file.

virtual bool	Process ()=0

virtual void	DefineOutputTree ()
	Define the tree that should be written to the output file.

HighlandInputManager &	input ()

void	FillConfigTree ()
	Fill the "config" tree, which includes details of the analysis cuts etc.

Protected Attributes
Long64_t	_entry
	The current entry in the file.

std::string	_inputFileName
	Input file name, as specified by the user.

std::string	_inputFileType

std::string	_outputFileName
	The output file name, as specified by the user.

bool	_cosmicMode

bool	_versionCheck
	Check version compatibility between nd280AnalysisTools compilation and oaAnalysis file.

MemoryUsage	_memory
	Memory logging.

CorrectionManager	_corrections
	Correction manager.

DocStringManager	_docStrings
	DocStrings manager.

Protected Attributes inherited from OutputManager
std::string	_default_docstring

DocStringManager *	_doc

std::vector< Double_t >	_toyWeights

int	_toy_index
	current toy experiment index

Int_t	_single_tree_fill

std::vector< std::vector< std::string > >	_tree_vars_all_vars
	The names of all variables added.

std::vector< std::vector< std::string > >	_tree_vars_all_counters
	The names of all counters added.

std::vector< std::vector< Int_t > >	_link_var_to_counter
	Correspondece between a variable index and the counter index.

std::vector< std::vector< Int_t > >	_tree_vars_counter_size
	The size of the counter: 0 for variable size vectors, >0 for fix size vectors.

std::vector< std::vector< Int_t > >	_tree_vars_counter
	The counter it self.

std::vector< std::vector< Int_t > >	_tree_vars_int
	Single variables.

std::vector< std::vector< Float_t > >	_tree_vars_float

std::vector< std::vector< Double_t > >	_tree_vars_double

std::vector< std::vector< achar > >	_tree_vars_char

std::vector< std::vector< int_vector *> >	_tree_vars_int_vector
	Vector variables (1 index)

std::vector< std::vector< float_vector *> >	_tree_vars_float_vector

std::vector< std::vector< double_vector *> >	_tree_vars_double_vector

std::vector< std::vector< char_vector *> >	_tree_vars_char_vector

std::vector< std::vector< int_matrix *> >	_tree_vars_int_matrix
	Matrix variables (2 indices)

std::vector< std::vector< float_matrix *> >	_tree_vars_float_matrix

std::vector< std::vector< double_matrix *> >	_tree_vars_double_matrix

std::vector< std::vector< char_matrix *> >	_tree_vars_char_matrix

std::vector< std::vector< int_3Dmatrix *> >	_tree_vars_int_3Dmatrix
	3D matrix variables (3 indices)

std::vector< std::vector< float_3Dmatrix *> >	_tree_vars_float_3Dmatrix

std::vector< std::vector< double_3Dmatrix *> >	_tree_vars_double_3Dmatrix

std::vector< std::vector< Int_t > >	_tree_vars_used_counter
	The counter it self.

std::vector< std::vector< Int_t > >	_tree_vars_used_int
	Single variables.

std::vector< std::vector< Int_t > >	_tree_vars_used_float

std::vector< std::vector< Int_t > >	_tree_vars_used_double

std::vector< std::vector< Int_t > >	_tree_vars_used_char

std::vector< std::vector< Int_t > >	_tree_vars_used_int_vector
	Vector variables (1 index)

std::vector< std::vector< Int_t > >	_tree_vars_used_float_vector

std::vector< std::vector< Int_t > >	_tree_vars_used_double_vector

std::vector< std::vector< Int_t > >	_tree_vars_used_char_vector

std::vector< std::vector< Int_t > >	_tree_vars_used_int_matrix
	Matrix variables (2 indices)

std::vector< std::vector< Int_t > >	_tree_vars_used_float_matrix

std::vector< std::vector< Int_t > >	_tree_vars_used_double_matrix

std::vector< std::vector< Int_t > >	_tree_vars_used_char_matrix

std::vector< std::vector< Int_t > >	_tree_vars_used_int_3Dmatrix
	3D matrix variables (3 indices)

std::vector< std::vector< Int_t > >	_tree_vars_used_float_3Dmatrix

std::vector< std::vector< Int_t > >	_tree_vars_used_double_3Dmatrix

std::vector< std::vector< Bool_t > >	_tree_vars_exist_int
	–— Vectors containing whether a given index is used or not More...

std::vector< std::vector< Bool_t > >	_tree_vars_exist_float

std::vector< std::vector< Bool_t > >	_tree_vars_exist_double

std::vector< std::vector< Bool_t > >	_tree_vars_exist_char

std::vector< std::vector< Bool_t > >	_tree_vars_exist_int_vector
	Vector variables (1 index)

std::vector< std::vector< Bool_t > >	_tree_vars_exist_float_vector

std::vector< std::vector< Bool_t > >	_tree_vars_exist_double_vector

std::vector< std::vector< Bool_t > >	_tree_vars_exist_char_vector

std::vector< std::vector< Bool_t > >	_tree_vars_exist_int_matrix
	Matrix variables (2 indices)

std::vector< std::vector< Bool_t > >	_tree_vars_exist_float_matrix

std::vector< std::vector< Bool_t > >	_tree_vars_exist_double_matrix

std::vector< std::vector< Bool_t > >	_tree_vars_exist_char_matrix

std::vector< std::vector< Bool_t > >	_tree_vars_exist_int_3Dmatrix
	3D matrix variables (3 indices)

std::vector< std::vector< Bool_t > >	_tree_vars_exist_float_3Dmatrix

std::vector< std::vector< Bool_t > >	_tree_vars_exist_double_3Dmatrix

Protected Attributes inherited from TreeManager
TFile *	_file
	Root input or output file.

std::vector< TTree *>	_trees
	Vector of trees.

std::vector< TTree *>	_trees_nonull
	Vector of non NULL trees.

std::vector< Int_t >	_trees_indices
	Vector of indices for the non NULL TTree in previous vector.

Int_t	_current_tree
	The current tree.

Additional Inherited Members
Public Types inherited from OutputManager
enum	enumStandardMicroTrees_OutputManager { NTOYS =0, toy_weight, toy_index, enumStandardMicroTreesLast_OutputManager }

enum	enumSpecialTrees { config =0, header, truth, NRooTrackerVtx, GRooTrackerVtx, RooTrackerVtx, enumSpecialTreesLast }

Detailed Description

This class is a base class for simple event loops (Flat tree creation, etc). It handles the opening and reading of input files, and converting each spill to the AnaSpill format. The derived Process() function is called for each spill.

Definition at line 15 of file SimpleLoopBase.hxx.

Member Function Documentation

§ Execute()

void SimpleLoopBase::Execute ( )

Entry point to the class, where argc and argv are the command line parameters.

Definition at line 382 of file SimpleLoopBase.cxx.

                             {
 //********************************************************************
   Loop(_entry_nmax,_entry_imin);
 }

§ Finalize()

void SimpleLoopBase::Finalize ( )

protectedvirtual

Tidy up, including closing the output file. Called after all spills have beem read.

Reimplemented from OutputManager.

Reimplemented in CreateFlatTree, and CreateMiniTree.

Definition at line 207 of file SimpleLoopBase.cxx.

                              {
 //********************************************************************
 
   // Finalize the derived class
   Finalize();
 
   // Create and fill the header tree with a single entry
   AddTreeWithName(OutputManager::header,"header");  
   Header* headerp = &_input.header();
   GetTree(OutputManager::header)->Branch("POTInfo","Header",&headerp,32000,0);  
   GetTree(OutputManager::header)->Fill();
 
   // Save all trees after looping over all events
   std::vector< TTree* >::iterator it;
   for (it=GetTrees().begin();it!=GetTrees().end();it++){
     (*it)->AutoSave("SaveSelf");
   }
 
   // Finalize the base class
   OutputManager::Finalize();
 
   // Clean up
   input().RemoveConverters();
 
   // Write out the memory used.
   _memory.Write();
 
   // Close the output file
   CloseOutputFile();
 }

§ Initialize()

bool SimpleLoopBase::Initialize ( )

protectedvirtual

Initialize the input manager etc, and calls the derived version of the function. Called before any spills are read.

Reimplemented from OutputManager.

Reimplemented in CreateFlatTree, and CreateMiniTree.

Definition at line 103 of file SimpleLoopBase.cxx.

                                {
 //********************************************************************
 
   // Initialize the InputManager by specifying the input type and the input file
   if (!input().Initialize(_inputFileName,_inputFileType,_cosmicMode)) return false;
 
   // Read corrections from the input file
 
   // When running over a FlatTree corrections may already exist in it.
   // It that case corrections are read from the input file (config tree) and added to the CorrectionManager. 
   // In this case each correction is stored as 
   // "appliedInInput" and "disabled", such that it is not applied twice. 
   if (!_input.InputIsOriginalTree()){
     _corrections.ReadCorrections(_inputFileName, true);
   }
 
   // Initialize the tree manager
   if (!OutputManager::Initialize()) return false;
 
   // Open the output file
   if (!OpenOutputFile(_outputFileName)) return false;
 
   // Initialize the top level algorithm
   if (!Initialize()) return false;
 
   // Print on the screen the corrections
   _corrections.DumpCorrections();
 
   //  if (input().GetChain() == 0) return;
 
   // Define the output tree
   SimpleLoopBase::DefineOutputTree();
 
   // Create and fill the "config" tree with a single entry
   FillConfigTree();
 
   return true;
 }

§ InitializeSpill()

bool SimpleLoopBase::InitializeSpill ( )

protectedvirtual

Initialize each spill, including reading it from the input file. Called before Process().

Reimplemented in CreateFlatTree, and CreateMiniTree.

Definition at line 143 of file SimpleLoopBase.cxx.

                                     {
 //********************************************************************
 
   // Initialize the tree manager
   OutputManager::InitializeEntry();
 
   // To compute the entry increment
   Int_t entry0 = _entry;
   
   // Fill the spill structure for the current spill from the input tree
   // The previous succesfully read spill is deleted internally if the current spill is OK
   bool spillOK = input().LoadSpill(_entry);
 
   // To compute the entry increment
   Int_t entry1 = _entry;
 
   // Increment the number of entries run so far
   _entry_count += entry1-entry0;
 
   // Dump info about number of entries run
   if (_entry_count%1000==0 || _entry_count == _entry_nmax)
     std::cout << "entry: " <<  _entry_count  << " of " << _entry_nmax << " (" << (100*_entry_count/_entry_nmax) << "%) --> " << _entry << std::endl;
 
   // return if the read spill is not OK
   if (!spillOK) return false;
   
   // Apply corrections
   _corrections.ApplyCorrections(input().GetCorrectedSpill());
 
   // Create a clone of the Corrected Spill
   input().MakeFinalSpill();
 
   // Record the POT for this spill
   input().IncrementPOTBySpill();
 
   // initialize the MyAnalysis spill
   if (!InitializeSpill()) return false;
 
   return true;
 }

§ Loop()

void SimpleLoopBase::Loop	(	int	nmax = `0`,
		int	imin = `0`
	)

The main event loop, which loops over all the spills, and calls Process() for each.

Definition at line 246 of file SimpleLoopBase.cxx.

                                           {
 //********************************************************************
   
   if (!SimpleLoopBase::Initialize()) return;
   
   // Get the number of entries in the tree
   Long64_t nentries = _input.GetEntries();  
 
   if (imin>nentries){
     std::cout << "SimpleLoopBase::Loop(). input tree has " << nentries << " entries. You cannot start from entry " << imin << std::endl;    
     return;
   }
 
   // Compute the number of entries to be run
   if (nmax==0 || imin+nmax>nentries) _entry_nmax = nentries-imin;
   else                               _entry_nmax = nmax;
 
   // Compute the number of the last entry to be run  
   _entry_imax = _entry_imin+_entry_nmax;
 
   if (input().InputIsFlatTree())
     std::cout << "SimpleLoopBase::Loop(). input tree has " << nentries << " entries for " << input().header().GetPOT() << " good POT" << std::endl;
   else
     std::cout << "SimpleLoopBase::Loop(). input tree has " << nentries << " entries (POT counted on the fly)" << std::endl;
   std::cout << "SimpleLoopBase::Loop(). loop over " << _entry_nmax << " entries from entry number "<< _entry_imin << std::endl;
 
   // Initialize clock
   timeval tim;
   gettimeofday(&tim, NULL);
   double t0=tim.tv_sec+(tim.tv_usec/1000000.0);
 
   //--------- Loop over entries in the tree ----------------------------------
   _entry=_entry_imin;
 
   while (_entry<_entry_imax) {
     if (!SimpleLoopBase::InitializeSpill()) continue;    
     Process();      
     SimpleLoopBase::FinalizeSpill();
   }
   SimpleLoopBase::Finalize();
 
   gettimeofday(&tim, NULL);
   double t1=tim.tv_sec+(tim.tv_usec/1000000.0);
   
   std::cout << "--------- time profile --------------" << std::endl;
   std::cout << _entry_nmax << " entries processed in " << t1-t0 << " seconds" << std::endl;    
 
 }

§ Process()

virtual bool SimpleLoopBase::Process ( )

protectedpure virtual

The main function that should be overridden in the derived class. Called once for each spill, after it has been read in from the input file. The current spill can be accessed using ND::input().GetSpill().

Implemented in CreateFlatTree, and CreateMiniTree.

Member Data Documentation

§ _cosmicMode

bool SimpleLoopBase::_cosmicMode

protected

Whether to run in "cosmics" mode, where all the tracks are saved in a single bunch.

Definition at line 81 of file SimpleLoopBase.hxx.

§ _inputFileType

std::string SimpleLoopBase::_inputFileType

protected

Input file type. The file type is now found automatically, so this is deprecated.

Definition at line 74 of file SimpleLoopBase.hxx.

The documentation for this class was generated from the following files:

/hep/T2K/nd280rep/ANALYSIS/HIGHLAND2/ANAPARTICLE/highland2/highlandCore/v2r10/src/SimpleLoopBase.hxx
/hep/T2K/nd280rep/ANALYSIS/HIGHLAND2/ANAPARTICLE/highland2/highlandCore/v2r10/src/SimpleLoopBase.cxx

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

§ Execute()

§ Finalize()

§ Initialize()

§ InitializeSpill()

§ Loop()

§ Process()

Member Data Documentation

§ _cosmicMode

§ _inputFileType