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>

#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; 
  } 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 qudaInit(QudaInitArgs_t input);

  void qudaSetLayout(QudaLayout_t layout);

  void qudaFinalize();

  void* qudaAllocatePinned(size_t bytes);

  void qudaFreePinned(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,
      const double tadpole,
      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,
      const double tadpole,
      void* source,
      void* solution,
      double* const final_resid,
      double* const final_rel_resid,
      int* num_iters);

  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,
                      const double tadpole,
                      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,
      const double tadpole,
      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,
      const double tadpole,
      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** 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 qudaUpdateU(int precision,
       double eps,
       QudaMILCSiteArg_t *arg);

  double qudaMomAction(int precision,
           void *momentum);

  void qudaRephase(int prec, void *gauge, int flag, double i_mu);

  void qudaUnitarizeSU3(int prec, double tol, QudaMILCSiteArg_t *arg);

  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