source_Staggered_Wall.cpp

Go to the documentation of this file.

#include "source_Staggered_Wall.h"

#ifdef USE_PARAMETERS_FACTORY
#include "parameters_factory.h"
#endif

using Bridge::vout;

//- parameter entry
namespace {
  void append_entry(Parameters& param)
  {
    param.Register_int("source_position", 0);

    param.Register_string("verbose_level", "NULL");
  }


#ifdef USE_PARAMETERS_FACTORY
  bool init_param = ParametersFactory::Register("Source_Staggered_Wall", append_entry);
#endif
}
//- end

//- parameters class
Parameters_Source_Staggered_Wall::Parameters_Source_Staggered_Wall() { append_entry(*this); }
//- end

//====================================================================
void Source_Staggered_Wall::set_parameters(const Parameters& params)
{
  const string str_vlevel = params.get_string("verbose_level");

  m_vl = vout.set_verbose_level(str_vlevel);

  //- fetch and check input parameters
  int source_position;

  int err = 0;
  err += params.fetch_int("source_position", source_position);

  if (err) {
    vout.crucial(m_vl, "Source_Staggered_Wall: fetch error, input parameter not found.\n");
    abort();
  }


  set_parameters(source_position);
}


//====================================================================
void Source_Staggered_Wall::set_parameters(const int source_position)
{
  int Lt = CommonParameters::Lt();

  //- print input parameters
  vout.general(m_vl, "Source for staggered spinor field - Wall:\n");
  vout.general(m_vl, "  source_position[t] = %d\n", source_position);

  //- range check
  int err = 0;
  // NB. Lt > abs(source_position)
  err += ParameterCheck::non_negative(Lt - abs(source_position));

  if (err) {
    vout.crucial(m_vl, "Source_Staggered_Wall: parameter range check failed.\n");
    abort();
  }

  //- store values
  m_t_src = source_position;

  //- post-process
  init();
}


//====================================================================
void Source_Staggered_Wall::init()
{
  int Nvol = CommonParameters::Nvol();

  int Nx = CommonParameters::Nx();
  int Ny = CommonParameters::Ny();
  int Nz = CommonParameters::Nz();
  int Nt = CommonParameters::Nt();

  int ipex = Communicator::ipe(0);
  int ipey = Communicator::ipe(1);
  int ipez = Communicator::ipe(2);
  int ipet = Communicator::ipe(3);

  src_wall_1.reset(1, Nvol, 1);
  src_wall_2.reset(1, Nvol, 1);
  src_wall_1 = 0.0;
  src_wall_2 = 0.0;

  int tl_src = m_t_src % Nt;
  int ex     = 0;
  if (m_t_src / Nt == ipet) {
    for (int z = 0; z < Nz; ++z) {
      int z2 = z + ipez * Nz;
      for (int y = 0; y < Ny; ++y) {
        int y2 = y + ipey * Ny;
        for (int x = 0; x < Nx; ++x) {
          int x2 = x + ipex * Nx;

          int site = m_index.site(x, y, z, tl_src);

          if (((x2 + y2 + z2) % 2) == 0) {
            src_wall_1.set(0, site, ex, 1.0);
            src_wall_2.set(0, site, ex, 1.0);
          } else {
            src_wall_1.set(0, site, ex, 1.0);
            src_wall_2.set(0, site, ex, -1.0);
          }
        }
      }
    }
  }
}


//====================================================================
void Source_Staggered_Wall::set(Field_F_1spinor& src,
                                const int ic, const int i_src)
{
  int Nvol = CommonParameters::Nvol();

  src = 0.0;

  int ex = 0;
  if (i_src == 0) {
    for (int site = 0; site < Nvol; ++site) {
      src.set_r(ic, site, ex, src_wall_1.cmp(0, site, ex));
    }
  } else if (i_src == 1) {
    for (int site = 0; site < Nvol; ++site) {
      src.set_r(ic, site, ex, src_wall_2.cmp(0, site, ex));
    }
  } else {
    vout.general(m_vl, "Source_Staggered_Wall: illegal source index.\n");
    abort();
  }
}


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