FactoryBase.h

// -*- C++ -*-
//
// FactoryBase.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 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/Interface/Interfaced.h"
#include "FactoryBase.fh"
 
namespace AIDA {
  class IHistogram1D;
  class IHistogram2D;
  class IDataPointSet;
  class IAnalysisFactory;
  class ITree;
  class IHistogramFactory;
  class IDataPointSetFactory;
}
 
namespace ThePEG {
 
class FactoryBase: public Interfaced {
 
public:
 
  typedef AIDA::IHistogram1D * tH1DPtr;
 
  typedef const AIDA::IHistogram1D * tcH1DPtr;
 
  typedef AIDA::IHistogram2D * tH2DPtr;
 
  typedef const AIDA::IHistogram2D * tcH2DPtr;
 
  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
  normalizeToXSec(tH2DPtr histogram, CrossSection unit = picobarn) const = 0;
 
  virtual void normalizeToXSecFraction(tH1DPtr histogram) const = 0;
 
  virtual void normalizeToXSecFraction(tH2DPtr histogram) const = 0;
 
  virtual void normalizeToUnity(tH1DPtr histogram) const = 0;
 
  virtual void normalizeToUnity(tH2DPtr histogram) const = 0;
 
  AIDA::IAnalysisFactory & analysisFactory() const {
    return *theAnalysisFactory;
  }
 
  AIDA::ITree & tree() const;
 
  AIDA::IHistogramFactory & histogramFactory() const;
 
  AIDA::IDataPointSetFactory & dataSetFactory() const;
 
  void mkdir(const string & path);
 
  void mkdirs(const string & path);
 
  void cd(const string & path);
 
  tH1DPtr createHistogram1D(const string & path, int nb, double lo, double up);
 
  tH1DPtr createHistogram1D(const string & path, const string & title, int nb,
                            double lo, double up);
 
  tH1DPtr createHistogram1D(const string & path, const string & title,
                            const std::vector<double> & edges);
 
  tH2DPtr createHistogram2D(const string & path,
                            int nbx, double xlo, double xup,
                            int nby, double ylo, double yup);
 
  tH2DPtr createHistogram2D(const string & path, const string & title,
                            int nbx, double xlo, double xup,
                            int nby, double ylo, double yup);
 
  tH2DPtr createHistogram2D(const string & path, const string & title,
                            const std::vector<double> & xedges,
                            const std::vector<double> & yedges);
 
  DataFiller createDataSet(const string & path, const string & title, int dim);
 
  void registerClient(tIPtr 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 &) = delete;
 
};
 
}
 
#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 */