AnalysisHandler Class Reference

#include <AnalysisHandler.hh>

Collaboration diagram for AnalysisHandler:

Collaboration graph
[legend]

List of all members.

Detailed Description

A class which handles a number of analysis objects to be applied to generated events. An Analysis' AnalysisHandler is also responsible for handling the final writing-out of histograms.

Definition at line 18 of file AnalysisHandler.hh.


Public Member Functions

Standard constructors and destructors. */
 AnalysisHandler (AIDA::IAnalysisFactory &afac, string basefilename="Rivet", string runname="", HistoFormat storetype=AIDAML)
 AnalysisHandler (string basefilename="Rivet", string runname="", HistoFormat storetype=AIDAML)
 Make a Rivet handler with a set base filename and store type.
 ~AnalysisHandler ()
 The destructor is not virtual as this class should not be inherited from.
Run properties
string runName () const
 Get the name of this run.
size_t numEvents () const
double sumOfWeights () const
void setSumOfWeights (const double &sum)
bool needCrossSection () const
 Is cross-section information required by at least one child analysis?
AnalysisHandler & setCrossSection (double xs)
 Set the cross-section for the process being generated.
double crossSection () const
 Get the cross-section known to the handler.
bool hasCrossSection () const
 Whether the handler knows about a cross-section.
AnalysisHandler & setRunBeams (const ParticlePair &beams)
 Set beams for this run.
const ParticlePair & beams () const
 Get beam IDs for this run, determined from first event.
BeamPair beamIds () const
 Get beam IDs for this run, determined from first event.
double sqrtS () const
 Get energy for this run, determined from first event.
Handle analyses
std::vector< std::string > analysisNames () const
 Get a list of the currently registered analyses' names.
const std::set< Analysis * > & analyses () const
 Get a list of the currently registered analyses' names.
AnalysisHandler & addAnalysis (const std::string &analysisname)
AnalysisHandler & removeAnalysis (const std::string &analysisname)
 Remove an analysis from the run list using its name.
AnalysisHandler & addAnalyses (const std::vector< std::string > &analysisnames)
AnalysisHandler & removeAnalyses (const std::vector< std::string > &analysisnames)
 Remove analyses from the run list using their names.
AnalysisHandler & addAnalysis (Analysis *analysis)
 Add an analysis to the run list by object.
AnalysisHandler & removeIncompatibleAnalyses (const BeamPair &beams)
Main init/execute/finalise
void init ()
void init (const GenEvent &event)
 Initialize a run, with the run beams taken from the example event.
void analyze (const GenEvent &event)
void finalize ()
AIDA factories etc.
Deprecated:
All this will be removed when histogramming is overhauled


AIDA::IAnalysisFactory & analysisFactory ()
 The AIDA analysis factory.
void commitData ()
 Commit the AIDA tree to file.
AIDA::ITree & tree ()
 The AIDA tree object.
AIDA::IHistogramFactory & histogramFactory ()
 The AIDA histogram factory.
AIDA::IDataPointSetFactory & datapointsetFactory ()
 The AIDA histogram factory.

Private Member Functions

void _setupFactories (string basefilename, HistoFormat storetype)
 Do the initialisation of the AIDA analysis factories.
void _normalizeTree (AIDA::ITree &tree)
 Convert any IHistogram1D objects in the AIDA tree to IDataPointSet objects.
Log & getLog ()
 Get a logger object.
AnalysisHandler & operator= (const AnalysisHandler &)
 AnalysisHandler (const AnalysisHandler &)

Private Attributes

set< Analysis * > _analyses
 The collection of Analysis objects to be used.
Run properties
std::string _runname
 Run name.
size_t _numEvents
 Number of events seen.
double _sumOfWeights
 Sum of event weights seen.
double _xs
 Cross-section known to AH.
ParticlePair _beams
 Beams used by this run.
bool _initialised
 Flag to check if init has been called.
AIDA factory handles
AIDA::IAnalysisFactory * _theAnalysisFactory
 The AIDA analysis factory.
AIDA::ITree * _theTree
 The AIDA tree object.
AIDA::IHistogramFactory * _theHistogramFactory
 The AIDA histogram factory.
AIDA::IDataPointSetFactory * _theDataPointSetFactory
 The AIDA data point set factory.

Constructor & Destructor Documentation

AnalysisHandler ( AIDA::IAnalysisFactory &  afac,
string  basefilename = "Rivet",
string  runname = "",
HistoFormat  storetype = AIDAML 
)

The standard constructor.

Parameters:
basefilename the name of the file (no extension) where histograms are to be stored.
runname optional name of this run, prepended to AIDA data paths.
storetype a string indicating to the AIDA analysis factory how to store the histograms. Which strings are allowed depends on actual AIDA implementation used. To output in standard AIDA XML the string is typically "xml".
afac an AIDA analysis factory object. The caller must make sure that the lifetime of the factory object exceeds the AnalysisHandler object.

AnalysisHandler ( string  basefilename = "Rivet",
string  runname = "",
HistoFormat  storetype = AIDAML 
)

Make a Rivet handler with a set base filename and store type.

Definition at line 16 of file AnalysisHandler.cc.

References AnalysisHandler::_setupFactories(), AnalysisHandler::_theAnalysisFactory, and Rivet::createAnalysisFactory().

00018     : _runname(runname), _numEvents(0), 
00019       _sumOfWeights(0.0), _xs(-1.0), _initialised(false)
00020   {
00021     _theAnalysisFactory = createAnalysisFactory();
00022     _setupFactories(basefilename, storetype);
00023   }

~AnalysisHandler (  ) 

The destructor is not virtual as this class should not be inherited from.

Definition at line 36 of file AnalysisHandler.cc.

00037   {  }

AnalysisHandler ( const AnalysisHandler &   )  [private]

The copy constructor is private and must never be called. In fact, it should not even be implemented.

Member Function Documentation

void _setupFactories ( string  basefilename,
HistoFormat  storetype 
) [private]

Do the initialisation of the AIDA analysis factories.

Definition at line 194 of file AnalysisHandler.cc.

References AnalysisHandler::_theAnalysisFactory, AnalysisHandler::_theDataPointSetFactory, AnalysisHandler::_theHistogramFactory, AnalysisHandler::_theTree, Rivet::AIDAML, Rivet::endsWith(), Rivet::FLAT, Rivet::ROOT, and AnalysisHandler::tree().

Referenced by AnalysisHandler::AnalysisHandler().

00194                                                                                   {
00195     string filename(basefilename), storetypestr("");
00196     if (storetype == AIDAML) {
00197       if (!endsWith(filename, ".aida")) filename += ".aida";
00198       storetypestr = "xml";
00199     } else if (storetype == FLAT) {
00200       if (!endsWith(filename, ".data")) filename += ".data";
00201       storetypestr = "flat";
00202     } else if (storetype == ROOT) {
00203       if (!endsWith(filename, ".root")) filename += ".root";
00204       storetypestr = "root";
00205     }
00206     _theTree = _theAnalysisFactory->createTreeFactory()->create(filename, storetypestr, false, true);
00207     _theHistogramFactory = _theAnalysisFactory->createHistogramFactory(tree());
00208     _theDataPointSetFactory = _theAnalysisFactory->createDataPointSetFactory(tree());
00209   }

void _normalizeTree ( AIDA::ITree &  tree  )  [private]

Convert any IHistogram1D objects in the AIDA tree to IDataPointSet objects.

Referenced by AnalysisHandler::finalize().

Log & getLog (  )  [private]

Get a logger object.

Definition at line 40 of file AnalysisHandler.cc.

References Log::getLog().

Referenced by AnalysisHandler::analyze(), AnalysisHandler::finalize(), AnalysisHandler::init(), AnalysisHandler::removeIncompatibleAnalyses(), and AnalysisHandler::setRunBeams().

00040                                {
00041     return Log::getLog("Rivet.Analysis.Handler");
00042   }

string runName (  )  const

Get the name of this run.

Definition at line 270 of file AnalysisHandler.cc.

References AnalysisHandler::_runname.

Referenced by Analysis::histoDir().

00270 { return _runname; }

size_t numEvents (  )  const

Get the number of events seen. Should only really be used by external steering code or analyses in the finalize phase.

Definition at line 271 of file AnalysisHandler.cc.

References AnalysisHandler::_numEvents.

Referenced by Analysis::numEvents().

00271 { return _numEvents; }

double sumOfWeights (  )  const

Get the sum of the event weights seen - the weighted equivalent of the number of events. Should only really be used by external steering code or analyses in the finalize phase.

Definition at line 272 of file AnalysisHandler.cc.

References AnalysisHandler::_sumOfWeights.

Referenced by Analysis::sumOfWeights().

00272 { return _sumOfWeights; }

void setSumOfWeights ( const double &  sum  ) 

Set sum of weights. This is useful if Rivet is steered externally and the analyses are run for a sub-contribution of the events (but of course have to be normalised to the total sum of weights)

Definition at line 274 of file AnalysisHandler.cc.

References AnalysisHandler::_sumOfWeights.

00274                                                          {
00275     _sumOfWeights=sum;
00276   }

bool needCrossSection (  )  const

Is cross-section information required by at least one child analysis?

Definition at line 326 of file AnalysisHandler.cc.

References AnalysisHandler::_analyses, and Analysis::needsCrossSection().

Referenced by Run::processEvent().

00326                                                {
00327     bool rtn = false;
00328     foreach (const Analysis* a, _analyses) {
00329       if (!rtn) rtn = a->needsCrossSection();
00330       if (rtn) break;
00331     }
00332     return rtn;
00333   }

AnalysisHandler & setCrossSection ( double  xs  ) 

Set the cross-section for the process being generated.

Definition at line 336 of file AnalysisHandler.cc.

References AnalysisHandler::_analyses, AnalysisHandler::_xs, and Analysis::setCrossSection().

Referenced by AnalysisHandler::analyze(), Run::init(), and Run::processEvent().

00336                                                              {
00337     _xs = xs;
00338     foreach (Analysis* a, _analyses) {
00339       a->setCrossSection(xs);
00340     }
00341     return *this;
00342   }

double crossSection (  )  const [inline]

Get the cross-section known to the handler.

Definition at line 91 of file AnalysisHandler.hh.

References AnalysisHandler::_xs.

Referenced by AnalysisHandler::hasCrossSection().

00091                                 {
00092       return _xs;
00093     }

bool hasCrossSection (  )  const

Whether the handler knows about a cross-section.

Definition at line 345 of file AnalysisHandler.cc.

References AnalysisHandler::crossSection().

Referenced by Run::processEvent().

00345                                               {
00346     return (crossSection() >= 0);
00347   }

AnalysisHandler& setRunBeams ( const ParticlePair &  beams  )  [inline]

Set beams for this run.

Definition at line 100 of file AnalysisHandler.hh.

References AnalysisHandler::_beams, Log::DEBUG, AnalysisHandler::getLog(), Rivet::GeV, and AnalysisHandler::sqrtS().

Referenced by AnalysisHandler::init().

00100                                                             { 
00101       _beams = beams;
00102       getLog() << Log::DEBUG << "Setting run beams = " << beams
00103                << " @ " << sqrtS()/GeV << " GeV" << endl;
00104       return *this;
00105     }

const ParticlePair& beams (  )  const [inline]

Get beam IDs for this run, determined from first event.

Definition at line 108 of file AnalysisHandler.hh.

References AnalysisHandler::_beams.

Referenced by AnalysisHandler::analyze(), AnalysisHandler::beamIds(), Analysis::beams(), and AnalysisHandler::sqrtS().

00108                                       { 
00109       return _beams;
00110     }

BeamPair beamIds (  )  const

Get beam IDs for this run, determined from first event.

Definition at line 355 of file AnalysisHandler.cc.

References Rivet::beamIds(), and AnalysisHandler::beams().

Referenced by Analysis::beamIds(), and AnalysisHandler::init().

00355                                           { 
00356     return Rivet::beamIds(beams());
00357   }

double sqrtS (  )  const

Get energy for this run, determined from first event.

Definition at line 359 of file AnalysisHandler.cc.

References AnalysisHandler::beams(), and Rivet::sqrtS().

Referenced by AnalysisHandler::analyze(), AnalysisHandler::setRunBeams(), and Analysis::sqrtS().

00359                                       {
00360     return Rivet::sqrtS(beams());
00361   }

std::vector< std::string > analysisNames (  )  const

Get a list of the currently registered analyses' names.

Definition at line 279 of file AnalysisHandler.cc.

References AnalysisHandler::_analyses, and Analysis::name().

Referenced by Run::init(), and AnalysisHandler::init().

00279                                                             {
00280     std::vector<std::string> rtn;
00281     foreach (Analysis* a, _analyses) {
00282       rtn.push_back(a->name());
00283     }
00284     return rtn;
00285   }

const std::set<Analysis*>& analyses (  )  const [inline]

Get a list of the currently registered analyses' names.

Definition at line 128 of file AnalysisHandler.hh.

References AnalysisHandler::_analyses.

Referenced by AnalysisHandler::init().

00128                                               {
00129       return _analyses;
00130     }

AnalysisHandler& addAnalysis ( const std::string &  analysisname  ) 

Add an analysis to the run list using its name. The actual Analysis to be used will be obtained via AnalysisHandler::getAnalysis(string). If no matching analysis is found, no analysis is added (i.e. the null pointer is checked and discarded.

Referenced by AnalysisHandler::addAnalyses().

AnalysisHandler& removeAnalysis ( const std::string &  analysisname  ) 

Remove an analysis from the run list using its name.

Referenced by AnalysisHandler::removeAnalyses().

AnalysisHandler & addAnalyses ( const std::vector< std::string > &  analysisnames  ) 

Add analyses to the run list using their names. The actual Analysis' to be used will be obtained via AnalysisHandler::addAnalysis(string), which in turn uses AnalysisHandler::getAnalysis(string). If no matching analysis is found for a given name, no analysis is added, but also no error is thrown.

Definition at line 288 of file AnalysisHandler.cc.

References AnalysisHandler::addAnalysis().

00288                                                                                          {
00289     foreach (const string& aname, analysisnames) {
00290       //getLog() << Log::DEBUG << "Adding analysis '" << aname << "'" << endl;
00291       addAnalysis(aname);
00292     }
00293     return *this;
00294   }

AnalysisHandler & removeAnalyses ( const std::vector< std::string > &  analysisnames  ) 

Remove analyses from the run list using their names.

Definition at line 297 of file AnalysisHandler.cc.

References AnalysisHandler::removeAnalysis().

00297                                                                                             {
00298     foreach (const string& aname, analysisnames) {
00299       removeAnalysis(aname);
00300     }
00301     return *this;
00302   }

AnalysisHandler & addAnalysis ( Analysis *  analysis  ) 

Add an analysis to the run list by object.

Definition at line 349 of file AnalysisHandler.cc.

References AnalysisHandler::_analyses, and Analysis::_analysishandler.

00349                                                                   {
00350     analysis->_analysishandler = this;
00351     _analyses.insert(analysis);
00352     return *this;
00353   }

AnalysisHandler & removeIncompatibleAnalyses ( const BeamPair &  beams  ) 

Remove beam-incompatible analyses from the run list.

Todo:
Do this automatically in the init phase (including energies) and deprecate explicit use

Definition at line 177 of file AnalysisHandler.cc.

References AnalysisHandler::_analyses, AnalysisHandler::getLog(), Analysis::isCompatible(), Analysis::name(), and Log::WARN.

Referenced by AnalysisHandler::init().

00177                                                                                     {
00178     vector<Analysis*> todelete;
00179     foreach (Analysis* a, _analyses) {
00180       if (! a->isCompatible(beams)) {
00181         todelete.push_back(a);
00182       }
00183     }
00184     foreach (Analysis* a, todelete) {
00185       getLog() << Log::WARN << "Removing incompatible analysis '"
00186                << a->name() << "'" << endl;
00187       _analyses.erase(a);
00188       delete a;
00189     }
00190     return *this;
00191   }

void init (  )  [inline]

Deprecated:
Obsolete method, kept only for backwards compatibility

Definition at line 167 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::analyze(), and Run::init().

00167 {}

void init ( const GenEvent &  event  ) 

Initialize a run, with the run beams taken from the example event.

Definition at line 45 of file AnalysisHandler.cc.

References ProjectionApplier::_allowProjReg, AnalysisHandler::_analyses, AnalysisHandler::_initialised, AnalysisHandler::_numEvents, AnalysisHandler::_sumOfWeights, AnalysisHandler::analyses(), AnalysisHandler::analysisNames(), AnalysisHandler::beamIds(), Rivet::beams(), Log::DEBUG, Log::ERROR, AnalysisHandler::getLog(), Analysis::init(), Analysis::name(), AnalysisHandler::removeIncompatibleAnalyses(), AnalysisHandler::setRunBeams(), Analysis::status(), Rivet::toUpper(), and Log::WARN.

00045                                                {
00046     assert(!_initialised);
00047     setRunBeams(Rivet::beams(ge));
00048     getLog() << Log::DEBUG << "Initialising the analysis handler" << endl;
00049     _numEvents = 0;
00050     _sumOfWeights = 0.0;
00051     
00052     // Check that analyses are beam-compatible
00053     const size_t num_anas_requested = analysisNames().size();
00054     removeIncompatibleAnalyses(beamIds());
00055     foreach (const Analysis* a, analyses()) {
00056       if (toUpper(a->status()) != "VALIDATED") {
00057         getLog() << Log::WARN 
00058                  << "Analysis '" << a->name() << "' is unvalidated: be careful!" << endl;
00059       }
00060     }
00061     if (num_anas_requested > 0 && analysisNames().size() == 0) {
00062       getLog() << Log::ERROR
00063                << "All analyses were incompatible with the first event's beams\n"
00064                << "Exiting, since this probably isn't intentional!" << endl;
00065       exit(1);
00066     }
00067     
00068     foreach (Analysis* a, _analyses) {
00069       getLog() << Log::DEBUG << "Initialising analysis: " << a->name() << endl;
00070       // Allow projection registration in the init phase onwards
00071       a->_allowProjReg = true;
00072       a->init();
00073       //getLog() << Log::DEBUG << "Checking consistency of analysis: " << a->name() << endl;
00074       //a->checkConsistency();
00075       getLog() << Log::DEBUG << "Done initialising analysis: " << a->name() << endl;
00076     }
00077     _initialised = true;
00078     getLog() << Log::DEBUG << "Analysis handler initialised" << endl;
00079   }

void analyze ( const GenEvent &  event  ) 

Analyze the given event. This function will call the AnalysisBase::analyze() function of all included analysis objects.

Definition at line 82 of file AnalysisHandler.cc.

References AnalysisHandler::_analyses, AnalysisHandler::_beams, AnalysisHandler::_initialised, AnalysisHandler::_numEvents, AnalysisHandler::_sumOfWeights, Analysis::analyze(), Rivet::beamIds(), AnalysisHandler::beams(), Rivet::compatible(), Log::DEBUG, Log::ERROR, Rivet::fuzzyEquals(), AnalysisHandler::getLog(), Rivet::GeV, AnalysisHandler::init(), Analysis::name(), AnalysisHandler::setCrossSection(), AnalysisHandler::sqrtS(), and Rivet::sqrtS().

Referenced by Run::processEvent().

00082                                                   {
00083     // Call init with event as template if not already initialised
00084     if (!_initialised) {
00085       init(ge);
00086     }
00087     // Proceed with event analysis
00088     assert(_initialised);
00089     // Ensure that beam details match those from first event
00090     const BeamPair beams = Rivet::beamIds(ge);
00091     const double sqrts = Rivet::sqrtS(ge);
00092     if (!compatible(beams, _beams) || !fuzzyEquals(sqrts, sqrtS())) {
00093       getLog() << Log::ERROR << "Event beams mismatch: "
00094                << beams << " @ " << sqrts/GeV << " GeV" << " vs. first beams "
00095                << this->beams() << " @ " << this->sqrtS()/GeV << " GeV" << endl;
00096       exit(1);
00097     }
00098 
00099     
00100     Event event(ge);
00101     _numEvents++;
00102     // Weights
00103     const double weight = event.weight();
00104     _sumOfWeights += weight;
00105     getLog() << Log::DEBUG << "Event #" << _numEvents << " weight = " << weight << endl;
00106     #ifdef HEPMC_HAS_CROSS_SECTION
00107     if (ge.cross_section()) {
00108       const double xs = ge.cross_section()->cross_section();
00109       setCrossSection(xs);
00110     }
00111     #endif
00112     foreach (Analysis* a, _analyses) {
00113       getLog() << Log::DEBUG << "About to run analysis " << a->name() << endl;
00114       a->analyze(event);
00115       getLog() << Log::DEBUG << "Finished running analysis " << a->name() << endl;
00116     }
00117   }

void finalize (  ) 

Finalize a run. This function first calls the AnalysisBase::finalize() functions of all included analysis objects and converts all histograms to AIDA DataPointSet objects in the AIDA tree. Using the histogram tree for further analysis or writing to file is left to the API user.

Definition at line 120 of file AnalysisHandler.cc.

References AnalysisHandler::_analyses, AnalysisHandler::_initialised, AnalysisHandler::_normalizeTree(), AnalysisHandler::_numEvents, AnalysisHandler::_theTree, Log::DEBUG, Analysis::finalize(), AnalysisHandler::getLog(), Log::INFO, and AnalysisHandler::tree().

00120                                  {
00121     assert(_initialised);
00122     getLog() << Log::INFO << "Finalising analyses" << endl;
00123     foreach (Analysis* a, _analyses) {
00124       a->finalize();
00125     }
00126 
00127     // Print out number of events processed
00128     getLog() << Log::INFO << "Processed " << _numEvents << " event" << (_numEvents == 1 ? "" : "s") << endl;
00129 
00130     // Change AIDA histos into data point sets
00131     getLog() << Log::DEBUG << "Converting histograms to scatter plots" << endl;
00132     assert(_theTree != 0);
00133     _normalizeTree(tree());
00134 
00135     // Delete analyses
00136     getLog() << Log::DEBUG << "Deleting analyses" << endl;
00137     foreach (Analysis* a, _analyses) {
00138       delete a;
00139     }
00140     _analyses.clear();
00141 
00142     // Print out MCnet boilerplate
00143     cout << endl;
00144     cout << "The MCnet usage guidelines apply to Rivet: see http://www.montecarlonet.org/GUIDELINES" << endl;
00145     cout << "Please acknowledge plots made with Rivet analyses, and cite arXiv:1003.0694 (http://arxiv.org/abs/1003.0694)" << endl;
00146   }

AIDA::IAnalysisFactory & analysisFactory (  ) 

The AIDA analysis factory.

Definition at line 306 of file AnalysisHandler.cc.

References AnalysisHandler::_theAnalysisFactory.

Referenced by Analysis::analysisFactory().

00306                                                          {
00307     return *_theAnalysisFactory;
00308   }

void commitData (  ) 

Commit the AIDA tree to file.

Definition at line 212 of file AnalysisHandler.cc.

References AnalysisHandler::tree().

00212                                    {
00213     tree().commit();
00214   }

AIDA::ITree & tree (  ) 

The AIDA tree object.

Definition at line 311 of file AnalysisHandler.cc.

References AnalysisHandler::_theTree.

Referenced by AnalysisHandler::_setupFactories(), AnalysisHandler::commitData(), AnalysisHandler::finalize(), and Analysis::tree().

00311                                    {
00312     return *_theTree;
00313   }

AIDA::IHistogramFactory & histogramFactory (  ) 

The AIDA histogram factory.

Definition at line 316 of file AnalysisHandler.cc.

References AnalysisHandler::_theHistogramFactory.

Referenced by Analysis::histogramFactory().

00316                                                            {
00317     return *_theHistogramFactory;
00318   }

AIDA::IDataPointSetFactory & datapointsetFactory (  ) 

The AIDA histogram factory.

Definition at line 321 of file AnalysisHandler.cc.

References AnalysisHandler::_theDataPointSetFactory.

Referenced by Analysis::datapointsetFactory().

00321                                                                  {
00322     return *_theDataPointSetFactory;
00323   }

AnalysisHandler& operator= ( const AnalysisHandler &   )  [private]

The assignment operator is private and must never be called. In fact, it should not even be implemented.

Member Data Documentation

set<Analysis*> _analyses [private]

The collection of Analysis objects to be used.

Definition at line 217 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::addAnalysis(), AnalysisHandler::analyses(), AnalysisHandler::analysisNames(), AnalysisHandler::analyze(), AnalysisHandler::finalize(), AnalysisHandler::init(), AnalysisHandler::needCrossSection(), AnalysisHandler::removeIncompatibleAnalyses(), and AnalysisHandler::setCrossSection().

std::string _runname [private]

Run name.

Definition at line 224 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::runName().

size_t _numEvents [private]

Number of events seen.

Definition at line 227 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::analyze(), AnalysisHandler::finalize(), AnalysisHandler::init(), and AnalysisHandler::numEvents().

double _sumOfWeights [private]

Sum of event weights seen.

Definition at line 230 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::analyze(), AnalysisHandler::init(), AnalysisHandler::setSumOfWeights(), and AnalysisHandler::sumOfWeights().

double _xs [private]

Cross-section known to AH.

Definition at line 233 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::crossSection(), and AnalysisHandler::setCrossSection().

ParticlePair _beams [private]

Beams used by this run.

Definition at line 236 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::analyze(), AnalysisHandler::beams(), and AnalysisHandler::setRunBeams().

bool _initialised [private]

Flag to check if init has been called.

Definition at line 239 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::analyze(), AnalysisHandler::finalize(), and AnalysisHandler::init().

AIDA::IAnalysisFactory* _theAnalysisFactory [private]

The AIDA analysis factory.

Definition at line 248 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::_setupFactories(), AnalysisHandler::analysisFactory(), and AnalysisHandler::AnalysisHandler().

AIDA::ITree* _theTree [private]

The AIDA tree object.

Definition at line 251 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::_setupFactories(), AnalysisHandler::finalize(), and AnalysisHandler::tree().

AIDA::IHistogramFactory* _theHistogramFactory [private]

The AIDA histogram factory.

Definition at line 254 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::_setupFactories(), and AnalysisHandler::histogramFactory().

AIDA::IDataPointSetFactory* _theDataPointSetFactory [private]

The AIDA data point set factory.

Definition at line 257 of file AnalysisHandler.hh.

Referenced by AnalysisHandler::_setupFactories(), and AnalysisHandler::datapointsetFactory().

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