fopr.h

Go to the documentation of this file.

#ifndef FOPR_INCLUDED
#define FOPR_INCLUDED

#include "Field/field_F.h"
#include "Parameters/parameters.h"

#include "IO/bridgeIO.h"
using Bridge::vout;

#ifdef USE_FACTORY
#include "Tools/factory.h"
#include "Tools/director.h"
#endif



class Fopr
{
 public:
  Fopr()
    : m_vl(CommonParameters::Vlevel()) {}

  virtual ~Fopr() {}

 private:
  // non-copyable
  Fopr(const Fopr&);
  Fopr& operator=(const Fopr&);

 public:
  virtual void set_parameters(const Parameters&) = 0;

  void set_parameter_verboselevel(const Bridge::VerboseLevel vl) { m_vl = vl; }

  virtual void set_config(Field *) = 0;
  virtual void set_config(unique_ptr<Field_G>&) = 0;

  //   and set the resultant field to the 1st argument.
  virtual void mult(Field&, const Field&) = 0;

  virtual void mult_dag(Field&, const Field&) {}

  virtual void mult_gm5(Field&, const Field&)
  {
    vout.crucial(m_vl, "Fopr: mult_gm5 not implemented.\n");
    exit(EXIT_FAILURE);
  }

  virtual void mult(Field&, const Field&, const std::string mode) {}

  virtual void mult_dag(Field&, const Field&, const std::string mode) {}

  virtual void mult_up(const int mu, Field&, const Field&) {}
  virtual void mult_dn(const int mu, Field&, const Field&) {}

  virtual void set_mode(const std::string mode)
  {
    vout.general(m_vl, "Fopr: set_mode not implemented.\n");
    exit(EXIT_FAILURE);
  }

  // virtual void set_lowmodes(int Nsbt, std::vector<double> *ev,
  //                           std::vector<Field> *vk);

  virtual std::string get_mode() const
  {
    vout.general(m_vl, "Fopr: get_mode not implemented.\n");
    return std::string();
  }

  virtual int field_nvol() = 0;

  virtual int field_nin() = 0;

  virtual int field_nex() = 0;

  virtual double flop_count() { return 0.0; }

  virtual double flop_count(const std::string mode)
  { return 0; }

 protected:
  Bridge::VerboseLevel m_vl;


#ifdef USE_FACTORY
 public:
  typedef Fopr *(*ProductCreator_noarg)();
  typedef Fopr *(*ProductCreator_fopr)(Fopr *fopr);
  typedef Fopr *(*ProductCreator_fopr_director)(Fopr *fopr, Director *director);
  typedef Fopr *(*ProductCreator_string)(const std::string& arg);

  typedef FactoryTemplate<Fopr, ProductCreator_noarg>           Factory_noarg;
  typedef FactoryTemplate<Fopr, ProductCreator_fopr>            Factory_fopr;
  typedef FactoryTemplate<Fopr, ProductCreator_fopr_director>   Factory_fopr_director;
  typedef FactoryTemplate<Fopr, ProductCreator_string>          Factory_string;

  static Fopr *New(const IdentifierType& subtype)
  {
    ProductCreator_noarg p = Factory_noarg::Find(subtype);

    return p ? (*p)() : 0;
  }

  static Fopr *New(const IdentifierType& subtype, Fopr *fopr)
  {
    ProductCreator_fopr p = Factory_fopr::Find(subtype);

    return p ? (*p)(fopr) : 0;
  }

  static Fopr *New(const IdentifierType& subtype, unique_ptr<Fopr>& fopr)
  {
    ProductCreator_fopr p = Factory_fopr::Find(subtype);

    return p ? (*p)(fopr.get()) : 0;
  }

  static Fopr *New(const IdentifierType& subtype, Fopr *fopr, Director *director)
  {
    ProductCreator_fopr_director p = Factory_fopr_director::Find(subtype);

    return p ? (*p)(fopr, director) : 0;
  }

  static Fopr *New(const IdentifierType& subtype, unique_ptr<Fopr>& fopr, unique_ptr<Director>& director)
  {
    ProductCreator_fopr_director p = Factory_fopr_director::Find(subtype);

    return p ? (*p)(fopr.get(), director.get()) : 0;
  }

  static Fopr *New(const IdentifierType& subtype, const std::string& arg)
  {
    ProductCreator_string p = Factory_string::Find(subtype);

    return p ? (*p)(arg) : 0;
  }

#ifdef USE_FACTORY_AUTOREGISTER
#else
  static bool init_factory();
#endif
#endif
};
#endif