FactoryBase.h

// -*- C++ -*-
//
// FactoryBase.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef THEPEG_FactoryBase_H
#define THEPEG_FactoryBase_H
//
// This is the declaration of the FactoryBase class.
//

#include "ThePEG/Config/LWH.h"
#include "ThePEG/Interface/Interfaced.h"
#include "FactoryBase.fh"
#include "AIAnalysisFactory.h"
#include "AITreeFactory.h"
#include "AITree.h"
#include "AIHistogramFactory.h"
#include "AIHistogram1D.h"
#include "AIAxis.h"
#include "AIDataPointSetFactory.h"
#include "AIDataPointSet.h"
#include "AIDataPoint.h"
#include "AIMeasurement.h"

namespace ThePEG {

class FactoryBase: public Interfaced {

public:

  typedef AIDA::IHistogram1D * tH1DPtr;

  typedef const AIDA::IHistogram1D * tcH1DPtr;

  typedef AIDA::IDataPointSet * tDSetPtr;

  typedef const AIDA::IDataPointSet * tcDSetPtr;

public:

  class DataFiller {

  public:

    DataFiller(AIDA::IDataPointSet * dps) : dset(dps) {}

    DataFiller(const DataFiller & df) : dset(df.dset) {}

    ~DataFiller();

    DataFiller & operator<<(double x) {
      v.push_back(x);
      return *this;
    }

    operator AIDA::IDataPointSet * () { return dset; }

  private:

    AIDA::IDataPointSet * dset;

    deque<double> v;

  };

public:

  FactoryBase();

  FactoryBase(const FactoryBase &);

  virtual ~FactoryBase();

public:

  const string & filename() const { return theFilename; }

  const string & suffix() const { return theSuffix; }

  const string & storeType() const { return theStoreType; }

  virtual void
  normalizeToXSec(tH1DPtr histogram, CrossSection unit = picobarn) const = 0;

  virtual void normalizeToXSecFraction(tH1DPtr histogram) const = 0;

  virtual void normalizeToUnity(tH1DPtr histogram) const = 0;

  AIDA::IAnalysisFactory & analysisFactory() const {
    return *theAnalysisFactory;
  }

  AIDA::ITree & tree() const { return *theTree; }

  AIDA::IHistogramFactory & histogramFactory() const {
    return *theHistogramFactory;
  }

  AIDA::IDataPointSetFactory & dataSetFactory() const {
    return *theDataSetFactory;
  }

  void mkdir(const string & path) { tree().mkdir(path); }

  void mkdirs(const string & path) { tree().mkdirs(path); }

  void cd(const string & path) { tree().cd(path); }

  tH1DPtr createHistogram1D(const string & path, int nb, double lo, double up) {
    return histogramFactory().createHistogram1D(path, nb, lo, up);
  }

  tH1DPtr createHistogram1D(const string & path, const string & title, int nb,
                            double lo, double up) {
    return histogramFactory().createHistogram1D(path, title, nb, lo, up);
  }

  tH1DPtr createHistogram1D(const string & path, const string & title,
                            const std::vector<double> & edges) {
    return histogramFactory().createHistogram1D(path, title, edges);
  }

  DataFiller createDataSet(const string & path, const string & title, int dim) {
    return DataFiller(dataSetFactory().create(path, title, dim));
  }

  void registerClient(tIPtr client) {
    initrun();
    clients.insert(client);
  }

protected:

  void analysisFactory(AIDA::IAnalysisFactory * x) {
    theAnalysisFactory = x;
  }

  void clear();


public:

  void persistentOutput(PersistentOStream & os) const;

  void persistentInput(PersistentIStream & is, int version);

  static void Init();

protected:

  virtual void doinitrun();

  virtual void dofinish();

private:

  string theFilename;

  string theSuffix;

  string theStoreType;

  AIDA::IAnalysisFactory * theAnalysisFactory;

  AIDA::ITree * theTree;

  AIDA::IHistogramFactory * theHistogramFactory;

  AIDA::IDataPointSetFactory * theDataSetFactory;

  set<IPtr> clients;

private:

  static AbstractClassDescription<FactoryBase> initFactoryBase;

  FactoryBase & operator=(const FactoryBase &);

};

}

#include "ThePEG/Utilities/ClassTraits.h"

namespace ThePEG {

template <>
struct BaseClassTrait<FactoryBase,1> {
  typedef Interfaced NthBase;
};

template <>
struct ClassTraits<FactoryBase>
  : public ClassTraitsBase<FactoryBase> {
  static string className() { return "ThePEG::FactoryBase"; }
};

}

#endif /* THEPEG_FactoryBase_H */

---