quda_milc_interface.h

Go to the documentation of this file.

#ifndef _QUDA_MILC_INTERFACE_H
#define _QUDA_MILC_INTERFACE_H
 
#include <enum_quda.h>
#include <quda.h>
 
#if __COMPUTE_CAPABILITY__ >= 600
#define USE_QUDA_MANAGED 1
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
  typedef struct {
    void *site; 
    void *link; 
    size_t link_offset; 
    void *mom; 
    size_t mom_offset; 
    size_t size; 
  } QudaMILCSiteArg_t;
 
  typedef struct {
    int max_iter; 
    QudaParity evenodd; 
    int mixed_precision; 
    double boundary_phase[4]; 
    int make_resident_solution; 
    int use_resident_solution; 
    QudaInverterType solver_type; 
    double tadpole; 
    double naik_epsilon; 
  } QudaInvertArgs_t;
 
  typedef struct {
    QudaPrecision  prec_ritz;
    int nev;
    int max_search_dim;
    int deflation_grid;
    double tol_restart;
 
    int eigcg_max_restarts;
    int max_restart_num;
    double inc_tol;
    double eigenval_tol;
 
    QudaExtLibType   solver_ext_lib;
    QudaExtLibType   deflation_ext_lib;
 
    QudaFieldLocation location_ritz;
    QudaMemoryType    mem_type_ritz;
 
    char *vec_infile;
    char *vec_outfile;
 
  } QudaEigArgs_t;
 
 
  typedef struct {
    const int* latsize; 
    const int* machsize; 
    int device; 
  } QudaLayout_t;
 
 
  typedef struct {
    QudaVerbosity verbosity; 
    QudaLayout_t layout; 
  } QudaInitArgs_t; // passed to the initialization struct
 
 
  typedef struct {
    int reunit_allow_svd;         
    int reunit_svd_only;          
    double reunit_svd_abs_error;  
    double reunit_svd_rel_error;  
    double force_filter;          
  } QudaHisqParams_t;
 
 
  typedef struct {
    int su3_source;          
    int use_pinned_memory;   
  } QudaFatLinkArgs_t;
 
  void qudaSetMPICommHandle(void *mycomm);
 
  void qudaInit(QudaInitArgs_t input);
 
  void qudaSetLayout(QudaLayout_t layout);
 
  void qudaFinalize();
 
  void* qudaAllocatePinned(size_t bytes);
 
  void qudaFreePinned(void *ptr);
 
  void *qudaAllocateManaged(size_t bytes);
 
  void qudaFreeManaged(void *ptr);
 
  void qudaHisqParamsInit(QudaHisqParams_t hisq_params);
 
  void qudaLoadKSLink(int precision,
                      QudaFatLinkArgs_t fatlink_args,
                      const double act_path_coeff[6],
                      void* inlink,
                      void* fatlink,
                      void* longlink);
 
  void qudaLoadUnitarizedLink(int precision,
                              QudaFatLinkArgs_t fatlink_args,
                              const double path_coeff[6],
                              void* inlink,
                              void* fatlink,
                              void* ulink);
 
 
  void qudaDslash(int external_precision,
                  int quda_precision,
                  QudaInvertArgs_t inv_args,
                  const void* const milc_fatlink,
                  const void* const milc_longlink,
                  void* source,
                  void* solution,
                  int* num_iters);
 
  void qudaDDInvert(int external_precision,
                    int quda_precision,
                    double mass,
                    QudaInvertArgs_t inv_args,
                    double target_residual,
                    double target_fermilab_residual,
                    const int * const domain_overlap,
                    const void* const fatlink,
                    const void* const longlink,
                    void* source,
                    void* solution,
                    double* const final_residual,
                    double* const final_fermilab_residual,
                    int* num_iters);
 
 
 
  void qudaInvert(int external_precision,
                  int quda_precision,
                  double mass,
                  QudaInvertArgs_t inv_args,
                  double target_residual,
                  double target_fermilab_residual,
                  const void* const milc_fatlink,
                  const void* const milc_longlink,
                  void* source,
                  void* solution,
                  double* const final_resid,
                  double* const final_rel_resid,
                  int* num_iters);
 
  void *qudaMultigridCreate(int external_precision, int quda_precision, double mass, QudaInvertArgs_t inv_args,
                            const void *const milc_fatlink, const void *const milc_longlink,
                            const char *const mg_param_file);
 
  void qudaInvertMG(int external_precision, int quda_precision, double mass, QudaInvertArgs_t inv_args,
                    double target_residual, double target_fermilab_residual, const void *const milc_fatlink,
                    const void *const milc_longlink, void *mg_pack_ptr, int mg_rebuild_type, void *source,
                    void *solution, double *const final_residual, double *const final_fermilab_residual, int *num_iters);
 
  void qudaMultigridDestroy(void *mg_pack_ptr);
 
  void qudaInvertMsrc(int external_precision,
                      int quda_precision,
                      double mass,
                      QudaInvertArgs_t inv_args,
                      double target_residual,
                      double target_fermilab_residual,
                      const void* const fatlink,
                      const void* const longlink,
                      void** sourceArray,
                      void** solutionArray,
                      double* const final_residual,
                      double* const final_fermilab_residual,
                      int* num_iters,
                      int num_src);
 
  void qudaMultishiftInvert(
      int external_precision,
      int precision,
      int num_offsets,
      double* const offset,
      QudaInvertArgs_t inv_args,
      const double* target_residual,
      const double* target_fermilab_residual,
      const void* const milc_fatlink,
      const void* const milc_longlink,
      void* source,
      void** solutionArray,
      double* const final_residual,
      double* const final_fermilab_residual,
      int* num_iters);
 
  void qudaEigCGInvert(
      int external_precision,
      int quda_precision,
      double mass,
      QudaInvertArgs_t inv_args,
      double target_residual,
      double target_fermilab_residual,
      const void* const fatlink,
      const void* const longlink,
      void* source,
      void* solution,
      QudaEigArgs_t eig_args,
      const int rhs_idx,//current rhs
      const int last_rhs_flag,//is this the last rhs to solve?
      double* const final_residual,
      double* const final_fermilab_residual,
      int *num_iters);
 
  void qudaCloverInvert(int external_precision,
                        int quda_precision,
                        double kappa,
                        double clover_coeff,
                        QudaInvertArgs_t inv_args,
                        double target_residual,
                        double target_fermilab_residual,
                        const void* milc_link,
                        void* milc_clover,
                        void* milc_clover_inv,
                        void* source,
                        void* solution,
                        double* const final_residual,
                        double* const final_fermilab_residual,
                        int* num_iters);
 
  void qudaEigCGCloverInvert(
      int external_precision,
      int quda_precision,
      double kappa,
      double clover_coeff,
      QudaInvertArgs_t inv_args,
      double target_residual,
      double target_fermilab_residual,
      const void* milc_link,
      void* milc_clover,
      void* milc_clover_inv,
      void* source,
      void* solution,
      QudaEigArgs_t eig_args,
      const int rhs_idx,//current rhs
      const int last_rhs_flag,//is this the last rhs to solve?
      double* const final_residual,
      double* const final_fermilab_residual,
      int *num_iters);
 
 
  void qudaLoadGaugeField(int external_precision,
                          int quda_precision,
                          QudaInvertArgs_t inv_args,
                          const void* milc_link) ;
 
  void qudaFreeGaugeField();
 
  void qudaLoadCloverField(int external_precision,
                           int quda_precision,
                           QudaInvertArgs_t inv_args,
                           void* milc_clover,
                           void* milc_clover_inv,
                           QudaSolutionType solution_type,
                           QudaSolveType solve_type,
                           double clover_coeff,
                           int compute_trlog,
                           double *trlog) ;
 
  void qudaFreeCloverField();
 
  void qudaCloverMultishiftInvert(int external_precision,
      int quda_precision,
      int num_offsets,
      double* const offset,
      double kappa,
      double clover_coeff,
      QudaInvertArgs_t inv_args,
      const double* target_residual,
      const void* milc_link,
      void* milc_clover,
      void* milc_clover_inv,
      void* source,
      void** solutionArray,
      double* const final_residual,
      int* num_iters
      );
 
  void qudaHisqForce(int precision,
                     int num_terms,
                     int num_naik_terms,
                     double dt,
                     double** coeff,
                     void** quark_field,
                     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* const milc_momentum);
 
  void qudaGaugeForce(int precision,
                      int num_loop_types,
                      double milc_loop_coeff[3],
                      double eb3,
                      QudaMILCSiteArg_t *arg);
 
  void qudaGaugeForcePhased(int precision, int num_loop_types, double milc_loop_coeff[3], double eb3,
                            QudaMILCSiteArg_t *arg, int phase_in);
 
  void qudaUpdateU(int precision,
                   double eps,
                   QudaMILCSiteArg_t *arg);
 
  void qudaUpdateUPhased(int precision, double eps, QudaMILCSiteArg_t *arg, int phase_in);
 
  void qudaUpdateUPhasedPipeline(int precision, double eps, QudaMILCSiteArg_t *arg, int phase_in, int want_gaugepipe);
 
  void qudaMomLoad(int precision, QudaMILCSiteArg_t *arg);
 
  void qudaMomSave(int precision, QudaMILCSiteArg_t *arg);
 
  double qudaMomAction(int precision, QudaMILCSiteArg_t *arg);
 
  void qudaRephase(int prec, void *gauge, int flag, double i_mu);
 
  void qudaUnitarizeSU3(int prec, double tol, QudaMILCSiteArg_t *arg);
 
  void qudaUnitarizeSU3Phased(int prec, double tol, QudaMILCSiteArg_t *arg, int phase_in);
 
  void qudaCloverForce(void *mom, double dt, void **x, void **p, double *coeff, double kappa,
                       double ck, int nvec, double multiplicity, void *gauge, int precision,
                       QudaInvertArgs_t inv_args);
 
  void qudaCloverTrace(void* out,
                       void* dummy,
                       int mu,
                       int nu);
 
 
  void qudaCloverDerivative(void* out,
                            void* gauge,
                            void* oprod,
                            int mu,
                            int nu,
                            double coeff,
                            int precision,
                            int parity,
                            int conjugate);
 
 
  void* qudaCreateExtendedGaugeField(void* gauge,
                                     int geometry,
                                     int precision);
 
  void* qudaResidentExtendedGaugeField(void* gauge,
                                       int geometry,
                                       int precision);
 
  void* qudaCreateGaugeField(void* gauge,
                             int geometry,
                             int precision);
 
  void qudaSaveGaugeField(void* gauge,
                          void* inGauge);
 
  void qudaDestroyGaugeField(void* gauge);
 
 
  void qudaGaugeFixingOVR( const int precision,
    const unsigned int gauge_dir,
    const int Nsteps,
    const int verbose_interval,
    const double relax_boost,
    const double tolerance,
    const unsigned int reunit_interval,
    const unsigned int stopWtheta,
    void* milc_sitelink
    );
 
 
  void qudaGaugeFixingFFT( int precision,
    unsigned int gauge_dir,
    int Nsteps,
    int verbose_interval,
    double alpha,
    unsigned int autotune,
    double tolerance,
    unsigned int stopWtheta,
    void* milc_sitelink
    );
 
  /* The below declarations are for removed functions from prior versions of QUDA. */
 
  void qudaAsqtadForce(int precision,
                       const double act_path_coeff[6],
                       const void* const one_link_src[4],
                       const void* const naik_src[4],
                       const void* const link,
                       void* const milc_momentum);
 
  void qudaComputeOprod(int precision,
                        int num_terms,
                        int num_naik_terms,
                        double** coeff,
                        double scale,
                        void** quark_field,
                        void* oprod[3]);
 
#ifdef __cplusplus
}
#endif
 
 
#endif // _QUDA_MILC_INTERFACE_H