field_G.cpp

Go to the documentation of this file.

#include "field_G.h"

#include "commonParameters.h"
#include "communicator.h"
#include "bridgeIO.h"
using Bridge::vout;

#include "mat_SU_N.h"


//====================================================================
void Field_G::check()
{
  //  int nth = ThreadManager_OpenMP::get_num_threads();
  //  int ith = ThreadManager_OpenMP::get_thread_id();
  //  assert(nth == 1);
  //  assert(ith == 0);
  // Org-version only support single thread environment.
}


//====================================================================
void Field_G::set_unit()
{
  Mat_SU_N ut(m_Nc);

  ut.unit();

  for (int mu = 0; mu < m_Nex; ++mu) {
    for (int site = 0; site < m_Nvol; ++site) {
      set_mat(site, mu, ut);
    }
  }
}


//====================================================================
void Field_G::set_random(RandomNumbers *rand)
{
  rand->gauss_lex_global(*this);

  Mat_SU_N ut(m_Nc);

  for (int mu = 0; mu < m_Nex; ++mu) {
    for (int site = 0; site < m_Nvol; ++site) {
      this->mat(ut, site, mu);
      ut.reunit();
      this->set_mat(site, mu, ut);
    }
  }
}


//====================================================================
void Field_G::reunit()
{
  Mat_SU_N ut(m_Nc);

  for (int mu = 0; mu < m_Nex; ++mu) {
    for (int site = 0; site < m_Nvol; ++site) {
      mat(ut, site, mu);
      ut.reunit();
      set_mat(site, mu, ut);
    }
  }
}


//====================================================================
void mult_Field_Gnn(Field_G& w, const int ex,
                    const Field_G& u1, const int ex1,
                    const Field_G& u2, const int ex2)
{
  assert(ex < w.nex());
  assert(ex1 < u1.nex());
  assert(ex2 < u2.nex());
  assert(u1.nvol() == w.nvol());
  assert(u2.nvol() == w.nvol());

  const int Nvol = w.nvol();

  for (int site = 0; site < Nvol; ++site) {
    w.set_mat(site, ex, u1.mat(site, ex1) * u2.mat(site, ex2));
  }
}


//====================================================================
void mult_Field_Gdn(Field_G& w, const int ex,
                    const Field_G& u1, const int ex1,
                    const Field_G& u2, const int ex2)
{
  assert(ex < w.nex());
  assert(ex1 < u1.nex());
  assert(ex2 < u2.nex());
  assert(u1.nvol() == w.nvol());
  assert(u2.nvol() == w.nvol());

  const int Nvol = w.nvol();

  for (int site = 0; site < Nvol; ++site) {
    w.set_mat(site, ex, u1.mat_dag(site, ex1) * u2.mat(site, ex2));
  }
}


//====================================================================
void mult_Field_Gnd(Field_G& w, const int ex,
                    const Field_G& u1, const int ex1,
                    const Field_G& u2, const int ex2)
{
  assert(ex < w.nex());
  assert(ex1 < u1.nex());
  assert(ex2 < u2.nex());
  assert(u1.nvol() == w.nvol());
  assert(u2.nvol() == w.nvol());

  const int Nvol = w.nvol();

  for (int site = 0; site < Nvol; ++site) {
    w.set_mat(site, ex, u1.mat(site, ex1) * u2.mat_dag(site, ex2));
  }
}


//====================================================================
void mult_Field_Gdd(Field_G& w, const int ex,
                    const Field_G& u1, const int ex1,
                    const Field_G& u2, const int ex2)
{
  assert(ex < w.nex());
  assert(ex1 < u1.nex());
  assert(ex2 < u2.nex());
  assert(u1.nvol() == w.nvol());
  assert(u2.nvol() == w.nvol());

  const int Nvol = w.nvol();

  for (int site = 0; site < Nvol; ++site) {
    w.set_mat(site, ex, u1.mat_dag(site, ex1) * u2.mat_dag(site, ex2));
  }
}


//====================================================================
void multadd_Field_Gnn(Field_G& w, const int ex,
                       const Field_G& u1, const int ex1,
                       const Field_G& u2, const int ex2,
                       const double ff)
{
  assert(ex < w.nex());
  assert(ex1 < u1.nex());
  assert(ex2 < u2.nex());
  assert(u1.nvol() == w.nvol());
  assert(u2.nvol() == w.nvol());

  const int Nvol = w.nvol();

  for (int site = 0; site < Nvol; ++site) {
    w.add_mat(site, ex, u1.mat(site, ex1) * u2.mat(site, ex2) * ff);
  }
}


//====================================================================
void multadd_Field_Gdn(Field_G& w, const int ex,
                       const Field_G& u1, const int ex1,
                       const Field_G& u2, const int ex2,
                       const double ff)
{
  assert(ex < w.nex());
  assert(ex1 < u1.nex());
  assert(ex2 < u2.nex());
  assert(u1.nvol() == w.nvol());
  assert(u2.nvol() == w.nvol());

  const int Nvol = w.nvol();

  for (int site = 0; site < Nvol; ++site) {
    w.add_mat(site, ex, u1.mat_dag(site, ex1) * u2.mat(site, ex2) * ff);
  }
}


//====================================================================
void multadd_Field_Gnd(Field_G& w, const int ex,
                       const Field_G& u1, const int ex1,
                       const Field_G& u2, const int ex2,
                       const double ff)
{
  assert(ex < w.nex());
  assert(ex1 < u1.nex());
  assert(ex2 < u2.nex());
  assert(u1.nvol() == w.nvol());
  assert(u2.nvol() == w.nvol());

  const int Nvol = w.nvol();

  for (int site = 0; site < Nvol; ++site) {
    w.add_mat(site, ex, u1.mat(site, ex1) * u2.mat_dag(site, ex2) * ff);
  }
}


//====================================================================
void multadd_Field_Gdd(Field_G& w, const int ex,
                       const Field_G& u1, const int ex1,
                       const Field_G& u2, const int ex2,
                       const double ff)
{
  assert(ex < w.nex());
  assert(ex1 < u1.nex());
  assert(ex2 < u2.nex());
  assert(u1.nvol() == w.nvol());
  assert(u2.nvol() == w.nvol());

  const int Nvol = w.nvol();

  for (int site = 0; site < Nvol; ++site) {
    w.add_mat(site, ex, u1.mat_dag(site, ex1) * u2.mat_dag(site, ex2) * ff);
  }
}


//====================================================================
void at_Field_G(Field_G& w, const int ex)
{
  assert(ex < w.nex());

  const int Nvol = w.nvol();

  for (int site = 0; site < Nvol; ++site) {
    w.set_mat(site, ex, w.mat(site, ex).at());
  }
}


//====================================================================
void ah_Field_G(Field_G& w, const int ex)
{
  assert(ex < w.nex());

  const int Nvol = w.nvol();

  for (int site = 0; site < Nvol; ++site) {
    w.set_mat(site, ex, w.mat(site, ex).ah());
  }
}


//====================================================================
//============================================================END=====