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 */