Runnable updates. IO for Qt and Vol sum in ff.

src/io.jl

@@ -175,8 +175,8 @@ function save_data()
     BDIO_write!(fb,Eoft0)
     BDIO_write!(fb,Qt0)
     for fl in 1:params["Frontflow"]["nsteps"]+1
-        BDIO_write!(fb,Eoft[:,fl])
-        BDIO_write!(fb,Qt[:,fl])
+        BDIO_write!(fb,Eoft[fl,:])
+        BDIO_write!(fb,Qt[fl,:])
     end
 
     for noi in 1:params["Backflow"]["N_noise"]

src/meas.jl

@@ -38,6 +38,7 @@ function load_fields()
     global pphat_t = Array{Float64}(undef,lp.iL[4],params["Frontflow"]["N_noise"],params["Frontflow"]["nsteps"] + 1);
     global pptilde_t = Array{Complex{Float64}}(undef,lp.iL[4],params["Frontflow"]["N_noise"],params["Frontflow"]["nsteps"] + 1);
 
+    global Qteuc = Array{Float64}(undef,lp.iL[4]);
     global Qt = Array{Complex{Float64}}(undef,params["Frontflow"]["nsteps"] + 1,lp.iL[4]);
     global Eoft = Array{Complex{Float64}}(undef,params["Frontflow"]["nsteps"] + 1,lp.iL[4]);
     global Eofpla = Array{Complex{Float64}}(undef,lp.iL[4],lp.npls);
@@ -69,8 +70,8 @@ function Frontflow_pt() # Will be Frontflow
 
     Eoft_plaq(Eofpla,U, gp, lp, ymws)
     Eoft0 .= sum(Eofpla,dims = 2)
-    Qtop(pp_density,U, gp, lp, ymws)
-    Qt0 .= pp_density
+    Qtop(Qteuc,U, gp, lp, ymws)
+    Qt0 .= Qteuc
 
     for noi in 1:params["Frontflow"]["N_noise"]
 
@@ -79,15 +80,12 @@ function Frontflow_pt() # Will be Frontflow
         println(log_file,"CG converged after ",niter," iterations with residue ",CUDA.mapreduce(x -> norm2(x), +, dws.sr))
         flush(log_file)
 
-        pp_density .= Array(norm2.(psi))
-        ap_density .= Array(dot.(psi,dmul.(Gamma{4},psi)))
-        pp_corr_t0[:,noi] .= zero(Float64)
-        ap_corr_t0[:,noi] .= zero(ComplexF64)
-        @timeit "Volume sum" for b in 1:lp.bsz for r in 1:lp.rsz
-            t = point_time((b,r),lp)
-            pp_corr_t0[t,noi] += pp_density[b,r]
-            ap_corr_t0[t,noi] += ap_density[b,r]
-        end end
+        pp_corr_t0[:,noi,tstep] .= zero(Float64)
+        ap_corr_t0[:,noi,tstep] .= zero(ComplexF64)
+        @timeit "Volume sum performance test" begin
+            pp_corr_t0[:,noi,tstep] .= scalar_contraction(psi)
+            ap_corr_t0[:,noi,tstep] .= gammazero_contraction(psi)
+        end
 
         if params["Frontflow"]["t_zero"]>0.0
             _,epslist = flw_adapt(U, psi, int, params["Frontflow"]["t_zero"], gp, dpar, lp, ymws, dws)
@@ -100,8 +98,8 @@ function Frontflow_pt() # Will be Frontflow
             if noi ==1
                 Eoft_plaq(Eofpla,U, gp, lp, ymws)
                 Eoft[tstep,:] .= sum(Eofpla,dims = 2)
-                Qtop(pp_density, U, gp, lp, ymws)
-                Qt[tstep,:] .= pp_density
+                Qtop(Qteuc, U, gp, lp, ymws)
+                Qt[tstep,:] .= Qteuc
             end
 
             pp_corr_t[:,noi,tstep] .= zero(Float64)
@@ -117,19 +115,16 @@ function Frontflow_pt() # Will be Frontflow
         if noi ==1
             Eoft_plaq(Eofpla,U, gp, lp, ymws)
             Eoft[end,:] .= sum(Eofpla,dims = 2)
-            Qtop(pp_density, U, gp, lp, ymws)
-            Qt[end,:] .= pp_density
+            Qtop(Qteuc, U, gp, lp, ymws)
+            Qt[end,:] .= Qteuc
         end
 
-        pp_density .= Array(norm2.(psi))
-        ap_density .= Array(dot.(psi,dmul.(Gamma{4},psi)))
         pp_corr_t[:,noi,end] .= zero(Float64)
         ap_corr_t[:,noi,end] .= zero(ComplexF64)
-        @timeit "Volume sum" for b in 1:lp.bsz for r in 1:lp.rsz
-            t = point_time((b,r),lp)
-            pp_corr_t[t,noi,end] += pp_density[b,r]
-            ap_corr_t[t,noi,end] += ap_density[b,r]
-        end end
+        @timeit "Volume sum performance test" begin
+            pp_corr_t[:,noi,end] .= scalar_contraction(psi)
+            ap_corr_t[:,noi,end] .= gammazero_contraction(psi)
+        end
 
         @timeit "CPU to GPU" copyto!(U,U_CPU)
     end
@@ -313,6 +308,15 @@ function Two_pt_lagrange() # Will be 2pt lagrange mult
         println(log_file,"CG converged after ",niter," iterations with residue ",CUDA.mapreduce(x -> norm2(x), +, dws.sr))
         flush(log_file)
 
+        pp_corr_t0[:,noi,fl] .= zero(Float64)
+        ap_corr_t0[:,noi,fl] .= zero(ComplexF64)
+        @timeit "Volume sum performance test" begin
+            pphat_t0[:,noi,fl] .= -scalar_contraction(psi)
+            pptilde_t0[:,noi,fl] .= gammazero_contraction(psi)
+        end
+
+
+
         _,epslist = flw_adapt(U, psi, int, params["Frontflow"]["t_zero"], gp, dpar, lp, ymws, dws)
         @timeit "GPU to CPU" psit_CPU .= Array(psi)
         @timeit "CPU to GPU" copyto!(U,U_CPU)
@@ -327,35 +331,31 @@ function Two_pt_lagrange() # Will be 2pt lagrange mult
 
         for fl in 1:params["Frontflow"]["nsteps"]
 
-            pphat_t[:,noi,fl] .= zero(Float64)
-            pp_density .= Array(norm2.(psi))
-            pptilde_t[:,noi,fl] .= zero(Float64)
-            ap_density .= Array(dot.(dws.st,psi))
-            @timeit "Volume sum" for b in 1:lp.bsz for r in 1:lp.rsz
-                t = point_time((b,r),lp)
-                pphat_t[t,noi,fl] += -pp_density[b,r]
-                pptilde_t[t,noi,fl] += ap_density[b,r]
-            end end
+            pp_corr_t[:,noi,fl] .= zero(Float64)
+            ap_corr_t[:,noi,fl] .= zero(ComplexF64)
+            @timeit "Volume sum performance test" begin
+                pphat_t[:,noi,fl] .= -scalar_contraction(psi)
+                pptilde_t[:,noi,fl] .= gammazero_contraction(psi)
+            end
             ymws.U1 .= U
             flw(U, psi, int, 1, params["Frontflow"]["epsilon"], gp, dpar, lp, ymws, dws)
             U .= ymws.U1
             flw(U, dws.st, int, 1, params["Frontflow"]["epsilon"], gp, dpar, lp, ymws, dws)
 
         end
-        pphat_t[:,noi,end] .= zero(Float64)
-        pp_density .= Array(norm2.(psi))
-        pptilde_t[:,noi,end] .= zero(Complex{Float64})
-        ap_density .= Array(dot.(dws.st,psi))
-        @timeit "Volume sum" for b in 1:lp.bsz for r in 1:lp.rsz
-            t = point_time((b,r),lp)
-            pphat_t[t,noi,end] += -pp_density[b,r]
-            pptilde_t[t,noi,end] += ap_density[b,r]
-        end end
+        pp_corr_t[:,noi,end] .= zero(Float64)
+        ap_corr_t[:,noi,end] .= zero(ComplexF64)
+        @timeit "Volume sum performance test" begin
+            pphat_t[:,noi,end] .= -scalar_contraction(psi)
+            pptilde_t[:,noi,end] .= gammazero_contraction(psi)
+        end
 
         @timeit "CPU to GPU" copyto!(U,U_CPU)
 
     end
 
+    pphat_t0 .= pphat_t0./prod(lp.iL[1:3])
+    pptilde_t0 .= pptilde_t0./prod(lp.iL[1:3])
     pphat_t .= pphat_t./prod(lp.iL[1:3])
     pptilde_t .= pptilde_t./prod(lp.iL[1:3])