Test    : GaAs with EPM (cplx)
Enabled : Yes

# for density
Copy : gsphere_input
Executable : gsphere.py
Arguments : gsphere_input gsphere_output

match ; Number of G-vectors ; GREP(gsphere_output, "ng = ", 3); 1459
match ; Kinetic energy      ; GREP(gsphere_output, "1411       6     3    -1", 8); 41.704354286
match ; FFT grid            ; GREP(gsphere_output, "minimal", 4); 15
match ; Max G-vector index  ; GREP(gsphere_output, "max g-vector indices", 6); 7

Copy : kgrid.in

Executable : kgrid.x
Processors : serial
Arguments : kgrid.in kgrid.out kgrid.log

match ; Space group (lattice)       ; GREP(kgrid.log, "symmetries of the Bravais lattice", 3, 2);  225
match ; Space group (crystal)       ; GREP(kgrid.log, "symmetries of the crystal with FFT grid", 3, 2);  216
match ; Number of symmetries        ; GREP(kgrid.log, "symmetries of the crystal with FFT grid", 1, 1);   24
match ; Number of k-points for WFN  ; GREP(kgrid.log, "k-points in the irreducible wedge", 1, 1);  4
match ; z-coord of first k-point    ; LINE(kgrid.out,  3, 3);  0.25
match ; Weight  of first k-point    ; LINE(kgrid.out,  3, 4);  1.0
match ; z-coord of third k-point    ; LINE(kgrid.out,  5, 3);  0.75
match ; Weight  of third k-point    ; LINE(kgrid.out,  5, 4);  3.0

Executable : epm2bgw.x
Processors : serial
Output : WFN.out
Input  : WFN.in PIPE

Precision : 8e-15
match ; Eigenvalue  1 at k-pt 1   ; GREP(WFN.out,   "kpoint          1", 2,  1); -0.2710614199849328
match ; Eigenvalue 10 at k-pt 1   ; GREP(WFN.out,   "kpoint          1", 2, 10);  1.2565373697755460
match ; Eigenvalue 18 at k-pt 2   ; GREP(WFN.out,   "kpoint          2", 2, 18);  2.1322637363008994

Output : WFNq.out
Input  : WFNq.in PIPE

match ; Eigenvalue  1 at k-pt 1   ; GREP(WFNq.out,   "kpoint          1", 2,  1); -0.2707683365493481
match ; Eigenvalue  1 at k-pt 2   ; GREP(WFNq.out,   "kpoint          2", 2,  1); -0.2713538843958779
match ; Eigenvalue  4 at k-pt 3   ; GREP(WFNq.out,   "kpoint          3", 2,  4);  0.4737569992229542

Output : WFN_co.out
Input  : WFN_co.in PIPE

match ; Eigenvalue  1 at k-pt 1   ; GREP(WFN_co.out, "kpoint          1", 2,  1); -0.3114476911953253
match ; Eigenvalue  1 at k-pt 3   ; GREP(WFN_co.out, "kpoint          3", 2,  1); -0.1716036669587518
match ; Eigenvalue 18 at k-pt 3   ; GREP(WFN_co.out, "kpoint          3", 2, 18);  2.1502954231769573

Output : WFN_fi.out
Input  : WFN_fi.in PIPE

match ; Eigenvalue  1 at k-pt 1   ; GREP(WFN_fi.out, "kpoint          1", 2, 1);  -0.2989224970633751
match ; Eigenvalue  4 at k-pt 1   ; GREP(WFN_fi.out, "kpoint          1", 2, 4);   0.5813903551954895
match ; Eigenvalue  6 at k-pt 7   ; GREP(WFN_fi.out, "kpoint          7", 2, 6);   0.9544171216722384

Output : WFNq_fi.out
Input  : WFNq_fi.in PIPE

match ; Eigenvalue  1 at k-pt 2   ; GREP(WFNq_fi.out, "kpoint          2", 2, 1);  -0.2319702906363918
match ; Eigenvalue  4 at k-pt 5   ; GREP(WFNq_fi.out, "kpoint          5", 2, 4);   0.4610540689492043
match ; Eigenvalue  3 at k-pt 20  ; GREP(WFNq_fi.out, "kpoint         20", 2, 3);   0.3807148446582930

Executable : epsilon.cplx.x
Processors : 4
Output : eps_static.out
Input  : epsilon.inp

Precision : 1e-13
match ; Re chi(q1,0,0)       ; LINE(chi_converge.dat, 16, 2) ; -0.57760029E-06
match ; Re chi(q1,Gmax,Gmax) ; LINE(chi_converge.dat, 16, 4) ; -0.76795260E-03
match ; Re chi(q3,0,0)       ; LINE(chi_converge.dat, 50, 2) ; -0.24928474E-01
match ; Re chi(q3,Gmax,Gmax) ; LINE(chi_converge.dat, 50, 4) ; -0.12781391E-02
Precision : 3e-11
match ; epsilon q1 ; GREP(eps_static.out, "q-pt      1: Head of Epsilon",         7, 0); 14.9234176133623
Precision : 2e-13
match ; eps inv q1 ; GREP(eps_static.out, "q-pt      1: Head of Epsilon Inverse", 8, 0); 0.0770203148897139
match ; epsilon q2 ; GREP(eps_static.out, "q-pt      2: Head of Epsilon",         7, 0); 2.97351207417238
match ; eps inv q2 ; GREP(eps_static.out, "q-pt      2: Head of Epsilon Inverse", 8, 0); 0.390620255028178
match ; epsilon q3 ; GREP(eps_static.out, "q-pt      3: Head of Epsilon",         7, 0); 2.8027495957472
match ; eps inv q3 ; GREP(eps_static.out, "q-pt      3: Head of Epsilon Inverse", 8, 0); 0.396981083283834
match ; epsilonInv Head      ; GREP(epsilon.log, "inverse epsilon", 7, 1); 0.07702031

Command : mv epsilon.log eps_static.log

# For tricking eps0sym we link eps0mat.h5 to eps0mat
Command : if [ -f eps0mat.h5 ]; then ln -s eps0mat.h5 eps0mat ; fi

# We are not going to use the symmetrized eps0mat. It makes very little difference here.
Executable : eps0sym.cplx.x
Arguments : eps0mat eps0mat_sym > eps0sym.out

Precision : 0.0011
match ; max symmetry discrepancy ; GREP(eps0sym.out, "The max error in your matrix is", 8, 0); 0.69184E+02

Executable : sigma.cplx.x
Output : sig_HF.out
Input  : sig_HF.inp sigma.inp

# These numbers should be identical to the full GW Sigma calculation below.
Precision : 2e-6
match ; n2, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 4); -14.252939
match ; n5, k2 Exchange             ; GREP(sigma_hp.log, "ik =   2",  4, 7);  -4.676235

Command : mv sigma_hp.log sig_hp_HF.log

Executable : sigma.cplx.x
Output : sig_COHSEX.out
Input  : sig_COHSEX.inp sigma.inp

match ; n2, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 4);   9.187328
match ; n2, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1",  6, 4);  -8.424123
match ; n2, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 4);  -5.444661

match ; n5, k2 Screened Exchange    ; GREP(sigma_hp.log, "ik =   2",  5, 7);   2.328117
match ; n5, k2 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   2",  6, 7);  -7.534184
match ; n5, k2 Linear QP Correction ; GREP(sigma_hp.log, "ik =   2", 10, 7);   0.023357

Command : mv sigma_hp.log sig_hp_COHSEX.log

Executable : sigma.cplx.x
Output : sig_GPP.out
Input  : sig_GPP.inp sigma.inp

Precision : 2e-5
match ; k-point 1 z-coordinate      ; GREP(sigma_hp.log, "ik =   1",  5, 0);   0.000000
match ; n2, k1 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   1",  2, 4);  8.045074
match ; n2, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 4); -14.252939
match ; n2, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 4);   9.330292
match ; n2, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1", 11, 4);  -6.607926
match ; n2, k1 CH + Static Remainder; GREP(sigma_hp.log, "ik =   1",  6, 4);  -7.415517
match ; n2, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 4);  -1.885657

match ; k-point 2 z-coordinate      ; GREP(sigma_hp.log, "ik =   2",  5, 0);   0.500000
match ; n5, k2 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   2",  2, 7);   9.905659
match ; n5, k2 Exchange             ; GREP(sigma_hp.log, "ik =   2",  4, 7);  -4.676235
match ; n5, k2 Screened Exchange    ; GREP(sigma_hp.log, "ik =   2",  5, 7);   2.736528
match ; n5, k2 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   2", 11, 7);  -6.215881
match ; n5, k2 CH + Static Remainder; GREP(sigma_hp.log, "ik =   2",  6, 7);  -6.884029
match ; n5, k2 Linear QP Correction ; GREP(sigma_hp.log, "ik =   2", 10, 7);   2.827626

Command : mv sigma_hp.log sig_hp_GPP.log

Command : ln -s WFN_inner WFN_co

Executable : kernel.cplx.x
Processors : 4
Output : kernel.out
Input  : kernel.inp

Precision : 1e-8
match ; Norm of head; GREP(kernel.out, " - Head :", 4); 1.807840663558E+0001
match ; Norm of wing; GREP(kernel.out, " - Wing :", 4); 3.102148535343E+0000
match ; Norm of body; GREP(kernel.out, " - Body :", 4); 2.227852114743E+0001
match ; Norm of x   ; GREP(kernel.out, " - X    :", 4); 2.207582471582E+0001

# BSE with velocity operator
Executable : absorption.cplx.x
Output : absp.out
Input  : absorption.inp

Precision : 0.0001
match ; Number of eigenvalues  ; GREP(eigenvalues.dat, "# neig  = ", 4); 432
match ; Eigenvalue 1           ; LINE(eigenvalues.dat,  5, 1);  0.22832093E+01
Precision : 5e-5
match ; Transition mtxel 1     ; LINE(eigenvalues.dat,  5, 2);  0.62405315E+02
match ; Eigenvalue 10          ; LINE(eigenvalues.dat, 14, 1);  0.37584270E+01
Precision : 5e-4
match ; Transition mtxel 10    ; LINE(eigenvalues.dat, 14, 2);  0.38363936E+01
Precision : 2e-7
match ; Sum rule               ; GREP(absp.out, "Sum rule (BSE)", 5);  0.84269128363059242

# PlotXct
#Copy : eigenvectors
#Executable : plotxct.cplx.x
#Output : plotxct.out
#Input  : plotxct.inp

#Precision : 1.1e-6
#match ; Grid Value  ; GREP(xct.000001_s1.a3Dr, "#    real", 3, 1); 5.44781E-02
#match ; Hole z pos  ; GREP(xct.000001_s1.a3Dr, "# rh = ",   6, 0); 0.000000
#match ; Spin        ; GREP(xct.000001_s1.a3Dr, "# spin = ", 4, 0); 1

#Executable: volume.py
#Arguments: WFN_fi.in tbpw xct.000001_s1.a3Dr a3dr xct.000001.xsf xsf true re true

#match ; z grid steps ; GREP(xct.000001.xsf, "BEGIN_DATAGRID_3D", 3, 1); 25
#match ; grid value   ; GREP(xct.000001.xsf, "BEGIN_DATAGRID_3D", 1, 8); -2.90442E-02

# PlotXct with restrict_kpoints
#Copy : eigenvectors
#Executable : plotxct.cplx.x
#Command : echo "restrict_kpoints 6" >> plotxct.inp
#Output : plotxct.out
#Input  : NONE

#Precision : 1.1e-6
#match ; Energy      ; GREP(plotxct.out, "Excitation energy", 3, 0); 2.283209280
#match ; k-pts norm  ; GREP(plotxct.out, "Norm squared of the exciton", 4, 1); .989273986556286
#match ; Grid Value  ; GREP(xct.000001_s1.a3Dr, "#    real", 3, 1); 4.90135E-02
#match ; Hole z pos  ; GREP(xct.000001_s1.a3Dr, "# rh = ",   6, 0); 0.000000
#match ; Spin        ; GREP(xct.000001_s1.a3Dr, "# spin = ", 4, 0); 1

# NLO Two Photon
#Command : mv WFNq_fi WFNq_fi_orig
#Command : ln -s WFN_fi WFNq_fi
#Executable : nonlinearoptics.cplx.x
#Processors : 4
#Output : nonlinearoptics_tp.out
#Input  : nonlinearoptics_tp.inp nonlinearoptics.inp

#Precision : 0.0001
#match ; Eigenvalue 2 ; LINE(osc.dat, 2, 2);  0.24826351E+01
#match ; Osc 2 ; LINE(osc.dat, 2, 3);  0.10176089E+01
#match ; 2P Osc 2 ; LINE(osc.dat, 2, 4);  0.60930980E+00
#match ; 2P Max ; LINE(osc.dat, 2, 5); 2
#match ; 2P Max Val ; LINE(osc.dat, 2, 6);  0.29485796E+01

#Command : mv absorption_nl.dat absorp_tp.dat
#Command : mv osc.dat osc.dat_tp

# BSE with momentum operator
# The eigenvalues would be identical to velocity operator in q->0 limit, and the transition
# matrix elements should be very close, since EPM is a local potential.
Executable : absorption.cplx.x
Output : absp_mom.out
Input  : absp_mom.inp absorption.inp

Precision : 0.0001
match ; Number of eigenvalues  ; GREP(eigenvalues.dat, "# neig  = ", 4); 432
match ; Eigenvalue 1           ; LINE(eigenvalues.dat,  5, 1);  0.22843439E+01
Precision : 5e-5
match ; Transition mtxel 1     ; LINE(eigenvalues.dat,  5, 2);  0.61884231E+02
match ; Eigenvalue 10          ; LINE(eigenvalues.dat, 14, 1);  0.37517114E+01
Precision : 6e-4
match ; Transition mtxel 10    ; LINE(eigenvalues.dat, 14, 2);  0.29784519E+01
Precision : 2e-7
match ; Sum rule               ; GREP(absp_mom.out, "Sum rule (BSE)", 5);  0.84210556744510257

Command : echo "local_fields" >> absorption.inp
Executable : absorption.cplx.x
Output : absp_localfields.out
Input : NONE

Precision : 2e-8
match ; Static epsilon 1 ; GREP(absorption_eh.dat, " 0.000000000 ", 3);  11.103418564
match ; Peak   epsilon 2 ; GREP(absorption_eh.dat, " 3.850000000 ", 2); 10.395226413
match ; Peak   epsilon 1 ; GREP(absorption_eh.dat, " 3.850000000 ", 3); 10.502244752

# BSE with momentum operator cell averaging
Executable : absorption.cplx.x
Output : absp_mom_ca.out
Input  : absp_mom_ca.inp absorption.inp

Precision : 0.0001
match ; Number of eigenvalues  ; GREP(eigenvalues.dat, "# neig  = ", 4); 432
match ; Eigenvalue 1           ; LINE(eigenvalues.dat,  5, 1);  0.22843439E+01
Precision : 5e-5
match ; Transition mtxel 1     ; LINE(eigenvalues.dat,  5, 2);  0.61884231E+02
match ; Eigenvalue 10          ; LINE(eigenvalues.dat, 14, 1);  0.37517114E+01
Precision : 5e-4
match ; Transition mtxel 10    ; LINE(eigenvalues.dat, 14, 2);  0.29780772E+01
Precision : 2e-7
match ; Sum rule               ; GREP(absp_mom_ca.out, "Sum rule (BSE)", 5);  0.84210556744510257

Executable : absorption.cplx.x
Output : absp_haydock.out
Input : absp_haydock.inp absorption.inp

Precision : 2e-8
match ; Static epsilon 1 ; GREP(absorption_eh.dat, " 0.000000000 ", 3);  14.692986371
match ; Peak   epsilon 2 ; GREP(absorption_eh.dat, " 3.850000000 ", 2); 16.642171164
match ; Peak   epsilon 1 ; GREP(absorption_eh.dat, " 3.850000000 ", 3); -4.919587516

Command : mv absorption.inp absp.inp; sed s/use_velocity/use_dos/ absp.inp > absorption.inp
Executable : absorption.cplx.x
Output : absp_jdos.out
Input : NONE

Precision : 2e-8
match ; Static epsilon 1 ; GREP(absorption_eh.dat, " 0.000000000 ", 3);  9.385792157
match ; Peak   epsilon 2 ; GREP(absorption_eh.dat, " 3.850000000 ", 2); 3.335970890
match ; Peak   epsilon 1 ; GREP(absorption_eh.dat, " 3.850000000 ", 3); 13.018053496

# Finite Q:
#wavefunctions
Executable : epm2bgw.x
Processors : serial
Output : WFNq_co.out
Input  : WFNq_co.in PIPE

Precision : 8e-15
match ; Eigenvalue  1 at k-pt 1   ; GREP(WFNq_co.out,   "kpoint          1", 2,  1);  -0.3114430293864866
match ; Eigenvalue  2 at k-pt 1   ; GREP(WFNq_co.out,   "kpoint          1", 2, 10);  0.5263513980291089
match ; Eigenvalue  1 at k-pt 2   ; GREP(WFNq_co.out,   "kpoint          2", 2, 18);  0.4348444811367879


# Full frequency

Executable: scissors2eqp.x
Arguments: WFNq 0 0 1.25 0 0 1.25 > scissors2eqp_q.out
Command : mv eqp.dat eqp_q.dat
Executable: scissors2eqp.x
Arguments: WFN 0 0 1.25 0 0 1.25 > scissors2eqp.out

Command : ln -s WFN_inner WFN_outer
Executable : epsilon.cplx.x
Processors : 4
Output : eps_ff.out
Input  : eps_ff.inp epsilon.inp

Precision : 7e-12
match ; Re eps q1          ; GREP(eps_ff.out, "q-pt      1: Head of Epsilon",          7, 0); 5.436965954321662E+000
Precision : 3e-13
match ; Im eps q1          ; GREP(eps_ff.out, "q-pt      1: Head of Epsilon",          8, 0); 0.0
match ; Re epsinv q1       ; GREP(eps_ff.out, "q-pt      1: Head of Epsilon Inverse",  8, 0); 1.956208342139506E-001
match ; Im epsinv q1       ; GREP(eps_ff.out, "q-pt      1: Head of Epsilon Inverse",  9, 0); 0.0

Precision : 1e-5
match ; epsilon    Head 30.0 eV Re ; LINE(EpsDyn, 9, 2) ; 3.454744E-01
match ; epsilon    Head 30.0 eV Im ; LINE(EpsDyn, 9, 3) ; 4.484178E-01
match ; epsilonInv Head 30.0 eV Re ; LINE(EpsInvDyn, 21, 2) ; 5.738705E-01
match ; epsilonInv Head 30.0 eV Im ; LINE(EpsInvDyn, 21, 3) ; -5.091707E-01

Command : mv epsilon.log eps_ff.log

# Uses WFN_outer
Executable: scissors2eqp.x
Arguments: WFN_outer 0 0 1.5 0 0 1.5 > scissors2eqp.out
Command: mv eqp.dat eqp_outer.dat
Executable: scissors2eqp.x
Arguments: WFN_inner 0 0 1.25 0 0 1.25 > scissors2eqp.out

Executable : sigma.cplx.x
Processors : 4
Output : sig_ff.out
Input  : sig_ff.inp sigma.inp

Precision : 2e-5
match ; n2, k1 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   1", 2,  4);   8.045074
match ; n2, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1", 4,  4); -14.252939
match ; n2, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1", 5,  4);   7.129196
match ; n2, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1", 6,  4);  -3.380932
match ; n2, k1 Imag SX              ; GREP(sigma_hp.log, "ik =   1", 1,  5);   1.122251
match ; n2, k1 Imag CH              ; GREP(sigma_hp.log, "ik =   1", 2,  5);  -1.574468
match ; n5, k1 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   1", 2, 10);   9.243551
match ; n5, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1", 4, 10); -5.410015
match ; n5, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1", 5, 10);   1.835675
match ; n5, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1", 6, 10);  -3.016443
match ; n5, k1 Imag SX              ; GREP(sigma_hp.log, "ik =   1", 1, 11);   0.889475
match ; n5, k1 Imag CH              ; GREP(sigma_hp.log, "ik =   1", 2, 11);  -1.356371
match ; n2, k3 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   3", 2,  4);   1.932049
match ; n2, k3 Exchange             ; GREP(sigma_hp.log, "ik =   3", 4,  4); -14.226161
match ; n2, k3 Screened Exchange    ; GREP(sigma_hp.log, "ik =   3", 5,  4);   7.871204
match ; n2, k3 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   3", 6,  4);  -3.967903
match ; n2, k3 Imag SX              ; GREP(sigma_hp.log, "ik =   3", 1,  5);   3.794042
match ; n2, k3 Imag CH              ; GREP(sigma_hp.log, "ik =   3", 2,  5);  -3.671611
match ; n5, k3 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   3", 2, 10);   10.574825
match ; n5, k3 Exchange             ; GREP(sigma_hp.log, "ik =   3", 4, 10); -4.202341
match ; n5, k3 Screened Exchange    ; GREP(sigma_hp.log, "ik =   3", 5, 10);   1.469481
match ; n5, k3 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   3", 6, 10);  -2.675255
match ; n5, k3 Imag SX              ; GREP(sigma_hp.log, "ik =   3", 1, 11);   0.419615
match ; n5, k3 Imag CH              ; GREP(sigma_hp.log, "ik =   3", 2, 11);  -0.845961

Command : mv sigma_hp.log sig_hp_ff.log

Executable : epsilon.cplx.x
Processors : 4
Output : eps_ff_parallel_freq.out
Input  : eps_ff_parallel_freq.inp epsilon.inp

# numbers below should be all the same as eps_ff.inp results and number of processors must always be greater than nfreq_group in input file
Precision : 7e-12
match ; Re eps q1          ; GREP(eps_ff_parallel_freq.out, "q-pt      1: Head of Epsilon",          7, 0); 6.13955386367811
Precision : 3e-13
match ; Im eps q1          ; GREP(eps_ff_parallel_freq.out, "q-pt      1: Head of Epsilon",          8, 0); 0.0
match ; Re epsinv q1       ; GREP(eps_ff_parallel_freq.out, "q-pt      1: Head of Epsilon Inverse",  8, 0); 0.180539609777306
match ; Im epsinv q1       ; GREP(eps_ff_parallel_freq.out, "q-pt      1: Head of Epsilon Inverse",  9, 0); 0.0
Precision : 1e-5
match ; epsilon    Head 30.0 eV Re ; LINE(EpsDyn, 9, 2) ; 0.695678
match ; epsilon    Head 30.0 eV Im ; LINE(EpsDyn, 9, 3) ; 0.116462
match ; epsilonInv Head 30.0 eV Re ; LINE(EpsInvDyn, 21, 2) ; 1.342573
match ; epsilonInv Head 30.0 eV Im ; LINE(EpsInvDyn, 21, 3) ; -0.304618

Command : mv epsilon.log eps_ff_parallel_freq.log

Executable : epsilon.cplx.x
Processors : 4
Output : eps_ff_elements.out
Input  : eps_ff_elements.inp epsilon.inp

# should be all the same as eps_ff.inp results
Precision : 7e-12
match ; Re eps q1          ; GREP(eps_ff_elements.out, "q-pt      1: Head of Epsilon",          7, 0); 6.13955386367811
Precision : 3e-13
match ; Im eps q1          ; GREP(eps_ff_elements.out, "q-pt      1: Head of Epsilon",          8, 0); 0.0
match ; Re epsinv q1       ; GREP(eps_ff_elements.out, "q-pt      1: Head of Epsilon Inverse",  8, 0); 0.180539609777306
match ; Im epsinv q1       ; GREP(eps_ff_elements.out, "q-pt      1: Head of Epsilon Inverse",  9, 0); 0.0
Precision : 1e-5
match ; epsilon    Head 30.0 eV Re ; LINE(EpsDyn, 9, 2) ; 0.695678
match ; epsilon    Head 30.0 eV Im ; LINE(EpsDyn, 9, 3) ; 0.116462
match ; epsilonInv Head 30.0 eV Re ; LINE(EpsInvDyn, 21, 2) ; 1.342573
match ; epsilonInv Head 30.0 eV Im ; LINE(EpsInvDyn, 21, 3) ; -0.304618

Command : mv epsilon.log eps_ff_elements.log

Executable : epsilon.cplx.x
Processors : 4
Output : eps_ff_parallel_freq_elements.out
Input  : eps_ff_parallel_freq_elements.inp epsilon.inp

# numbers below should be all the same as eps_ff.inp results and number of processors must always be greater than nfreq_group in input file
Precision : 7e-12
match ; Re eps q1          ; GREP(eps_ff_parallel_freq_elements.out, "q-pt      1: Head of Epsilon",          7, 0); 6.13955386367811
Precision : 3e-13
match ; Im eps q1          ; GREP(eps_ff_parallel_freq_elements.out, "q-pt      1: Head of Epsilon",          8, 0); 0.0
match ; Re epsinv q1       ; GREP(eps_ff_parallel_freq_elements.out, "q-pt      1: Head of Epsilon Inverse",  8, 0); 0.180539609777306
match ; Im epsinv q1       ; GREP(eps_ff_parallel_freq_elements.out, "q-pt      1: Head of Epsilon Inverse",  9, 0); 0.0
Precision : 1e-5
match ; epsilon    Head 30.0 eV Re ; LINE(EpsDyn, 9, 2) ; 0.695678
match ; epsilon    Head 30.0 eV Im ; LINE(EpsDyn, 9, 3) ; 0.116462
match ; epsilonInv Head 30.0 eV Re ; LINE(EpsInvDyn, 21, 2) ; 1.342573
match ; epsilonInv Head 30.0 eV Im ; LINE(EpsInvDyn, 21, 3) ; -0.304618

Command : mv epsilon.log eps_ff_parallel_freq_elements.log

Command : mv WFN_fi WFN_fi_bse

Executable : epm2bgw.x
Processors : serial
Output : WFN_kpath.out
Input  : WFN_kpath.in PIPE

Precision : 8e-15
match ; Eigenvalue  1 at k-pt  71 ; GREP(WFN_kpath.out,   "kpoint         71", 2, 1); -0.2169735672217880
match ; Eigenvalue  4 at k-pt  71 ; GREP(WFN_kpath.out,   "kpoint         71", 2, 4);  0.5276099594344549
match ; Eigenvalue  9 at k-pt 126 ; GREP(WFN_kpath.out,   "kpoint        126", 2, 9);  1.4610417868264702

Executable : eqp.py
Arguments : eqp1 sig_hp_GPP.log eqp_co.dat > eqp.out 
 
match ; k-point 2 z-coord ; LINE(eqp_co.dat, 10, 3);  0.500
match ; MF Eigenvalue     ; LINE(eqp_co.dat, 14, 3);  7.161621000
match ; GW Eigenvalue     ; LINE(eqp_co.dat, 14, 4); -2.522081000

Executable : wfn_rho_vxc_info.x
Processors : serial
Arguments : WFN_fi > WFN_kpath_info.out

match ; Number of G-vectors ; GREP(WFN_kpath_info.out, "Number of G-vectors", 4, 0); 1459
match ; k-grid x            ; GREP(WFN_kpath_info.out, "k-grid:",             2, 0);    0

Executable : inteqp.cplx.x
Processors : 4
Output : inteqp.out
Input : inteqp.inp

Precision : 1e-5
match ; Cartesian kx coord  ; LINE(bandstructure.dat,    6, 3);   0.27419
match ; MF Eigenvalue       ; LINE(bandstructure.dat,    6, 6);  -2.925582651
match ; GW Eigenvalue       ; LINE(bandstructure.dat,    6, 7); -11.935396800
match ; Difference          ; LINE(bandstructure.dat,    6, 8);  -9.009814020
match ; Cartesian kx coord  ; LINE(bandstructure.dat, 1010, 3);   0.40813
match ; MF Eigenvalue       ; LINE(bandstructure.dat, 1010, 6);  15.496296952
match ; GW Eigenvalue       ; LINE(bandstructure.dat, 1010, 7);   9.642694605
match ; Difference          ; LINE(bandstructure.dat, 1010, 8);  -5.853603030
# below must match result in bandstructure.dat!
match ; eqp.dat last band MF; LINE(eqp.dat, 1134, 3);  15.496296952
match ; eqp.dat last band GW; LINE(eqp.dat, 1134, 4);   9.642694605

# Full frequency(Shishkin and Kresse 2006)
Executable : epsilon.cplx.x
Processors : 4
Output : eps_ff1_elements.out
Input  : eps_ff1_elements.inp epsilon.inp

Precision : 7e-12
match ; Re eps q1          ; GREP(eps_ff1_elements.out, "q-pt      1: Head of Epsilon",          7, 0); 6.08611192290713
Precision : 3e-13
match ; Im eps q1          ; GREP(eps_ff1_elements.out, "q-pt      1: Head of Epsilon",          8, 0); 0.0
match ; Re epsinv q1       ; GREP(eps_ff1_elements.out, "q-pt      1: Head of Epsilon Inverse",  8, 0); 0.182134209423543
match ; Im epsinv q1       ; GREP(eps_ff1_elements.out, "q-pt      1: Head of Epsilon Inverse",  9, 0); 0.0
Precision : 1e-5
match ; epsilon    Head 30.0 eV Re ; LINE(EpsDyn, 9, 2) ; 0.695417
match ; epsilon    Head 30.0 eV Im ; LINE(EpsDyn, 9, 3) ; 0.116774
match ; epsilonInv Head 30.0 eV Re ; LINE(EpsInvDyn, 21, 2) ; 1.342430
match ; epsilonInv Head 30.0 eV Im ; LINE(EpsInvDyn, 21, 3) ; -0.305876 

Command : mv epsilon.log eps_ff1_elements.log
