transfer.h

Go to the documentation of this file.

#ifndef _TRANSFER_H
#define _TRANSFER_H

#include <color_spinor_field.h>
#include <dirac_quda.h>
#include <vector>

namespace quda {

  class Transfer {

  private:

    const std::vector<ColorSpinorField*> &B;

    const int Nvec;

    ColorSpinorField *V_h;

    ColorSpinorField *V_d;

    ColorSpinorField *fine_tmp_h;

    ColorSpinorField *fine_tmp_d;

    ColorSpinorField *coarse_tmp_h; 

    ColorSpinorField *coarse_tmp_d; 

    int *geo_bs;

    int *fine_to_coarse_h;

    int *coarse_to_fine_h;

    int *fine_to_coarse_d;

    int *coarse_to_fine_d;

    int spin_bs;

    int *spin_map;

    QudaSiteSubset site_subset;

    QudaParity parity;

    bool enable_gpu;

    mutable bool use_gpu;

    void fillV(ColorSpinorField &V);

    void createGeoMap(int *geo_bs);

    //template <class Complex, class FieldOrder>
    //void blockOrderV(Complex *out, const FieldOrder &in, int *geo_bs, int spin_bs);

    //template <class FieldOrder, class Complex>
    //void undoblockOrderV(FieldOrder &out, Complex *in, int *geo_bs, int spin_bs);   

  //template <class Complex>
    //void blockGramSchmidt(Complex *v, int nBlocks, int Nc, int blockSize);

    void createSpinMap(int spin_bs);

    mutable double flops_;

    TimeProfile &profile;

  public:

    Transfer(const std::vector<ColorSpinorField*> &B, int Nvec, int *geo_bs, int spin_bs,
       bool enable_gpu, TimeProfile &profile);

    virtual ~Transfer();

    void P(ColorSpinorField &out, const ColorSpinorField &in) const;

    void R(ColorSpinorField &out, const ColorSpinorField &in) const;

    const ColorSpinorField& Vectors(QudaFieldLocation location=QUDA_CPU_FIELD_LOCATION) const {
      return (location == QUDA_CUDA_FIELD_LOCATION) ? *V_d : *V_h;
    }

    int nvec() const {return Nvec;}

    int Spin_bs() const {return spin_bs;}

    const int *Geo_bs() const {return geo_bs;}
    
    void setTransferGPU(bool use_gpu) const { this->use_gpu = use_gpu; }

    void setSiteSubset(QudaSiteSubset site_subset, QudaParity parity);

    double flops() const;
  };

  void FillV(ColorSpinorField &V, const std::vector<ColorSpinorField*> &B, int Nvec);

  void BlockOrthogonalize(ColorSpinorField &V, int Nvec, const int *geo_bs, 
        const int *fine_to_coarse, int spin_bs);

  void Prolongate(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &v, 
      int Nvec, const int *fine_to_coarse, const int *spin_map,
      int parity=QUDA_INVALID_PARITY);

  void Restrict(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &v, 
    int Nvec, const int *fine_to_coarse, const int *coarse_to_fine, const int *spin_map,
    int parity=QUDA_INVALID_PARITY);
  

} // namespace quda
#endif // _TRANSFER_H