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;  
    QudaStaggeredPhase staggered_phase_type; 
    int staggered_phase_applied; 
    double i_mu; 
    int overlap; 
    int overwrite_mom; 
    int use_resident_gauge;  
    int use_resident_mom;    
    int make_resident_gauge; 
    int make_resident_mom;   
    int return_result_gauge; 
    int return_result_mom;   
    size_t gauge_offset; 
    size_t mom_offset; 
    size_t site_size; 
  } 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; 
    int compute_true_res; 
    double true_res; 
    double true_res_hq; 
    int maxiter; 
    double reliable_delta; 
    int use_sloppy_partial_accumulator; 
    int solution_accumulator_pipeline;

    int max_res_increase;

    int max_res_increase_total;

    int heavy_quark_check;

    int pipeline; 
    int num_offset; 
    int num_src; 
    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 iter_res_offset[QUDA_MAX_MULTI_SHIFT];

    double true_res_hq_offset[QUDA_MAX_MULTI_SHIFT];

    double residue[QUDA_MAX_MULTI_SHIFT];

    int compute_action;

    double action[2];

    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;                   
    double clover_rho;                     
    int compute_clover_trlog;              
    double trlogA[2];                      
    int compute_clover;                    
    int compute_clover_inverse;            
    int return_clover;                     
    int return_clover_inverse;             
    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 solver
     * preconditioner, if enabled.
     */

    QudaInverterType inv_type_precondition;

    void *preconditioner;

    void *deflation_op;

    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;
    int rhs_idx;
    int deflation_grid;
    double eigenval_tol;
    int eigcg_max_restarts;
    int max_restart_num;
    double inc_tol;

    int make_resident_solution;

    int use_resident_solution;

    int make_resident_chrono;

    int use_resident_chrono;

    int max_chrono_dim;

    int chrono_index;

    QudaExtLibType extlib_type;

  } 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;
//specific for Lanczos method:
    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;
//more general stuff:
    QudaBoolean import_vectors;

    QudaPrecision cuda_prec_ritz;

    QudaMemoryType mem_type_ritz;

    QudaFieldLocation location;

    QudaBoolean run_verify;

    char vec_infile[256];

    char vec_outfile[256];

    double gflops;

    double secs;

    QudaExtLibType extlib_type;

  } QudaEigParam;


  typedef struct QudaMultigridParam_s {

    QudaInvertParam *invert_param;

    int n_level;

    int geo_block_size[QUDA_MAX_MG_LEVEL][QUDA_MAX_DIM];

    int spin_block_size[QUDA_MAX_MG_LEVEL];

    int n_vec[QUDA_MAX_MG_LEVEL];

    QudaVerbosity verbosity[QUDA_MAX_MG_LEVEL];

    QudaInverterType setup_inv_type[QUDA_MAX_MG_LEVEL];

    double setup_tol[QUDA_MAX_MG_LEVEL];

    QudaInverterType smoother[QUDA_MAX_MG_LEVEL];

    QudaSolutionType coarse_grid_solution_type[QUDA_MAX_MG_LEVEL];

    QudaSolveType smoother_solve_type[QUDA_MAX_MG_LEVEL];

    QudaMultigridCycleType cycle_type[QUDA_MAX_MG_LEVEL];

    int nu_pre[QUDA_MAX_MG_LEVEL];

    int nu_post[QUDA_MAX_MG_LEVEL];

    double smoother_tol[QUDA_MAX_MG_LEVEL];

    double omega[QUDA_MAX_MG_LEVEL];

    QudaBoolean global_reduction[QUDA_MAX_MG_LEVEL];

    QudaFieldLocation location[QUDA_MAX_MG_LEVEL];

    QudaComputeNullVector compute_null_vector;
 
    QudaBoolean generate_all_levels; 

    QudaBoolean run_verify;

    char vec_infile[256];

    char vec_outfile[256];

    double gflops;

    double secs;

    double mu_factor[QUDA_MAX_MG_LEVEL];

  } QudaMultigridParam;



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

  void updateR();

  QudaGaugeParam newQudaGaugeParam(void);

  QudaInvertParam newQudaInvertParam(void);

  QudaMultigridParam newQudaMultigridParam(void);

  QudaEigParam newQudaEigParam(void);

  void printQudaGaugeParam(QudaGaugeParam *param);

  void printQudaInvertParam(QudaInvertParam *param);

  void printQudaMultigridParam(QudaMultigridParam *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 invertMultiSrcQuda(void **_hp_x, void **_hp_b, QudaInvertParam *param);


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

  void* newMultigridQuda(QudaMultigridParam *param);

  void destroyMultigridQuda(void *mg_instance);

  void updateMultigridQuda(void *mg_instance, QudaMultigridParam *param);

  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 computeKSLinkQuda(void* fatlink, void* longlink, void* ulink, void* inlink,
                         double *path_coeff, QudaGaugeParam *param);



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

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

  void staggeredPhaseQuda(void *gauge_h, QudaGaugeParam *param);

  void projectSU3Quda(void *gauge_h, double tol, QudaGaugeParam *param);

  double momActionQuda(void* momentum, QudaGaugeParam* param);

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

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

  void destroyGaugeFieldQuda(void* gauge);

  void createCloverQuda(QudaInvertParam* param);

  void computeCloverForceQuda(void *mom, double dt, void **x, void **p, double *coeff, double kappa2, double ck,
            int nvector, double multiplicity, void *gauge,
            QudaGaugeParam *gauge_param, QudaInvertParam *inv_param);

  void computeStaggeredForceQuda(void* mom, double dt, double delta, void **x, void *gauge,
         QudaGaugeParam *gauge_param, QudaInvertParam *invert_param);

  void computeHISQForceQuda(void* momentum,
                            long long* flops,
                            const double level2_coeff[6],
                            const double fat7_coeff[6],
                            const void* const w_link,
                            const void* const v_link,
                            const void* const u_link,
                            void** quark,
                            int num,
                            int num_naik,
                            double** coeff,
                            QudaGaugeParam* param);

  void gaussGaugeQuda(long seed);

  void plaqQuda(double plaq[3]);

  void performWuppertalnStep(void *h_out, void *h_in, QudaInvertParam *param, 
                             unsigned int nSteps, double alpha);

  void performAPEnStep(unsigned int nSteps, double alpha);

  void performSTOUTnStep(unsigned int nSteps, double rho);

  void performOvrImpSTOUTnStep(unsigned int nSteps, double rho, double epsilon);

  double qChargeCuda();

  int computeGaugeFixingOVRQuda(void* gauge,
                      const unsigned int gauge_dir,
                      const unsigned int Nsteps,
                      const unsigned int verbose_interval,
                      const double relax_boost,
                      const double tolerance,
                      const unsigned int reunit_interval,
                      const unsigned int stopWtheta,
                      QudaGaugeParam* param,
                      double* timeinfo);
  int computeGaugeFixingFFTQuda(void* gauge,
                      const unsigned int gauge_dir,
                      const unsigned int Nsteps,
                      const unsigned int verbose_interval,
                      const double alpha,
                      const unsigned int autotune,
                      const double tolerance,
                      const unsigned int stopWtheta,
                      QudaGaugeParam* param,
                      double* timeinfo);

  void flushChronoQuda(int index);


  void openMagma();

  void closeMagma();

  void* newDeflationQuda(QudaEigParam *param);

  void destroyDeflationQuda(void *df_instance);

#ifdef __cplusplus
}
#endif

/* #include <quda_new_interface.h> */

#endif /* _QUDA_H */