quda/include/quda.h

Go to the documentation of this file.

#ifndef _QUDA_H
#define _QUDA_H

#include <enum_quda.h>

#define QUDA_VERSION_MAJOR     0
#define QUDA_VERSION_MINOR     4
#define QUDA_VERSION_SUBMINOR  0 

#define QUDA_VERSION ((QUDA_VERSION_MAJOR<<16) | (QUDA_VERSION_MINOR<<8) | QUDA_VERSION_SUBMINOR)

#ifdef __cplusplus
extern "C" {
#endif

#define QUDA_MAX_DIM 6

#define QUDA_MAX_MULTI_SHIFT 32


  typedef struct QudaGaugeParam_s {

    int X[4];

    double anisotropy;    
    double tadpole_coeff; 
    QudaLinkType type;
    QudaGaugeFieldOrder gauge_order;

    QudaTboundary t_boundary;

    QudaPrecision cpu_prec;

    QudaPrecision cuda_prec;
    QudaReconstructType reconstruct;

    QudaPrecision cuda_prec_sloppy;
    QudaReconstructType reconstruct_sloppy;

    QudaPrecision cuda_prec_precondition;
    QudaReconstructType reconstruct_precondition;

    QudaGaugeFixed gauge_fix;

    int ga_pad;

    int site_ga_pad;

    int staple_pad;   
    int llfat_ga_pad; 
    int mom_ga_pad;   
    int packed_size;
    double gaugeGiB;

    int preserve_gauge; 
  } QudaGaugeParam;


  /*
   * Parameters relating to the solver and the choice of Dirac operator.
   */
  typedef struct QudaInvertParam_s {

    QudaDslashType dslash_type;
    QudaInverterType inv_type;

    double mass;  
    double kappa; 
    double m5;    
    int Ls;       
    double mu;    
    QudaTwistFlavorType twist_flavor;  
    double tol;
    int maxiter;
    double reliable_delta; 
    int num_offset; 
    double offset[QUDA_MAX_MULTI_SHIFT];

    double tol_offset[QUDA_MAX_MULTI_SHIFT];

    QudaSolutionType solution_type;  
    QudaSolveType solve_type;        
    QudaMatPCType matpc_type;
    QudaDagType dagger;
    QudaMassNormalization mass_normalization;

    QudaPreserveSource preserve_source;

    QudaPrecision cpu_prec;
    QudaPrecision cuda_prec;
    QudaPrecision cuda_prec_sloppy;
    QudaPrecision cuda_prec_precondition;

    QudaDiracFieldOrder dirac_order;

    QudaGammaBasis gamma_basis;

    QudaPrecision clover_cpu_prec;
    QudaPrecision clover_cuda_prec;
    QudaPrecision clover_cuda_prec_sloppy;
    QudaPrecision clover_cuda_prec_precondition;

    QudaCloverFieldOrder clover_order;
    QudaUseInitGuess use_init_guess;

    QudaVerbosity verbosity;    

    int sp_pad;
    int cl_pad;

    int iter;
    double spinorGiB;
    double cloverGiB;
    double gflops;
    double secs;

    QudaTune tune;

    QudaPreserveDirac preserve_dirac;

    int gcrNkrylov;

    /*
     * The following parameters are related to the domain-decomposed
     * preconditioner, if enabled.
     */

    QudaInverterType inv_type_precondition;

    QudaVerbosity verbosity_precondition;

    double tol_precondition;

    int maxiter_precondition;

    QudaPrecision prec_precondition;

    double omega;

  } QudaInvertParam;


  /*
   * Interface functions, found in interface_quda.cpp
   */

  void initQuda(int device);

  void loadGaugeQuda(void *h_gauge, QudaGaugeParam *param);

  void freeGaugeQuda(void);

  void saveGaugeQuda(void *h_gauge, QudaGaugeParam *param);

  void loadCloverQuda(void *h_clover, void *h_clovinv,
                      QudaInvertParam *inv_param);

  void freeCloverQuda(void);

  void invertQuda(void *h_x, void *h_b, QudaInvertParam *param);

  void invertMultiShiftQuda(void **_hp_x, void *_hp_b, QudaInvertParam *param,
                            double* offsets, int num_offsets,
                            double* residue_sq);

  void invertMultiShiftQudaMixed(void **_hp_x, void *_hp_b,
                                 QudaInvertParam *param, double* offsets,
                                 int num_offsets, double* residue_sq);
    
  void dslashQuda(void *h_out, void *h_in, QudaInvertParam *inv_param,
                  QudaParity parity);

  void MatQuda(void *h_out, void *h_in, QudaInvertParam *inv_param);

  void MatDagMatQuda(void *h_out, void *h_in, QudaInvertParam *inv_param);

  void endQuda(void);

  QudaGaugeParam newQudaGaugeParam(void);

  QudaInvertParam newQudaInvertParam(void);

  void printQudaGaugeParam(QudaGaugeParam *param);

  void printQudaInvertParam(QudaInvertParam *param);


  /*
   * The following routines are temporary additions used by the HISQ
   * link-fattening code.
   */

  void  record_gauge(int* X, void *_fatlink, int _fatlink_pad, 
                     void* _longlink, int _longlink_pad, 
                     QudaReconstructType _longlink_recon,
                     QudaReconstructType _longlink_recon_sloppy,
                     QudaGaugeParam *_param);
  void set_dim(int *);
  void pack_ghost(void **cpuLink, void **cpuGhost, int nFace,
                  QudaPrecision precision);
  void setFatLinkPadding(QudaComputeFatMethod method, QudaGaugeParam* param);
  int computeFatLinkQuda(void* fatlink, void** sitelink,
                         double* act_path_coeff, QudaGaugeParam* param, 
                         QudaComputeFatMethod method);
  
  /*
   * The following routines are only used by the examples in tests/ .
   * They should generally not be called in a typical application.
   */  
  void initCommsQuda(int argc, char **argv, const int *X, const int nDim);
  void endCommsQuda();

#ifdef __cplusplus
}
#endif

#endif /* _QUDA_H */