quda.h

Go to the documentation of this file.

#ifndef _QUDA_H
#define _QUDA_H

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

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct QudaGaugeParam_s {

    QudaFieldLocation location; 
    int X[4];             
    double anisotropy;    
    double tadpole_coeff; 
    double scale; 
    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; 
    QudaStaggeredPhase staggered_phase_type; 
    int staggered_phase_applied; 
    int overlap; 
    int use_resident_gauge;  
    int use_resident_mom;    
    int make_resident_gauge; 
    int make_resident_mom;   
  } 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 b_5[QUDA_MAX_DWF_LS];  
    double c_5[QUDA_MAX_DWF_LS];  
    double mu;    
    double epsilon; 
    QudaTwistFlavorType twist_flavor;  
    double tol;    
    double tol_restart;   
    double tol_hq; 
    double true_res; 
    double true_res_hq; 
    int maxiter; 
    double reliable_delta; 
    int use_sloppy_partial_accumulator; 
    int max_res_increase;

    int max_res_increase_total;

    int pipeline; 
    int num_offset; 
    int overlap; 
    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; 
    QudaSolverNormalization solver_normalization; 
    QudaPreserveSource preserve_source;       
    QudaPrecision cpu_prec;                
    QudaPrecision cuda_prec;               
    QudaPrecision cuda_prec_sloppy;        
    QudaPrecision cuda_prec_precondition;  
    QudaDiracFieldOrder dirac_order;       
    QudaGammaBasis gamma_basis;            
    QudaFieldLocation clover_location;            
    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;       
    double clover_coeff;                   
    int compute_clover_trlog;              
    double trlogA[2];                      
    QudaVerbosity verbosity;               
    int sp_pad;                            
    int cl_pad;                            
    int iter;                              
    double spinorGiB;                      
    double cloverGiB;                      
    double gflops;                         
    double secs;                           
    QudaTune tune;                          
    int Nsteps; 

    int gcrNkrylov;

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

    QudaInverterType inv_type_precondition;

    QudaDslashType dslash_type_precondition;
    QudaVerbosity verbosity_precondition;

    double tol_precondition;

    int maxiter_precondition;

    double omega;

    int precondition_cycle;

    QudaSchwarzType schwarz_type;

    QudaResidualType residual_type;

    QudaPrecision cuda_prec_ritz; 
    int nev;

    int max_search_dim;//for magma library this parameter must be multiple 16?

    int rhs_idx;

    int deflation_grid;//total deflation space is nev*deflation_grid

  } QudaInvertParam;


  // Parameter set for solving the eigenvalue problems.
  // Eigen problems are tightly related with Ritz algorithm.
  // And the Lanczos algorithm use the Ritz operator.
  // For Ritz matrix operation, 
  // we need to know about the solution type of dirac operator.
  // For acceleration, we are also using chevisov polynomial method.
  // And nk, np values are needed Implicit Restart Lanczos method
  // which is optimized form of Lanczos algorithm
  typedef struct QudaEigParam_s {

    QudaInvertParam *invert_param;
    QudaSolutionType  RitzMat_lanczos;
    QudaSolutionType  RitzMat_Convcheck;
    QudaEigType eig_type;

    double *MatPoly_param;
    int NPoly;
    double Stp_residual;
    int nk;
    int np;
    int f_size;
    double eigen_shift;

  } QudaEigParam;

    

  /*
   * 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 initQudaDevice(int device);

  void initQudaMemory();

  void initQuda(int device);

  void endQuda(void);

  QudaGaugeParam newQudaGaugeParam(void);

  QudaInvertParam newQudaInvertParam(void);

  QudaEigParam newQudaEigParam(void);

  void printQudaGaugeParam(QudaGaugeParam *param);

  void printQudaInvertParam(QudaInvertParam *param);

  void printQudaEigParam(QudaEigParam *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 lanczosQuda(int k0, int m, void *hp_Apsi, void *hp_r, void *hp_V, 
                   void *hp_alpha, void *hp_beta, QudaEigParam *eig_param);

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

  void invertMultiShiftMDQuda(void **_hp_xe, void **_hp_xo, void **_hp_ye, 
      void **_hp_yo, void *_hp_b, QudaInvertParam *param);

  void invertMultiShiftQuda(void **_hp_x, void *_hp_b, QudaInvertParam *param);

  void incrementalEigQuda(void *_h_x, void *_h_b, QudaInvertParam *param, void *_h_u, double *inv_eigenvals, int last_rhs);

  void dslashQuda(void *h_out, void *h_in, QudaInvertParam *inv_param,
      QudaParity parity);
  
  void dslashQuda_4dpc(void *h_out, void *h_in, QudaInvertParam *inv_param,
      QudaParity parity, int test_type);
  
  void dslashQuda_mdwf(void *h_out, void *h_in, QudaInvertParam *inv_param,
      QudaParity parity, int test_type);

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

  void computeKSLinkQuda(void* fatlink, void* longlink, void* ulink, void* inlink, 
                         double *path_coeff, QudaGaugeParam *param, QudaComputeFatMethod method);



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

  void updateGaugeFieldQuda(void* gauge, void* momentum, double dt, 
      int conj_mom, int exact, QudaGaugeParam* param);


  void* createExtendedGaugeField(void* gauge, int geometry, QudaGaugeParam* param);

  void* createGaugeField(void* gauge, int geometry, QudaGaugeParam* param);

  void  saveGaugeField(void* outGauge, void* inGauge, QudaGaugeParam* param);

  void  extendGaugeField(void* outGauge, void* inGauge);


  void destroyQudaGaugeField(void* gauge);

  void createCloverQuda(QudaInvertParam* param);


  void computeCloverTraceQuda(void* out, void* clover, int mu, int nu, int dim[4]);

  void computeCloverDerivativeQuda(void* out, void* gauge, void* oprod, int mu, int nu,
      double coeff,
      QudaParity parity, QudaGaugeParam* param, int conjugate);

  void computeStaggeredOprodQuda(void** oprod, void** quark, int num, double** coeff, QudaGaugeParam* param);

  void computeStaggeredForceQuda(void* mom, void* quark, double* coeff);

  void computeAsqtadForceQuda(void* const momentum,
        long long* flops,
        const double act_path_coeff[6],
        const void* const one_link_src[4],
        const void* const naik_src[4],
        const void* const link,
        const QudaGaugeParam* param);


  void computeHISQForceQuda(void* momentum,
    long long* flops,
    const double level2_coeff[6],
    const double fat7_coeff[6],
    const void* const staple_src[4],
    const void* const one_link_src[4],
    const void* const naik_src[4],
    const void* const w_link,
    const void* const v_link,
    const void* const u_link,
    const QudaGaugeParam* param);



  void computeHISQForceCompleteQuda(void* momentum,
                      const double level2_coeff[6],
                      const double fat7_coeff[6],
                      void** quark_array,
                      int num_terms,
                      double** quark_coeff,
                      const void* const w_link,
                      const void* const v_link,
                      const void* const u_link,
                      const QudaGaugeParam* param);

  void performAPEnStep(unsigned int nSteps, double alpha);
  double plaqCuda();
  void openMagma();

  void closeMagma();


#ifdef __cplusplus
}
#endif

/* #include <quda_new_interface.h> */

#endif /* _QUDA_H */