AnalysisLoop Class Reference

#include <AnalysisLoop.hxx>

Public Member Functions
	AnalysisLoop (AnalysisAlgorithm *ana, int argc, char *argv[])
	Constructor which parses and sanity checks the command line options.
void	Loop (int nmax=0, int imin=0)
void	Execute ()
void	SetEvent (AnaEventC *event)

Protected Member Functions
bool	Initialize ()
void	Finalize ()
bool	InitializeSpill ()
void	FinalizeSpill ()
void	InitializeBunch ()
void	FinalizeBunch ()
void	InitializeConfiguration ()
bool	FinalizeConfiguration ()
void	InitializeToy ()
bool	FinalizeToy ()
	Called after each toy experiment is complete.
void	InitializeSelection (const SelectionBase &sel)
void	FinalizeSelection (const SelectionBase &sel)
bool	Process (SelectionBase &selec)
void	DefineCorrections ()
	Define the corrections to be applied.
void	DefineConfigurations ()
	Define the configurations (micro-trees) and which systematics should be applied in each "configuration".
void	DefineMicroTrees ()
	Define the variables that should be stored in the output micro-trees.
void	DefineTruthTree ()
	Define the "truth" tree. See FillTruthTree().
void	FillCategories ()
void	FillMicroTrees ()
	Fill the standard configurations trees: More...
void	FillToyVarsInMicroTrees ()
	Fill the standard configurations only toy-dependent variables.
void	PrintUsage (const std::string &programName)
	More...
AnalysisAlgorithm &	ana ()
void	FillHeaderTree ()
	Fill the "header" tree, which includes POT information etc.
void	FillConfigTree ()
	Fill the "config" tree, which includes details of the analysis cuts etc.

Protected Attributes
Long64_t	_entry
	Fill the "truth" tree. More...
std::string	_inputFileName
	Path to the input file, as defined by the user.
std::string	_inputFileType
std::string	_outputFileName
	What to call the output file, as defined by the user.
std::string	_inputSkimFileName
	Path to the file with the list of events to skim, as defined by the user.
bool	_enableTruthTree
	Whether the "truth" tree should be filled. See FillTruthTree().
bool	_cosmicMode
bool	_versionCheck
	Check version compatibility between nd280AnalysisTools compilation and oaAnalysis file.
bool	_fillTrees
	Whether to fill the trees and create an output file or not.
MemoryUsage	_memory
	Tools for tracking memory usage.
AnaEventC *	_event

Detailed Description

This class is a base class for analyses.

It specifies the interface that analyses should conform to, although user analyses should inherit from baseAnalysis, not AnalysisLoop directly. baseAnalysis implements all the required functions, so the user doesn't have to implement all the functions themselves.

The class also contains the low-level functionality for running the analysis, including the all-important Loop function.

Definition at line 17 of file AnalysisLoop.hxx.

Member Function Documentation

Execute()

void AnalysisLoop::Execute

(

)

Simply calls Loop with the appropriate parameters as read from the command line.

Definition at line 1333 of file AnalysisLoop.cxx.

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

FillCategories()

void AnalysisLoop::FillCategories ( )

protected

Fill the track categories for color drawing. There is a definition in baseAnalysis, and the user can specify their own if they have defined their own custom categories.

FillMicroTrees()

void AnalysisLoop::FillMicroTrees ( )

protected

Fill the standard configurations trees:

Fill the truth tree. The truth tree is designed to contain information about all true signal events, including those that the analysis didn't select as signal.

The derived version should fill the relevant variables, and return whether the tree should be written or not. The derived function is only called once per spill!

Definition at line 1173 of file AnalysisLoop.cxx.

                                 {
//********************************************************************

  // Fill the entry number in the input tree
  ana().output().FillVar(AnalysisAlgorithm::entry, (int) _entry);

  // Fill the tree for the current configuration provided the true codes for color drawing
  std::map< std::string, TrackCategoryDefinition* >::iterator it;
  Int_t categ_index = AnalysisAlgorithm::firstCategory;
  for (it=ana().cat().GetCategories().begin();it!=ana().cat().GetCategories().end();it++, categ_index++ ){
    std::string categ_name = it->first;
    TrackCategoryDefinition& categ = *(it->second);
    if (categ.IsMultiType()){
      for (unsigned int i=0;i<categ.GetNTypes();i++)
         ana().output().FillVectorVar(categ_index, (int)ana().cat().CheckCategoryType(categ_name,i),i);
    }
    else ana().output().FillVar(categ_index, ana().cat().GetCode(categ_name));
  }

  // reference toy
  ana().output().FillVar(AnalysisAlgorithm::toy_ref, ana().conf().GetCurrentConfiguration()->GetRefToyIndex());

  // Call the derive classes functions
  ana().SetAnalysisPoint(AnalysisAlgorithm::kFillMicroTrees);
  ana().FillMicroTrees();

  // Call the base class function and actually fills the tree
  // (fill the toy configuration variables: toy_index, toy_weight)
  ana().output().FillMicroTrees();
}

Finalize()

void AnalysisLoop::Finalize ( )

protected

Called after all processing is complete. Cleans up, then writes to and closes the output file.

Definition at line 500 of file AnalysisLoop.cxx.

                           {
//********************************************************************

  // Finalize the derived class
  ana().SetAnalysisPoint(AnalysisAlgorithm::kFinalize);
  ana().Finalize();

  // Create and fill the header tree with a single entry
  if (_fillTrees) {
    FillHeaderTree();

    // Save all trees after looping over all events
    std::vector< TTree* >::iterator it;
    for (it=ana().output().GetTrees().begin();it!=ana().output().GetTrees().end();it++){
      (*it)->AutoSave("SaveSelf");
    }

    // Write out memory usage, if needed.
    _memory.Write();

    // Close the output file
    ana().output().CloseOutputFile();
  }
}

FinalizeBunch()

void AnalysisLoop::FinalizeBunch ( )

protected

Called after each bunch is finished, simply calling the user's derived version.

Definition at line 449 of file AnalysisLoop.cxx.

                                {
//********************************************************************

  // The PreviousToyBox must be Reset after processing one event (all toys)
  ana().sel().FinalizeEvent(*_event);

  // Derived classes
  ana().SetAnalysisPoint(AnalysisAlgorithm::kFinalizeBunch);
  ana().FinalizeBunch();

  // Delete the event
  delete _event;
}

FinalizeConfiguration()

bool AnalysisLoop::FinalizeConfiguration ( )

protected

Fill the tree for this bunch, including the "truth" tree if it is enabled. The derived version should fill any variabled in the micro-tree that don't depend on the exact analysis.

Definition at line 409 of file AnalysisLoop.cxx.

                                        {
//********************************************************************

  // Delete the array for systematics weights. Will create a new one in InitializeConfiguration (TODO)
  if (_weightSyst) delete [] _weightSyst;
  _weightSyst = NULL;

  // Delete the SystBox for the current event
  if (_event->GetIsMC() && ana().evar().GetNEnabledEventVariations()>0)
    ana().evar().FinalizeEvent(*_event);

  // Delete the SystBox for the current event
  if (_event->GetIsMC() && ana().eweight().GetNEnabledEventWeights()>0)
    ana().eweight().FinalizeEvent(*_event);

  // Finalize the configuration for the User AnalysisAlgorithm
  ana().SetAnalysisPoint(AnalysisAlgorithm::kFinalizeConfiguration);
  if (!ana().FinalizeConfiguration()) return false;

  // When requested fill the tree only for events that pass the selection at least for one of the toys
  // conf_passed is true when at least one of the toys passes the selection
  if (!_fillTrees ||  (!_conf_passed && ana().GetFillSuccessOnly())) return true;

  // Only fill the tree for events that pass a given cut
  if (!ana().CheckAccumLevelToSave()) return false;

  // Reset the categories for the current track
  ana().cat().ResetCurrentCategories();

  // Fill categories for color drawing for the current track
  ana().SetAnalysisPoint(AnalysisAlgorithm::kFillCategories);
  ana().FillCategories();

  // Fill all micro-trees (main trees for analysis)
  FillMicroTrees();

  return true;
}

FinalizeSelection()

void AnalysisLoop::FinalizeSelection ( const SelectionBase &  sel )

protected

Compute the weight for this selection by applying the systematic weights. Only for MC when any of the weight systematics is enabled,

Definition at line 357 of file AnalysisLoop.cxx.

                                                              {
//********************************************************************

  /// Compute the weight for this selection by applying the systematic weights. Only for MC when any of the weight systematics is enabled,
  // and when the selection was passed. TODO: now that this is not only a systematic it could be also used for data
  if (_toy_passed && _event->GetIsMC() && ana().eweight().GetNEnabledEventWeights()>0){      
    // Get the current Toy Experiment
    ToyExperiment* toy = ana().conf().GetCurrentConfiguration()->GetToyMaker().GetToyExperiment(ana().conf().GetToyIndex());
    // Apply the relevant weight systematics for the current selection. Internally loops over branches in the selection and compute the weights only 
    // for the succesfull branches
    ana().eweight().ComputeEventWeights(selec,*toy, *_event, selec.GetPreviousToyBox(*_event), _weightSyst);
  }

  // finalize selection for the user analysis. TODO: currently not used by any analysis.
  ana().SetAnalysisPoint(AnalysisAlgorithm::kFinalizeSelection);
  ana().FinalizeSelection(selec);       
}

FinalizeSpill()

void AnalysisLoop::FinalizeSpill ( )

protected

Called after each spill is finished. Calls the user's derived version before deleting the current active Spill in the InputManager.

Definition at line 464 of file AnalysisLoop.cxx.

                                {
//********************************************************************

  if (_fillTrees){

    // Fill only the truth tree
    ana().output().SetFillSingleTree(OutputManager::truth);
    ana().output().SetCurrentTree(OutputManager::truth);

    // call the derived class function
    ana().SetAnalysisPoint(AnalysisAlgorithm::kFillTruthTree);
    ana().FillTruthTree();

    // Fill all trees
    ana().output().SetFillAllTrees();

    // Finalize the derived class
    ana().SetAnalysisPoint(AnalysisAlgorithm::kFinalizeSpill);
    ana().FinalizeSpill();

    _memory.LogMemory();

    // Save all trees every NENTRIES_TREESAVE
    if (_entry%NENTRIES_TREESAVE == 0){
      std::vector< TTree* >::iterator it;
      for (it=ana().output().GetTrees().begin();it!=ana().output().GetTrees().end();it++){
        (*it)->AutoSave("SaveSelf");
      }
    }
  }
  // delete Spill, CorrectedSpill and RawSpill
  ana().input().DeleteSpill();

}

Initialize()

bool AnalysisLoop::Initialize ( )

protected

Initialize the entire analysis. Calls the Initialize() function in the user's derived class as part of the initialization.

Definition at line 152 of file AnalysisLoop.cxx.

                             {
//********************************************************************

  // Define the InputConverters. This must be called before the InputManager is initialized
  ana().SetAnalysisPoint(AnalysisAlgorithm::kDefineInputConverters);
  ana().DefineInputConverters();

  // Define Productions
  ana().SetAnalysisPoint(AnalysisAlgorithm::kDefineProductions);
  ana().DefineProductions();

  // Set the skim file name
  anaUtils::skimFileName = _inputSkimFileName;
  
  // Initialize the InputManager by specifying the input type and the input file
  if (!ana().input().Initialize(_inputFileName,_inputFileType, _cosmicMode)) return false;

  // Tell the AnalysisAlgorithm to perform version checking to make sure the sofware version and the input file match each other
  ana().SetVersionCheck(_versionCheck);

  // Initialize the User Analysis Algorithm. It can overwride the production via parameters file in baseAnalysis 
  ana().SetAnalysisPoint(AnalysisAlgorithm::kInitialize);
  if (!ana().Initialize()) return false;

  // This will take care of data/MC differences in detector volumes definitions          
  // Should be applied after the version has been defined
  // TODO. Moved temporarily to baseAnalysis.cxx to avoid dependency on psycheND280Utils
  //  ND::hgman().InitializeGeometry(ana().input().GetIsMC()); 

  // Initialise the Output Manager. 
  ana().output().Initialize();

  // Open the output file
  if (_fillTrees)
    if (!ana().output().OpenOutputFile(_outputFileName)) return false;

  //  if (ana().input().GetChain() == 0) return;

  // Define the Corrections
  DefineCorrections();

  // Define the selection (s)
  ana().SetAnalysisPoint(AnalysisAlgorithm::kDefineSelections);
  ana().DefineSelections();

  // Initialize the Selections (create the ToyBox)
  ana().sel().CreateToyBoxArray(_entry_nmax);

  // Define the Systematics
  ana().SetAnalysisPoint(AnalysisAlgorithm::kDefineSystematics);
  ana().DefineSystematics();

  // Define the configurations
  DefineConfigurations();
  
  // Define the micro tree variables
  if (_fillTrees)
    DefineMicroTrees();

  // Define the "truth tree" variables
  if (_enableTruthTree && _fillTrees)
    DefineTruthTree();

  // Create and fill the "config" tree with a single entry
  if (_fillTrees)
    FillConfigTree();

  // Fill allways the event summary even when the selection is not passed
  ana().sel().SetForceFillEventSummary(true);

  return true;
}

InitializeBunch()

void AnalysisLoop::InitializeBunch ( )

protected

Initialize each bunch of each spill, simply calling the user's derived version.

Definition at line 273 of file AnalysisLoop.cxx.

                                  {
//********************************************************************
  
  // Create the event from the spill and the current bunch (needed by psyche packages)
  _event = ana().MakeEvent();
  ana().SetEvent(_event);

  // Create and fill the EventBox for the current event
  ana().sel().InitializeEvent(*_event);

  // Initialize the Bunch in the User Analysis Algorithm
  ana().SetAnalysisPoint(AnalysisAlgorithm::kInitializeBunch);
  ana().InitializeBunch();  
}

InitializeConfiguration()

void AnalysisLoop::InitializeConfiguration ( )

protected

Initialize each configuration for each bunch. The current active configuration should already have been changed by Loop().

Definition at line 289 of file AnalysisLoop.cxx.

                                          {
//********************************************************************

  // Initialize the tree associated to the current configuration (put all variables to the default value)
  if (_fillTrees)
    ana().output().InitializeTree(ana().output().GetCurrentTree(), ana().GetInitializeTrees());

  if (ana().evar().HasEventVariations()){
    // Enable the appropriate EventVariations for this configuration
    ana().evar().DisableAllEventVariations();
    ana().evar().EnableEventVariations(ana().conf().GetEnabledEventVariations());
        
    // Create the SystBox array (only the first time it is called for each EventVariation)
    ana().evar().Initialize(_entry_nmax);
    
    // Initialize The SystBox for EventVariations
    ana().evar().InitializeEvent(ana().sel(),*_event);
  }    

  if (ana().eweight().HasEventWeights()){
    // Enable the appropriate EventWeights for this configuration
    ana().eweight().DisableAllEventWeights();
    ana().eweight().EnableEventWeights(ana().conf().GetEnabledEventWeights());
    
    // Create an array to store the systematics weights. (TODO. Is it faster to just resize the existing array ?)
    _nWeightSyst= ana().eweight().GetNEnabledEventWeights();
    anaUtils::CreateArray(_weightSyst, _nWeightSyst);
    
    // Create the SystBox array (only the first time it is called for each EventWeight)
    ana().eweight().Initialize(ana().sel(),_entry_nmax);
    
    // Initialize The SystBox for variation systematics
    ana().eweight().InitializeEvent(ana().sel(),*_event);
  }    

  // Initialize the Configuration in the User Analysis Algorithm
  ana().InitializeConfiguration();
}

InitializeSpill()

bool AnalysisLoop::InitializeSpill ( )

protected

Initialize each spill, including reading it from the input file, and applying any corrections specified by the user. Calls the user's derived version after applying the corrections.

Definition at line 226 of file AnalysisLoop.cxx.

                                  {
//********************************************************************

  // Initialize the OutputManager (TODO)
  if (_fillTrees)
    ana().output().InitializeEntry();

  // Initialize the truth tree (which does not belong to any configuration)
  if (_fillTrees)
    ana().output().InitializeTree(OutputManager::truth);

  // To compute the entry increment
  Int_t entry0 = _entry;
  
  // Fill the spill structure for the current spill from the input tree
  bool spillOK = ana().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. This will affect all configurations
  ana().corr().ApplyCorrections(ana().input().GetCorrectedSpill());

  // Create a clone of the Corrected Spill
  ana().input().MakeFinalSpill();

  // Record the POT for this spill
  ana().input().IncrementPOTBySpill();

  // initialize the spill in the User Analysis Algorithm
  ana().SetAnalysisPoint(AnalysisAlgorithm::kInitializeSpill);
  if (!ana().InitializeSpill()) return false;

  return true;
}

InitializeToy()

void AnalysisLoop::InitializeToy ( )

protected

Initialize each toy experiment for each configuration, including applying any systematic variations. The user's derived version is called after variations have been applied.

Definition at line 329 of file AnalysisLoop.cxx.

                                {
//********************************************************************

  // Apply variation systematics. Only for MC. TODO: now that this is not only a systematic it could be also used for data
  if (_event->GetIsMC() && ana().evar().GetNEnabledEventVariations()>0){

    // Get the current Toy Experiment
    ToyExperiment* toy = ana().conf().GetCurrentConfiguration()->GetToyMaker().GetToyExperiment(ana().conf().GetToyIndex());

    // Apply  systematic variations for systematic error propagation
    ana().evar().ApplyEventVariations(*toy, *_event);
  }

  // Initialize this toy experiment for the user Analysis Algorithm
  ana().SetAnalysisPoint(AnalysisAlgorithm::kInitializeToy);
  ana().InitializeToy();        
}

Loop()

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

This is the main looping function that controls the analysis. It initializes the analysis, then loops over

• Spills in the input file
  • Bunches in each spill
    • Configurations for each bunch (which sets of systematics to apply)
      • toy experiments for each configuration (the MC throws for each systematic)
        • Call the user's Process() function.

Definition at line 957 of file AnalysisLoop.cxx.

                                        {
//********************************************************************
  
  if (!Initialize()) return;
  
  // Get the number of entries in the tree
  Long64_t nentries = ana().input().GetEntries();  

  if (imin>nentries){
    std::cout << "AnalysisLoop::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 (ana().input().InputIsFlatTree())
    std::cout << "AnalysisLoop::Loop(). input tree has " << nentries << " entries for " << ana().input().header().GetPOT() << " good POT" << std::endl;
  else
    std::cout << "AnalysisLoop::Loop(). input tree has " << nentries << " entries (POT counted on the fly)" << std::endl;
  std::cout << "AnalysisLoop::Loop(). loop over " << _entry_nmax << " entries from entry number "<< _entry_imin << std::endl;

  double delta_t[20]={0};

  //--------- Loop over entries in the tree ----------------------------------
  _entry=_entry_imin;
  while (_entry<_entry_imax) {

    // Initialize clock
    timeval tim;
    gettimeofday(&tim, NULL);
    double t0=tim.tv_sec+(tim.tv_usec/1000000.0);

    // Fills the full Spill structure (it could imply reading several entries in input tree)
    bool spillOK = InitializeSpill();

    // Break the loop (at the moment only for skimmed events, when the last interesting event is processed)
    if (anaUtils::breakLoop) break;

    // go to the next spill if this one is not OK
    if (!spillOK) continue;
    
    gettimeofday(&tim, NULL);
    double t1=tim.tv_sec+(tim.tv_usec/1000000.0);

    delta_t[0] += t1-t0;

    //---- For each Spill loop over Bunches ----
    for (unsigned int ibunch=0;ibunch<ana().input().GetSpill().Bunches.size();ibunch++){
      gettimeofday(&tim, NULL);
      double t2=tim.tv_sec+(tim.tv_usec/1000000.0);

      ana().input().SetCurrentBunch(ibunch);
      InitializeBunch();

      gettimeofday(&tim, NULL);
      double t3=tim.tv_sec+(tim.tv_usec/1000000.0);


      delta_t[1] += t3-t2;


      //---- For each bunch loop over configurations ----     
      for (std::vector<ConfigurationBase*>::iterator it= ana().conf().GetConfigurations().begin();it!=ana().conf().GetConfigurations().end();it++){
        ConfigurationBase* conf = *it;

        gettimeofday(&tim, NULL);
        double t4=tim.tv_sec+(tim.tv_usec/1000000.0);
        
        if (!conf->IsEnabled()) continue;
        ana().conf().SetCurrentConfigurationIndex(conf->GetIndex());
        ana().output().SetCurrentTree(conf->GetTreeIndex());
        InitializeConfiguration();      

        gettimeofday(&tim, NULL);
        double t5=tim.tv_sec+(tim.tv_usec/1000000.0);
        
        delta_t[2] += t5-t4;
        
        _conf_passed=false;
        
        //---- For each configuration loop over toys --------
        for (int n=0;n<conf->GetNToys();n++){
          
          gettimeofday(&tim, NULL);
          double t6=tim.tv_sec+(tim.tv_usec/1000000.0);

          ana().conf().SetToyIndex(n);
          ana().output().SetToyIndex(n);
          InitializeToy();

          gettimeofday(&tim, NULL);
          double t7=tim.tv_sec+(tim.tv_usec/1000000.0);
          
          delta_t[3] += t7-t6;

          //---- For each toy loop over selections --------
          for (std::vector<SelectionBase*>::iterator sit= ana().sel().GetSelections().begin();sit!=ana().sel().GetSelections().end();sit++){
            SelectionBase& selec = **sit;
            if (!selec.IsEnabled()) continue;                            
            gettimeofday(&tim, NULL);
            double t8=tim.tv_sec+(tim.tv_usec/1000000.0);

            InitializeSelection(selec);

            gettimeofday(&tim, NULL);
            double t9=tim.tv_sec+(tim.tv_usec/1000000.0);

            delta_t[4] += t9-t8;

            _toy_passed = Process(selec);      

            gettimeofday(&tim, NULL);
            double t10=tim.tv_sec+(tim.tv_usec/1000000.0);

            delta_t[5] += t10-t9;

            FinalizeSelection(selec);

            gettimeofday(&tim, NULL);
            double t11=tim.tv_sec+(tim.tv_usec/1000000.0);


            delta_t[6] += t11-t10;
            if (_toy_passed) _conf_passed=true;            
          }

          gettimeofday(&tim, NULL);
          double t12=tim.tv_sec+(tim.tv_usec/1000000.0);

          if (!FinalizeToy()) break; 
          
          gettimeofday(&tim, NULL);
          double t13=tim.tv_sec+(tim.tv_usec/1000000.0);
          
          delta_t[7] += t13-t12;
          
        }
        
        gettimeofday(&tim, NULL);
        double t14=tim.tv_sec+(tim.tv_usec/1000000.0);
        
        FinalizeConfiguration();
        
        gettimeofday(&tim, NULL);
        double t15=tim.tv_sec+(tim.tv_usec/1000000.0);
        
        delta_t[8] += t15-t14;
      }      
      gettimeofday(&tim, NULL);
      double t16=tim.tv_sec+(tim.tv_usec/1000000.0);

      FinalizeBunch();

      gettimeofday(&tim, NULL);
      double t17=tim.tv_sec+(tim.tv_usec/1000000.0);

      delta_t[9] += t17-t16;
    }
    gettimeofday(&tim, NULL);
    double t18=tim.tv_sec+(tim.tv_usec/1000000.0);
    FinalizeSpill();
    gettimeofday(&tim, NULL);
    double t19=tim.tv_sec+(tim.tv_usec/1000000.0);

    delta_t[10] += t19-t18;

    delta_t[11] += t19-t0;
  }

  for (Int_t i=0;i<11;i++)
    delta_t[12] += delta_t[i];


  std::cout << "time profile --------------" << std::endl;
  std::cout << "Ini Spill:        " << delta_t[0] << std::endl;    
  std::cout << "Ini Bunch:        " << delta_t[1] << std::endl;    
  std::cout << "Ini Conf:         " << delta_t[2] << std::endl;    
  std::cout << "Ini Toy (v syst): " << delta_t[3] << std::endl;    
  std::cout << "Ini Sel:          " << delta_t[4] << std::endl;    
  std::cout << "Selection:        " << delta_t[5] << std::endl;    
  std::cout << "End Sel (w syst): " << delta_t[6] << std::endl;    
  std::cout << "End Toy:          " << delta_t[7] << std::endl;    
  std::cout << "End Conf:         " << delta_t[8] << std::endl;    
  std::cout << "End Bunch:        " << delta_t[9] << std::endl;    
  std::cout << "End Spill:        " << delta_t[10] << std::endl;   
  std::cout << "Total:            " << delta_t[11] << std::endl;   
  std::cout << "Total wo t:       " << delta_t[12] << std::endl;       



  Finalize();
}

PrintUsage()

void AnalysisLoop::PrintUsage ( const std::string &  programName )

protected

---

Simple usage statement, for if the user gave bad command line options.

Definition at line 1315 of file AnalysisLoop.cxx.

                                                         {
//********************************************************************
  std::cout << "usage: " << programName << " [options] [input-file]" << std::endl;
  std::cout << std::endl;
  std::cout << "Options:" << std::endl;
  std::cout << "    -c                Run in cosmics mode, putting all tracks in one 'bunch'" << std::endl;
  std::cout << "    -o <file>         Set the name of an output file (mandatory)" << std::endl;
  std::cout << "    -n <cnt>          Only read <cnt> events" << std::endl;
  std::cout << "    -s <cnt>          Skip <cnt> events" << std::endl;
  std::cout << "    -e <file>         Set the name of file containing events to skim (format: run subrun event)" << std::endl;
  std::cout << "    -p <file>         Set the name of a parameter override file" << std::endl;
  std::cout << "    -v                Don't Check version compatibility between nd280AnalysisTools and oaAnalysis file" << std::endl;
  std::cout << "    -r                Don't fill any trees and don't create an output file (mainly for speed tests)" << std::endl;
  std::cout << "    -m                Dumps on the screen the memory usage" << std::endl;
  std::exit(1);
}

Process()

bool AnalysisLoop::Process ( SelectionBase &  selec )

protected

The main function called to run the analysis. The derived version should apply any cuts, and return whether the current active bunch passed the cuts or not.

Definition at line 1156 of file AnalysisLoop.cxx.

                                              {
//********************************************************************

  // Returns true when any of the branches is passed
  // Internaly the CheckRedoSelection is called. The returned boolean is returned as argument 
  // by the Apply method of the selection such that we can save the redo value in the micro-tree
  bool redo = false;
  bool ToyPassed = selec.Apply(*_event, redo);

  // fill a variable saying if selection was  redone for this toy experiment
  if (_fillTrees)
    ana().output().FillToyVar(AnalysisAlgorithm::redo, (int)redo);

  return ToyPassed;
}

Member Data Documentation

_cosmicMode

bool AnalysisLoop::_cosmicMode

protected

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

Definition at line 166 of file AnalysisLoop.hxx.

_entry

Long64_t AnalysisLoop::_entry

protected

Fill the "truth" tree.

The number of entries we have read in.

Definition at line 146 of file AnalysisLoop.hxx.

_inputFileType

std::string AnalysisLoop::_inputFileType

protected

This was used when the user could specify what type of input file they had provided. Now this is done automatically.

Definition at line 153 of file AnalysisLoop.hxx.

---

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

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