gaugeFixing_Landau.h

Go to the documentation of this file.

#ifndef GAUGEFIXING_LANDAU_INCLUDED
#define GAUGEFIXING_LANDAU_INCLUDED

#include "gaugeFixing.h"
#include "Field/shiftField_eo.h"
#include "Tools/randomNumbers.h"
#include "Tools/randomNumberManager.h"

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



/*
    This class fixes the gauge of configuration to the Landau gauge.
    The algorithm is that developed by the Los Alamos group [see the
    implementation note].
    Overrelaxation is incorporated.
    To escape the Gribov copy, if convergence is not reached within
    the iterations specified by Nreset, random gauge transformation
    is performed to reset the configuration.
    This is the reason that random number generator is needed at the
    construction of this class.

    The implementation is not complete:
    - only applies to SU(3) case: because of specific implementation
      of maxTr function (Cabibbo-Marinari maximization).
    This should be improved in the version beyond test phase.
                                        [16 Feb 2012 H.Matsufuru]
    (Coding history will be recovered from trac.)
    YAML is implemented.                [14 Nov 2012 Y.Namekawa]
    unique_ptr is introduced to avoid memory leaks
                                        [21 Mar 2015 Y.Namekawa]
    Staple and RandomNumbers are moved into gaugeFixing
                                        [30 Mar 2016 Y.Namekawa]
 */

class GaugeFixing_Landau : public GaugeFixing
{
 public:
  static const std::string class_name;

 private:
  int m_Niter;             // max iteration number
  int m_Nnaive;            // number of naive iterations
  int m_Nmeas;             // interval of measurements
  int m_Nreset;            // Number of iteration to reset the config.
  double m_Enorm;          // convergence criterion
  double m_wp;             // overrelaxation parameter

  RandomNumbers *m_rand;
  Index_eo m_index;

 public:
  GaugeFixing_Landau()
    : GaugeFixing(),
    m_rand(RandomNumberManager::getInstance())
  {
  }

  GaugeFixing_Landau(RandomNumbers *rand)
    : GaugeFixing(),
    m_rand(rand)
  {
  }

  GaugeFixing_Landau(unique_ptr<RandomNumbers>& rand)
    : GaugeFixing(),
    m_rand(rand.get())
  {
  }

  ~GaugeFixing_Landau() {}

  void set_parameters(const Parameters& params);
  void set_parameters(const int Niter, const int Nnaive, const int Nmeas,
                      const int Nreset, const double Enorm, const double wp);

  void fix(Field_G& Ufix, const Field_G& Uorg);

 private:
  void gfix_step(Field_G& Ue, Field_G& Uo, const double wp);

  void set_randomGaugeTrans(Field_G& Geo);
  void gauge_trans_eo(Field_G& Ue, Field_G& Uo,
                      const Field_G& Geo, const int Ieo);

  void calc_SG(double& sg, double& Fval,
               const Field_G& Ue, const Field_G& Uo);
  void calc_W(Field_G& Weo,
              const Field_G& Ue, const Field_G& Uo, const int Ieo);
  void calc_DLT(Field_G& Weo,
                const Field_G& Ue, const Field_G& Uo, const int Ieo);

  void maxTr(Field_G&, Field_G&);
  void maxTr1(Field_G&, Field_G&);
  void maxTr2(Field_G&, Field_G&);
  void maxTr3(Field_G&, Field_G&);

#ifdef USE_FACTORY
 private:
  static GaugeFixing *create_object()
  {
    return new GaugeFixing_Landau();
  }

 public:
  static bool register_factory()
  {
    return GaugeFixing::Factory::Register("Landau", create_object);
  }
#endif
};
#endif