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>
 
#include <comm_key.h>
 
namespace quda {
 
  namespace clover
  {
 
    inline bool isNative(QudaCloverFieldOrder order, QudaPrecision precision)
    {
      if (precision == QUDA_DOUBLE_PRECISION) {
        if (order == QUDA_FLOAT2_CLOVER_ORDER) return true;
      } else if (precision == QUDA_SINGLE_PRECISION || precision == QUDA_HALF_PRECISION
                 || precision == QUDA_QUARTER_PRECISION) {
        if (order == QUDA_FLOAT4_CLOVER_ORDER) return true;
      }
      return false;
    }
 
  } // namespace clover
 
  // Prefetch type
  enum class CloverPrefetchType {
    BOTH_CLOVER_PREFETCH_TYPE,    // clover and inverse
    CLOVER_CLOVER_PREFETCH_TYPE,  // clover only
    INVERSE_CLOVER_PREFETCH_TYPE, // inverse clover only
    INVALID_CLOVER_PREFETCH_TYPE = QUDA_INVALID_ENUM
  };
 
  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;  
    double coeff;  
    bool twisted; // whether to create twisted mass clover
    double mu2;
    double rho;
 
    QudaCloverFieldOrder order;
    QudaFieldCreate create;
 
    QudaFieldLocation location;
 
    void setPrecision(QudaPrecision precision, bool force_native = false)
    {
      // is the current status in native field order?
      bool native = force_native ? true : clover::isNative(order, this->precision);
      this->precision = precision;
      this->ghost_precision = precision;
 
      if (native) {
        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),
      location(QUDA_INVALID_FIELD_LOCATION)
    {
    }
 
    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),
      location(param.location)
    {
    }
 
    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
    size_t length;
    size_t real_length;
    int nColor;
    int nSpin;
 
    void *clover;
    void *norm;
    void *cloverInv;
    void *invNorm;
 
    double csw;
    double coeff;
    bool twisted; 
    double mu2;
    double rho;
 
    QudaCloverFieldOrder order;
    QudaFieldCreate create;
 
    mutable double trlog[2];
 
  public:
    CloverField(const CloverFieldParam &param);
    virtual ~CloverField();
 
    static CloverField *Create(const CloverFieldParam &param);
 
    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; }
 
    using param_type = CloverFieldParam;
 
    bool isNative() const { return clover::isNative(order, precision); }
 
    double* TrLog() const { return trlog; }
    
    QudaCloverFieldOrder Order() const { return order; }
 
    size_t Bytes() const { return bytes; }
 
    size_t NormBytes() const { return norm_bytes; }
 
    size_t TotalBytes() const
    {
      int direct = V(false) ? 1 : 0;
      int inverse = V(true) ? 1 : 0;
      return (direct + inverse) * (bytes + norm_bytes);
    }
 
    int Ncolor() const { return nColor; }
 
    int Nspin() const { return nSpin; }
 
    double Csw() const { return csw; }
 
    double Coeff() const { return coeff; }
 
    bool Twisted() const { return twisted; }
 
    double Mu2() const { return mu2; }
 
    double Rho() const { return rho; }
 
    void setRho(double rho);
 
    double norm1(bool inverse = false) const;
 
    double norm2(bool inverse = false) const;
 
    double abs_max(bool inverse = false) const;
 
    double abs_min(bool inverse = false) const;
 
    virtual int full_dim(int d) const { return x[d]; }
  };
 
  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);
 
  public:
    // create a cudaCloverField from a CloverFieldParam
    cudaCloverField(const CloverFieldParam &param);
 
    virtual ~cudaCloverField();
 
    void copy(const CloverField &src, bool inverse=true);
 
    void loadCPUField(const cpuCloverField &cpu);
 
  
    void saveCPUField(cpuCloverField &cpu) const;
 
    void prefetch(QudaFieldLocation mem_space, qudaStream_t stream = 0) const;
 
    void prefetch(QudaFieldLocation mem_space, qudaStream_t stream, CloverPrefetchType type,
                  QudaParity parity = QUDA_INVALID_PARITY) const;
 
    virtual void copy_to_buffer(void *buffer) const;
 
    virtual void copy_from_buffer(void *buffer);
 
    friend class DiracClover;
    friend class DiracCloverPC;
    friend class DiracTwistedClover;
    friend class DiracTwistedCloverPC;
    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();
 
    virtual void copy_to_buffer(void *buffer) const;
 
    virtual void copy_from_buffer(void *buffer);
  };
 
  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
 
    FullClover(const cudaCloverField &clover, bool inverse = false) :
      precision(clover.precision),
      bytes(clover.bytes),
      norm_bytes(clover.norm_bytes),
      stride(clover.stride),
      rho(clover.rho)
    {
      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;
      }
    }
  };
 
  void computeClover(CloverField &clover, const GaugeField &fmunu, double coeff);
 
  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);
 
  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);
 
  void copyFieldOffset(CloverField &out, const CloverField &in, CommKey offset, QudaPCType pc_type);
 
  constexpr bool dynamic_clover_inverse()
  {
#ifdef DYNAMIC_CLOVER
    return true;
#else
    return false;
#endif
  }
 
} // namespace quda
 
#endif // _CLOVER_QUDA_H