quda.h

Go to the documentation of this file.

#ifndef _QUDA_H
#define _QUDA_H

#include <enum_quda.h>
#include <stdio.h> /* for FILE */

#define QUDA_VERSION_MAJOR     0
#define QUDA_VERSION_MINOR     5
#define QUDA_VERSION_SUBMINOR  0

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


#define QUDA_MAX_DIM 5

#define QUDA_MAX_MULTI_SHIFT 32


#ifdef __cplusplus
extern "C" {
#endif

  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;   
    double gaugeGiB;

    int preserve_gauge; 
  } QudaGaugeParam;


  typedef struct QudaInvertParam_s {

    QudaFieldLocation input_location; 
    QudaFieldLocation output_location; 
    QudaDslashType dslash_type;
    QudaInverterType inv_type;

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

    double tol_offset[QUDA_MAX_MULTI_SHIFT];     

    double tol_hq_offset[QUDA_MAX_MULTI_SHIFT];

    double true_res_offset[QUDA_MAX_MULTI_SHIFT]; 

    double true_res_hq_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;

    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;

    double omega;

    int precondition_cycle;

    QudaSchwarzType schwarz_type;

    QudaResidualType residual_type;

  } QudaInvertParam;


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

  void setVerbosityQuda(QudaVerbosity verbosity, const char prefix[],
                        FILE *outfile);

  typedef int (*QudaCommsMap)(const int *coords, void *fdata);

  void initCommsGridQuda(int nDim, const int *dims, QudaCommsMap func, void *fdata);

  void initQuda(int device);

  void endQuda(void);

  QudaGaugeParam newQudaGaugeParam(void);

  QudaInvertParam newQudaInvertParam(void);

  void printQudaGaugeParam(QudaGaugeParam *param);

  void printQudaInvertParam(QudaInvertParam *param);

  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);

  void dslashQuda(void *h_out, void *h_in, QudaInvertParam *inv_param,
                  QudaParity parity);

  void cloverQuda(void *h_out, void *h_in, QudaInvertParam *inv_param,
                  QudaParity *parity, int inverse);

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

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


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

  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);

  int computeGaugeForceQuda(void* mom, void* sitelink,  int*** input_path_buf, int* path_length,
                            void* loop_coeff, int num_paths, int max_length, double eb3,
                            QudaGaugeParam* qudaGaugeParam, double* timeinfo);

#ifdef __cplusplus
}
#endif

#include <quda_fortran.h>
/* #include <quda_new_interface.h> */

#endif /* _QUDA_H */