tm_times_HoppingMatrix

bgq/bgq_HoppingMatrix.c

@@ -14,6 +14,7 @@
 #include "bgq_dispatch.h"
 #include "bgq_comm.h"
 #include "bgq_workers.h"
+#include "bgq_stdoperators.h"
 
 #include "../update_backward_gauge.h"
 
@@ -309,3 +310,20 @@ void Hopping_Matrix_nocom(const int ieo, spinor * const l, spinor * const k) {
 	bgq_HoppingMatrix(ieo, targetfield, sourcefield, hm_nocom);
 }
 #endif
+
+
+#if BGQ_REPLACE
+void tm_times_Hopping_Matrix(const int ieo, spinor * const l, spinor * const k, double complex const cfactor) {
+	bgq_weylfield_controlblock *targetfield = bgq_translate_spinorfield(l);
+	bgq_weylfield_controlblock *sourcefield = bgq_translate_spinorfield(k);
+
+#ifdef _GAUGE_COPY
+	if(g_update_gauge_copy) {
+		update_backward_gauge(g_gauge_field);
+	}
+#endif
+
+	bgq_HoppingMatrix(ieo, targetfield, sourcefield, 0);
+	bgq_spinorfield_cmul_double(targetfield, ieo, targetfield, cfactor);
+}
+#endif

bgq/bgq_spinorfield.c

@@ -1906,10 +1906,10 @@ void spinorfield_linalg_wrr_invert(const spinor *legacyField_out, const spinor *
 	bgq_weylfield_controlblock *field_in1 = bgq_translate_spinorfield(legacyField_in1);
 	bgq_weylfield_controlblock *field_in2 = bgq_translate_spinorfield(legacyField_in2);
 
-	tristate isOdd = tristate_combine(field_in1->isOdd, tristate_invert(field_in2->isOdd));
-	bgq_spinorfield_prepareRead(field_in1, isOdd, false, false, false, false, true);
-	bgq_spinorfield_prepareRead(field_in2, tristate_invert(isOdd), false, false, false, false, true);
-	bgq_spinorfield_prepareWrite(field_out, !isOdd, ly_legacy, false);
+	tristate isOdd = tristate_combine(tristate_invert(field_in1->isOdd), field_in2->isOdd);
+	bgq_spinorfield_prepareRead(field_in1, tristate_invert(isOdd), false, false, false, false, true);
+	bgq_spinorfield_prepareRead(field_in2, isOdd, false, false, false, false, true);
+	bgq_spinorfield_prepareWrite(field_out, tristate_invert(isOdd), ly_legacy, false);
 }
 
 

bgq/bgq_stdoperators.c

@@ -33,6 +33,26 @@ static inline void bgq_site_set(bgq_su3_spinor_params(*target), bgq_su3_spinor_p
 }
 
 
+static inline void bgq_site_cmul(bgq_su3_spinor_params(*target), bgq_su3_spinor_params(spinor), bgq_params(qc), ucoord ic) {
+	bgq_su3_spinor_decl(result);
+
+	bgq_mul(result_v0_c0, qc, spinor_v0_c0);
+	bgq_mul(result_v0_c1, qc, spinor_v0_c1);
+	bgq_mul(result_v0_c2, qc, spinor_v0_c2);
+	bgq_mul(result_v1_c0, qc, spinor_v1_c0);
+	bgq_mul(result_v1_c1, qc, spinor_v1_c1);
+	bgq_mul(result_v1_c2, qc, spinor_v1_c2);
+	bgq_mul(result_v2_c0, qc, spinor_v2_c0);
+	bgq_mul(result_v2_c1, qc, spinor_v2_c1);
+	bgq_mul(result_v2_c2, qc, spinor_v2_c2);
+	bgq_mul(result_v3_c0, qc, spinor_v3_c0);
+	bgq_mul(result_v3_c1, qc, spinor_v3_c1);
+	bgq_mul(result_v3_c2, qc, spinor_v3_c2);
+
+	bgq_su3_spinor_mov(*target, result);
+}
+
+
 static inline void bgq_site_imul(bgq_su3_spinor_params(*target), bgq_su3_spinor_params(spinor), bgq_params(qz), bgq_params(qw), ucoord ic) {
 	bgq_su3_spinor_decl(result);
 
@@ -65,12 +85,42 @@ static inline void bgq_site_cmul_plain_add(bgq_su3_spinor_params(*target), bgq_s
 }
 
 
+static inline void bgq_site_gamma5(bgq_su3_spinor_params(*target), bgq_su3_spinor_params(spinor), ucoord ic) {
+	bgq_su3_spinor_decl(result);
+
+	bgq_mov(result_v0_c0, spinor_v0_c0);
+	bgq_mov(result_v0_c1, spinor_v0_c1);
+	bgq_mov(result_v0_c2, spinor_v0_c2);
+	bgq_mov(result_v1_c0, spinor_v1_c0);
+	bgq_mov(result_v1_c1, spinor_v1_c1);
+	bgq_mov(result_v1_c2, spinor_v1_c2);
+	bgq_neg(result_v2_c0, spinor_v2_c0);
+	bgq_neg(result_v2_c1, spinor_v2_c1);
+	bgq_neg(result_v2_c2, spinor_v2_c2);
+	bgq_neg(result_v3_c0, spinor_v3_c0);
+	bgq_neg(result_v3_c1, spinor_v3_c1);
+	bgq_neg(result_v3_c2, spinor_v3_c2);
+
+	bgq_su3_spinor_mov(*target, result);
+}
+
+
 
 #define OPERATOR_NAME bgq_spinorfield_diff
 #define OPERATOR_ARGFIELDS 2
 #define OPERATOR_VECSITEFUNC bgq_site_diff
 #include "bgq_operator.inc.c"
 
+#if BGQ_REPLACE
+void diff(spinor * const Q, const spinor * const R, const spinor * const S, const int N) {
+	assert(N == VOLUME/2);
+	bgq_weylfield_controlblock *targetfield = bgq_translate_spinorfield(Q);
+	bgq_weylfield_controlblock *sourcefield1 = bgq_translate_spinorfield(R);
+	bgq_weylfield_controlblock *sourcefield2 = bgq_translate_spinorfield(S);
+
+	bgq_spinorfield_diff_double(targetfield, tri_unknown, sourcefield1, sourcefield2);
+}
+#endif
 
 #define OPERATOR_NAME bgq_spinorfield_set
 #define OPERATOR_ARGFIELDS 0
@@ -204,3 +254,41 @@ void assign_mul_add_r(spinor * const R, const double c, const spinor * const S,
 	bgq_spinorfield_cmul_plain_add(targetfield, tri_unknown, targetfield, sourcefield, c);
 }
 #endif
+
+
+#define OPERATOR_NAME bgq_spinorfield_gamma5
+#define OPERATOR_ARGFIELDS 1
+#define OPERATOR_VECSITEFUNC bgq_site_gamma5
+#include "bgq_operator.inc.c"
+
+#if BGQ_REPLACE
+void gamma5(spinor * const l, spinor * const k, const int V) {
+	assert(V == VOLUME/2);
+	bgq_weylfield_controlblock *targetfield = bgq_translate_spinorfield(l);
+	bgq_weylfield_controlblock *sourcefield = bgq_translate_spinorfield(k);
+
+	bgq_spinorfield_gamma5_double(targetfield, tri_unknown, sourcefield);
+}
+#endif
+
+
+
+
+#define OPERATOR_NAME bgq_spinorfield_cmul_raw
+#define OPERATOR_ARGFIELDS 1
+#define OPERATOR_VECSITEFUNC bgq_site_cmul
+#define OPERATOR_EXTRAPARMS bgq_params(qc)
+#define OPERATOR_EXTRAARGS bgq_vars(qc)
+#include "bgq_operator.inc.c"
+
+void bgq_spinorfield_cmul_double(bgq_weylfield_controlblock *targetfield, tristate isOdd, bgq_weylfield_controlblock *sourcefield, double c) {
+	bgq_vector4double_decl(qc);
+	bgq_cconst(qc, c, c);
+	bgq_spinorfield_cmul_raw_double(targetfield, isOdd, sourcefield, bgq_vars(qc));
+}
+
+void bgq_spinorfield_cmul_float(bgq_weylfield_controlblock *targetfield, tristate isOdd, bgq_weylfield_controlblock *sourcefield, double c) {
+	bgq_vector4double_decl(qc);
+	bgq_cconst(qc, c, c);
+	bgq_spinorfield_cmul_raw_float(targetfield, isOdd, sourcefield, bgq_vars(qc));
+}

bgq/bgq_stdoperators.h

@@ -16,4 +16,7 @@ void bgq_spinorfield_diff_float(bgq_weylfield_controlblock *targetfield, tristat
 
 void bgq_spinorfield_copy(bgq_weylfield_controlblock *target, bgq_spinorfield_layout targetLayout, bgq_weylfield_controlblock *source);
 
+void bgq_spinorfield_cmul_double(bgq_weylfield_controlblock *targetfield, tristate isOdd, bgq_weylfield_controlblock *sourcefield, double c);
+void bgq_spinorfield_cmul_float(bgq_weylfield_controlblock *targetfield, tristate isOdd, bgq_weylfield_controlblock *sourcefield, double c);
+
 #endif /* BGQ_STDOPERATORS_H_ */

gamma.c

@@ -71,6 +71,7 @@ void gamma3( const int Q,  const int P, const int V){
     _gamma3(g_spinor_field[Q][ix],g_spinor_field[P][ix]);
   }
 }
+#if !BGQ_REPLACE
 void gamma5(spinor * const l, spinor * const k, const int V){
 	spinorfield_linalg_wr(l, k);
   int ix;
@@ -84,6 +85,7 @@ void gamma5(spinor * const l, spinor * const k, const int V){
     _vector_minus_assign((*r).s3,(*s).s3);
   }
 }
+#endif
 void gamma5new(spinor * const Q, spinor * const P, const int V){ 
 	spinorfield_linalg_wr(Q, P);
   int ix; 

linalg/diff.c

@@ -22,6 +22,8 @@
  *     Makes the difference (*Q) = (*R) - (*S)
  *******************************************************************************/
 
+#if !BGQ_REPLACE
+
 #ifdef HAVE_CONFIG_H
 # include<config.h>
 #endif
@@ -341,3 +343,6 @@ void diff_su3vect(su3_vector * const Q,su3_vector * const R,su3_vector * const S
 #endif
 }
 #endif
+
+#endif
+

tm_times_Hopping_Matrix.c

@@ -27,6 +27,8 @@
  *
  ****************************************************************/
 
+#if !BGQ_REPLACE
+
 #ifdef HAVE_CONFIG_H
 # include<config.h>
 #endif
@@ -160,4 +162,4 @@ void tm_times_Hopping_Matrix(const int ieo, spinor * const l, spinor * const k,
 }
 #endif
 
-
+#endif