clover_field.h

Go to the documentation of this file.

#ifndef _CLOVER_QUDA_H
#define _CLOVER_QUDA_H

#include <quda_internal.h>
#include <lattice_field.h>

namespace quda {

  struct CloverFieldParam : public LatticeFieldParam {
    bool direct; // whether to create the direct clover 
    bool inverse; // whether to create the inverse clover
    void *clover;
    void *norm;
    void *cloverInv;
    void *invNorm;
    double csw;  
    bool twisted; // whether to create twisted mass clover
    double mu2;
    double rho;

    QudaCloverFieldOrder order;
    QudaFieldCreate create;
    void setPrecision(QudaPrecision precision) {
      this->precision = precision;
      order = (precision == QUDA_DOUBLE_PRECISION) ? 
  QUDA_FLOAT2_CLOVER_ORDER : QUDA_FLOAT4_CLOVER_ORDER;
    }

    CloverFieldParam() :  LatticeFieldParam(),
      direct(true), inverse(true), clover(nullptr), norm(nullptr),
      cloverInv(nullptr), invNorm(nullptr), twisted(false), mu2(0.0), rho(0.0) { }

    CloverFieldParam(const CloverFieldParam &param) :  LatticeFieldParam(param),
      direct(param.direct), inverse(param.inverse),
      clover(param.clover), norm(param.norm),
      cloverInv(param.cloverInv), invNorm(param.invNorm),
      twisted(param.twisted), mu2(param.mu2), rho(param.rho) { }

    CloverFieldParam(const CloverField &field);
  };

  std::ostream& operator<<(std::ostream& output, const CloverFieldParam& param);

  class CloverField : public LatticeField {

  protected:
    size_t bytes; // bytes allocated per clover full field 
    size_t norm_bytes; // sizeof each norm full field
    int length;
    int real_length;
    int nColor;
    int nSpin;

    void *clover;
    void *norm;
    void *cloverInv;
    void *invNorm;

    double csw;
    bool twisted; 
    double mu2;
    double rho;

    QudaCloverFieldOrder order;
    QudaFieldCreate create;

    mutable double trlog[2];

  public:
    CloverField(const CloverFieldParam &param);
    virtual ~CloverField();

    void* V(bool inverse=false) { return inverse ? cloverInv : clover; }
    void* Norm(bool inverse=false) { return inverse ? invNorm : norm; }
    const void* V(bool inverse=false) const { return inverse ? cloverInv : clover; }
    const void* Norm(bool inverse=false) const { return inverse ? invNorm : norm; }

    bool isNative() const;

    double* TrLog() const { return trlog; }
    
    QudaCloverFieldOrder Order() const { return order; }

    size_t Bytes() const { return bytes; }

    size_t NormBytes() const { return norm_bytes; }

    bool Csw() const { return csw; }

    bool Twisted() const { return twisted; }

    double Mu2() const { return mu2; }

    double Rho() const { return rho; }

    void setRho(double rho);
  };

  class cudaCloverField : public CloverField {

  private:
    void *even, *odd;
    void *evenNorm, *oddNorm;

    void *evenInv, *oddInv;
    void *evenInvNorm, *oddInvNorm;

    // computes the clover field given the input gauge field
    void compute(const cudaGaugeField &gauge);

#ifdef USE_TEXTURE_OBJECTS
    cudaTextureObject_t tex;
    cudaTextureObject_t normTex;
    cudaTextureObject_t invTex;
    cudaTextureObject_t invNormTex;
    cudaTextureObject_t evenTex;
    cudaTextureObject_t evenNormTex;
    cudaTextureObject_t oddTex;
    cudaTextureObject_t oddNormTex;
    cudaTextureObject_t evenInvTex;
    cudaTextureObject_t evenInvNormTex;
    cudaTextureObject_t oddInvTex;
    cudaTextureObject_t oddInvNormTex;
    void createTexObject(cudaTextureObject_t &tex, cudaTextureObject_t &texNorm, void *field, void *norm, bool full);
    void destroyTexObject();
#endif

  public:
    // create a cudaCloverField from a CloverFieldParam
    cudaCloverField(const CloverFieldParam &param);

    virtual ~cudaCloverField();

#ifdef USE_TEXTURE_OBJECTS
    const cudaTextureObject_t& Tex() const { return tex; }
    const cudaTextureObject_t& NormTex() const { return normTex; }
    const cudaTextureObject_t& InvTex() const { return invTex; }
    const cudaTextureObject_t& InvNormTex() const { return invNormTex; }
    const cudaTextureObject_t& EvenTex() const { return evenTex; }
    const cudaTextureObject_t& EvenNormTex() const { return evenNormTex; }
    const cudaTextureObject_t& OddTex() const { return oddTex; }
    const cudaTextureObject_t& OddNormTex() const { return oddNormTex; }
    const cudaTextureObject_t& EvenInvTex() const { return evenInvTex; }
    const cudaTextureObject_t& EvenInvNormTex() const { return evenInvNormTex; }
    const cudaTextureObject_t& OddInvTex() const { return oddInvTex; }
    const cudaTextureObject_t& OddInvNormTex() const { return oddInvNormTex; }
#endif

    void copy(const CloverField &src, bool inverse=true);

    void loadCPUField(const cpuCloverField &cpu);

  
    void saveCPUField(cpuCloverField &cpu) const;

    friend class DiracClover;
    friend class DiracCloverPC;
    friend struct FullClover;
  };

  // this is a place holder for a future host-side clover object
  class cpuCloverField : public CloverField {

  private:

  public:
    cpuCloverField(const CloverFieldParam &param);
    virtual ~cpuCloverField();
  };

  double norm1(const CloverField &u, bool inverse=false);

  double norm2(const CloverField &a, bool inverse=false);


  // lightweight struct used to send pointers to cuda driver code
  struct FullClover {
    void *even;
    void *odd;
    void *evenNorm;
    void *oddNorm;
    QudaPrecision precision;
    size_t bytes; // sizeof each clover field (per parity)
    size_t norm_bytes; // sizeof each norm field (per parity)
    int stride; // stride (volume + pad)
    double rho; // rho additive factor

#ifdef USE_TEXTURE_OBJECTS
    const cudaTextureObject_t &evenTex;
    const cudaTextureObject_t &evenNormTex;
    const cudaTextureObject_t &oddTex;
    const cudaTextureObject_t &oddNormTex;
    const cudaTextureObject_t& EvenTex() const { return evenTex; }
    const cudaTextureObject_t& EvenNormTex() const { return evenNormTex; }
    const cudaTextureObject_t& OddTex() const { return oddTex; }
    const cudaTextureObject_t& OddNormTex() const { return oddNormTex; }    
#endif

    FullClover(const cudaCloverField &clover, bool inverse=false) :
    precision(clover.precision), bytes(clover.bytes), norm_bytes(clover.norm_bytes),
      stride(clover.stride), rho(clover.rho)
#ifdef USE_TEXTURE_OBJECTS
  , evenTex(inverse ? clover.evenInvTex : clover.evenTex)
  , evenNormTex(inverse ? clover.evenInvNormTex : clover.evenNormTex)
  , oddTex(inverse ? clover.oddInvTex : clover.oddTex)
  , oddNormTex(inverse ? clover.oddInvNormTex : clover.oddNormTex)
#endif
      { 
  if (inverse) {
    even = clover.evenInv;
    evenNorm = clover.evenInvNorm;
    odd = clover.oddInv;  
    oddNorm = clover.oddInvNorm;
  } else {
    even = clover.even;
    evenNorm = clover.evenNorm;
    odd = clover.odd; 
    oddNorm = clover.oddNorm;
  }
    }
  };


  // driver for computing the clover field from the gauge field
  void computeClover(CloverField &clover, const GaugeField &gauge, double coeff,  QudaFieldLocation location);


  void copyGenericClover(CloverField &out, const CloverField &in, bool inverse,
       QudaFieldLocation location, void *Out=0, void *In=0, void *outNorm=0, void *inNorm=0);
  


  void cloverInvert(CloverField &clover, bool computeTraceLog, QudaFieldLocation location);

  void cloverRho(CloverField &clover, double rho);

  void computeCloverForce(GaugeField& force, const GaugeField& U,
        std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &p,
        std::vector<double> &coeff);
  void computeCloverSigmaOprod(GaugeField& oprod,
             std::vector<ColorSpinorField*> &x,
             std::vector<ColorSpinorField*> &p,
             std::vector< std::vector<double> > &coeff);
  void computeCloverSigmaTrace(GaugeField &output, const CloverField &clover, double coeff);

  void cloverDerivative(cudaGaugeField &force, cudaGaugeField& gauge, cudaGaugeField& oprod, double coeff, QudaParity parity);

} // namespace quda

#endif // _CLOVER_QUDA_H