Test    : Silicon Wire with EPM (cplx)
Enabled : Yes

# for wavefunction
Copy : gsphere_input
Executable : ../Visual/gsphere.py
Arguments : gsphere_input gsphere_output

match ; Number of G-vectors ; GREP(gsphere_output, "ng = ", 3); 670
match ; FFT grid (min)      ; GREP(gsphere_output, "minimal", 6); 7
match ; FFT grid (FFTW)     ; GREP(gsphere_output, "factors ", 4, 1); 8
match ; Max G-vector index  ; GREP(gsphere_output, "Max G-vector indices", 7); 3

Copy : kgrid_WFN_fi.in

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

match ; Space group (lattice)          ; GREP(kgrid_WFN_fi.log, "symmetries of the Bravais lattice", 3, 2);  123
match ; Number of symmetries (lattice) ; GREP(kgrid_WFN_fi.log, "symmetries of the Bravais lattice", 1, 1);  16
match ; Number of symmetries (no FFT)  ; GREP(kgrid_WFN_fi.log, "symmetries of the crystal without FFT grid", 1, 1);  16
match ; Space group (crystal)          ; GREP(kgrid_WFN_fi.log, "symmetries of the crystal with FFT grid", 3, 2);  123
match ; Number of symmetries (crystal) ; GREP(kgrid_WFN_fi.log, "symmetries of the crystal with FFT grid", 1, 1);  8
match ; Number of k-points for WFN_fi  ; GREP(kgrid_WFN_fi.log, "k-points in the irreducible wedge", 1, 1);  5
match ; z-coord of 5th k-point (cart); LINE(kgrid_WFN_fi.log, -2, 4);  0.352987939
match ; z-coord of 1st k-point       ; LINE(kgrid_WFN_fi.out,  3, 3);  0.0
match ; Weight  of 1st k-point       ; LINE(kgrid_WFN_fi.out,  3, 4);  1.0
match ; z-coord of 4th k-point       ; LINE(kgrid_WFN_fi.out,  6, 3);  0.375
match ; Weight  of 4th k-point       ; LINE(kgrid_WFN_fi.out,  6, 4);  2.0
match ; z-coord of 5th k-point       ; LINE(kgrid_WFN_fi.out,  7, 3);  0.5
match ; Weight  of 5th k-point       ; LINE(kgrid_WFN_fi.out,  7, 4);  1.0

Copy : kgrid_WFNq.in

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

match ; Number of k-points for WFNq  ; GREP(kgrid_WFNq.log, "k-points folded with", 1, 1);  4
match ; z-coord of 1st k-point       ; LINE(kgrid_WFNq.out,  3, 3);  0.001
match ; Weight  of 1st k-point       ; LINE(kgrid_WFNq.out,  3, 4);  1.0
match ; z-coord of 4th k-point       ; LINE(kgrid_WFNq.out,  6, 3);  0.751
match ; Weight  of 4th k-point       ; LINE(kgrid_WFNq.out,  6, 4);  1.0

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

Precision : 1.5e-14
match ; Space group number        ; GREP(WFN.out,   "Space group", 3, 0); 123
match ; Eigenvalue  1 at k-pt 1   ; GREP(WFN.out,   "kpoint          1", 2,  1); -22.7451981509064503
match ; Eigenvalue 10 at k-pt 1   ; GREP(WFN.out,   "kpoint          1", 2, 10); -13.4232566259019226
match ; Eigenvalue 18 at k-pt 2   ; GREP(WFN.out,   "kpoint          2", 2, 18); -10.5193317124682491

Output : WFNq.out
Input  : WFNq.in PIPE

match ; Eigenvalue  1 at k-pt 1   ; GREP(WFNq.out,   "kpoint          1", 2,  1); -22.7451978284758418
match ; Eigenvalue  1 at k-pt 2   ; GREP(WFNq.out,   "kpoint          2", 2,  1); -22.6909471161069973
match ; Eigenvalue  4 at k-pt 3   ; GREP(WFNq.out,   "kpoint          3", 2,  4); -16.7827159195502915

Output : WFN_fi.out
Input  : WFN_fi.in PIPE

match ; Eigenvalue  1 at k-pt 1   ; GREP(WFN_fi.out, "kpoint          1", 2, 1);  -22.7451981509064503
match ; Eigenvalue  4 at k-pt 1   ; GREP(WFN_fi.out, "kpoint          1", 2, 4);  -16.8576271095923254
match ; Eigenvalue  6 at k-pt 7   ; GREP(WFN_fi.out, "kpoint          7", 2, 6);  -14.1409635385841579

Executable : wfn_time_reversal.x
Arguments : B WFN_time WFN > wfn_time_reversal.out

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

Precision : 1e-13
match ; Re chi(q1,0,0)              ; LINE(chi_converge.dat, 14, 2) ; -0.12129963E-09
match ; Re chi(q1,Gmax,Gmax)        ; LINE(chi_converge.dat, 14, 4) ; -0.20763480E-03
match ; Re chi(q1,Gmax,Gmax) extrap ; LINE(chi_converge.dat, 14, 5) ; -0.27235789E-03
match ; Re chi(q3,0,0)              ; LINE(chi_converge.dat, 38, 2) ; -0.87794542E-04
match ; Re chi(q3,Gmax,Gmax)        ; LINE(chi_converge.dat, 38, 4) ; -0.10971997E-03
match ; epsilonInv Head             ; GREP(epsilon.log, "inverse epsilon", 7, 3); 0.98978256

Command : mv epsilon.log eps_elements.log

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

Precision : 1e-13
match ; Re chi(q1,0,0)              ; LINE(chi_converge.dat, 14, 2) ; -0.12129963E-09
match ; Re chi(q1,Gmax,Gmax)        ; LINE(chi_converge.dat, 14, 4) ; -0.20763480E-03
match ; Re chi(q1,Gmax,Gmax) extrap ; LINE(chi_converge.dat, 14, 5) ; -0.27235789E-03
match ; Re chi(q3,0,0)              ; LINE(chi_converge.dat, 38, 2) ; -0.87794542E-04
match ; Re chi(q3,Gmax,Gmax)        ; LINE(chi_converge.dat, 38, 4) ; -0.10971997E-03
match ; epsilonInv Head             ; GREP(epsilon.log, "inverse epsilon", 7, 3); 0.98978256

Command : mv epsilon.log eps_matrix.log

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

Precision : 1e-13
match ; Re chi(q1,0,0)              ; LINE(chi_converge.dat, 14, 2) ; -0.12129963E-09
match ; Re chi(q1,Gmax,Gmax)        ; LINE(chi_converge.dat, 14, 4) ; -0.20763480E-03
match ; Re chi(q1,Gmax,Gmax) extrap ; LINE(chi_converge.dat, 14, 5) ; -0.27235789E-03
match ; Re chi(q3,0,0)              ; LINE(chi_converge.dat, 38, 2) ; -0.87794542E-04
match ; Re chi(q3,Gmax,Gmax)        ; LINE(chi_converge.dat, 38, 4) ; -0.10971997E-03
match ; epsilonInv Head             ; GREP(epsilon.log, "inverse epsilon", 7, 3); 0.98978256

Command : mv epsilon.log eps_disk.log
Command : mv epsilon.inp eps_disk.inp
Command : mv WFN WFN_inner

Copy : sig_GPP.inp sigma.inp
Command : echo "frequency_dependence 0" >> sigma.inp

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

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);  -232.921337
match ; n2, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 4);  -17.496894
match ; n2, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 4);   0.587526
match ; n2, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1",  6, 4);  -1.030896
match ; n2, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 4);  -250.861612

match ; n5, k1 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   1",  2, 7);  -203.077825
match ; n5, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 7);  -3.697117
match ; n5, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 7);   0.648427
match ; n5, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1",  6, 7);  -1.230217
match ; n5, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 7);  -207.356741
match ; n5, k1 QP Renormalization   ; GREP(sigma_hp.log, "ik =   1", 11, 7);     1.000000

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);  -232.921337
match ; n2, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 4);  -17.496894
match ; n2, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 4);   0.258267
match ; n2, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1", 11, 4);  -0.233332
match ; n2, k1 CH + Static Remainder; GREP(sigma_hp.log, "ik =   1",  6, 4);  -0.392360
match ; n2, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 4);  -250.531348

match ; n5, k1 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   1",  2, 7);  -203.077825
match ; n5, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 7);  -3.697117
match ; n5, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 7);   0.372254
match ; n5, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1", 11, 7);  -0.568239
match ; n5, k1 CH + Static Remainder; GREP(sigma_hp.log, "ik =   1",  6, 7);  -0.771732
match ; n5, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 7);  -207.149224
match ; n5, k1 Linear QPP Correction; GREP(sigma_hp.log, "ik =   1", 14, 7);  -206.946984

Command : mv sigma_hp.log sig_hp_GPP.log

Executable : sigma.cplx.x
Output : sig_GPP_avg.out
Input  : sig_GPP_avg.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);  -32.921337
match ; n2, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 4);  -17.496894
match ; n2, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 4);   0.258267
match ; n2, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1",  6, 4);  -0.233332
match ; n2, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 4);  -50.372510

match ; n5, k1 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   1",  2, 7);  -3.077825
match ; n5, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 7);  -3.697117
match ; n5, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 7);   0.372254
match ; n5, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1",  6, 7);  -0.568239
match ; n5, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 7);  -6.946984

Command : mv sigma_hp.log sig_hp_GPP_avg.log

Command : ln -s WFN_inner WFN_outer

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

Precision : 2e-5
match ; k-point 1 z-coordinate      ; GREP(sigma_hp.log, "ik =   1",  5, 0);     0.000000
match ; n4, k1 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   1",  2, 3);  -229.359681
match ; n4, k1 Corrected Eigenvalue ; GREP(sigma_hp.log, "ik =   1",  3, 3);   116.252255
match ; n4, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 3);   -19.684534
match ; n4, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 3);    -0.027669
match ; n4, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1", 11, 3);     0.182902
match ; n4, k1 CH + Static Remainder; GREP(sigma_hp.log, "ik =   1",  6, 3);     0.020401
match ; n4, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 3);  -248.502665

match ; n5, k1 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   1",  2, 4);  -203.077825
match ; n5, k1 Corrected Eigenvalue ; GREP(sigma_hp.log, "ik =   1",  3, 4);  -243.833390
match ; n5, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 4);    -3.703831
match ; n5, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 4);     0.446956
match ; n5, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1", 11, 4);    -0.328729
match ; n5, k1 CH + Static Remainder; GREP(sigma_hp.log, "ik =   1",  6, 4);    -0.532296
match ; n5, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 4);  -207.273617

Command : mv sigma_hp.log sig_hp_GPP_ca.log
Command : mv WFN_inner WFN_co

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

Precision : 1e-10
match ; max head ; GREP(kernel.out, "maximum: head       ", 3); 1.000000000000004
#match ; max wing ; GREP(kernel.out, "         wing       ", 2); BAD
#match ; max body ; GREP(kernel.out, "         body       ", 2); BAD
match ; max x    ; GREP(kernel.out, "       x        ", 2);  27.606775886939268

# 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); 96
match ; Eigenvalue 1           ; LINE(eigenvalues.dat,  5, 1);  0.19711910E+02
Precision : 1e-5
match ; Transition mtxel 1     ; LINE(eigenvalues.dat,  5, 2);  0.19159372E+01
match ; Eigenvalue 73          ; LINE(eigenvalues.dat, 77, 1);  0.38603718E+02
match ; Transition mtxel 73    ; LINE(eigenvalues.dat, 77, 2); 0.54179475E-03
match ; absorp0 energy 2878    ; LINE(absorption_noeh.dat, 2832, 1); 28.270000000
match ; absorp0 eps2 2878      ; LINE(absorption_noeh.dat, 2832, 2); 0.063289176
match ; absorp0 eps1 2878      ; LINE(absorption_noeh.dat, 2832, 3); 1.025213237
match ; absorp0 dos 2878       ; LINE(absorption_noeh.dat, 2832, 4); 0.046968251
match ; absorp energy 1972     ; LINE(absorption_eh.dat, 1976, 1); 19.710000000
match ; absorp eps2 1972       ; LINE(absorption_eh.dat, 1976, 2);  0.384383955
match ; absorp eps1 1972       ; LINE(absorption_eh.dat, 1976, 3);  1.011096986
match ; absorp dos 1972        ; LINE(absorption_eh.dat, 1976, 4);  0.027702078
Precision : 1e-10
match ; Sum rule               ; GREP(absp_mom.out, "Sum rule (BSE)", 5);  0.26469869599970303

# BSE with momentum operator
# Reading vmtxel and dtmat
Executable : absorption.cplx.x
Output : absp_readvm.out
Input  : absp_readvm.inp absorption.inp

Precision : 0.0001
match ; Number of eigenvalues  ; GREP(eigenvalues.dat, "# neig  = ", 4); 96
match ; Eigenvalue 1           ; LINE(eigenvalues.dat,  5, 1);  0.19711910E+02
Precision : 1e-5
match ; Transition mtxel 1     ; LINE(eigenvalues.dat,  5, 2);  0.19159372E+01
match ; Eigenvalue 73          ; LINE(eigenvalues.dat, 77, 1);  0.38603718E+02
match ; Transion mtxel 73      ; LINE(eigenvalues.dat, 77, 2); 0.54179475E-03
match ; absorp0 energy 2878    ; LINE(absorption_noeh.dat, 2832, 1); 28.270000000
match ; absorp0 eps2 2878      ; LINE(absorption_noeh.dat, 2832, 2); 0.063289176
match ; absorp0 eps1 2878      ; LINE(absorption_noeh.dat, 2832, 3); 1.025213237
match ; absorp0 dos 2878       ; LINE(absorption_noeh.dat, 2832, 4); 0.046968251
match ; absorp energy 1972     ; LINE(absorption_eh.dat, 1976, 1); 19.710000000
match ; absorp eps2 1972       ; LINE(absorption_eh.dat, 1976, 2);  0.384383955
match ; absorp eps1 1972       ; LINE(absorption_eh.dat, 1976, 3);  1.011096986
match ; absorp dos 1972        ; LINE(absorption_eh.dat, 1976, 4);  0.027702078
Precision : 1e-10
match ; Sum rule               ; GREP(absp_mom.out, "Sum rule (BSE)", 5);  0.26469869599970303

# BSE with momentum operator
# absorption_eh only
Executable : absorption.cplx.x
Output : absp_absorp.out
Input  : absp_absorp.inp absorption.inp

Precision : 1e-5
match ; absorp energy 1972     ; LINE(absorption_eh.dat, 1976, 1); 19.710000000
match ; absorp eps2 1972       ; LINE(absorption_eh.dat, 1976, 2);  0.384383967
match ; absorp eps1 1972       ; LINE(absorption_eh.dat, 1976, 3);  1.011096092
match ; absorp dos 1972        ; LINE(absorption_eh.dat, 1976, 4);  0.027702079

# BSE with momentum operator
# absorption_noeh only
Executable : absorption.cplx.x
Output : absp_absorp0.out
Input  : absp_absorp0.inp absorption.inp

Precision : 1e-5
match ; absorp0 energy 2878    ; LINE(absorption_noeh.dat, 2832, 1); 28.270000000
match ; absorp0 eps2 2878      ; LINE(absorption_noeh.dat, 2832, 2); 0.063289176
match ; absorp0 eps1 2878      ; LINE(absorption_noeh.dat, 2832, 3); 1.025213237
match ; absorp0 dos 2878       ; LINE(absorption_noeh.dat, 2832, 4); 0.046968251

Executable : eqp.py
Arguments : eqp1 sig_hp_GPP.log eqp_co.dat > eqp.out

match ; LDA Eigenvalue         ; LINE(eqp_co.dat, 14, 3); -231.946595000
match ; GW Eigenvalue          ; LINE(eqp_co.dat, 14, 4); -249.426416000

# Eqp Interpolation
Executable : inteqp.cplx.x
Output : inteqp.out
Input  : inteqp.inp

Precision : 1e-5
match ; LDA Eigenvalue         ; LINE(bandstructure.dat,  4, 6);  -231.66918
match ; GW Eigenvalue          ; LINE(bandstructure.dat,  4, 7); -249.214100003
match ; Difference             ; LINE(bandstructure.dat,  4, 8);   -17.544911000
match ; eqp.dat k1 band 8      ; LINE(eqp.dat,    8, 4);  -186.667687542
match ; eqp.dat k2 band 2      ; LINE(eqp.dat,   10, 4); -249.214100003

# BSE with mom operator
# comm_disk
Executable : absorption.cplx.x
Output : absp_disk.out
Input  : absp_disk.inp absorption.inp

Precision : 1e-5
Precision : 0.0001
match ; Number of eigenvalues  ; GREP(eigenvalues.dat, "# neig  = ", 4); 96
match ; Eigenvalue 1           ; LINE(eigenvalues.dat,  5, 1);  0.35302609E+02
Precision : 1e-5
match ; Transition mtxel 1     ; LINE(eigenvalues.dat,  5, 2);  0.13784312E-24
match ; RPA Eigenvalue 1       ; GREP(eigenvalues_noeh.dat,  '1     1     1     1', 5);  0.41870625E+02
match ; RPA Transition mtxel 1 ; GREP(eigenvalues_noeh.dat,  '1     1     1     1', 6);  0.24186613E+00
match ; RPA Eigenvalue 2       ; GREP(eigenvalues_noeh.dat,  '3     4     1     1', 5);  0.60644387E+02
match ; RPA Transition mtxel 2 ; GREP(eigenvalues_noeh.dat,  '3     4     1     1', 6);  0.72058996E-01

Command : rm eqp.dat
Command : rm bandstructure.dat

# BSE with mom operator and eqp_co_corrections
Executable : absorption.cplx.x
Output : absp_eqp.out
Input  : absp_eqp.inp absorption.inp

Precision : 0.0001
match ; Number of eigenvalues  ; GREP(eigenvalues.dat, "# neig  = ", 4); 96
match ; Eigenvalue 1           ; LINE(eigenvalues.dat,  5, 1);  0.35302609E+02
Precision : 1e-5
match ; Transition mtxel 1     ; LINE(eigenvalues.dat,  5, 2);  0.48112644E-24

match ; LDA Eigenvalue         ; LINE(bandstructure.dat,  4, 6);  -231.66918
match ; GW Eigenvalue          ; LINE(bandstructure.dat,  4, 7); -249.214100003
match ; Difference             ; LINE(bandstructure.dat,  4, 8);   -17.544911000
match ; eqp.dat k1 band 8      ; LINE(eqp.dat,    8, 4);  -186.667687542
match ; eqp.dat k2 band 2      ; LINE(eqp.dat,   10, 4); -249.214100003

Command : ln -s WFN_fi WFNq_fi

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

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

Executable: ../Visual/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); 61
match ; grid value   ; GREP(xct.000001.xsf, "BEGIN_DATAGRID_3D", 1, 8);  1.92006E-01

# PlotXct with restrict_kpoints
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 =", 4, 0); 19.711910437233488
match ; k-pts norm  ; GREP(plotxct.out, "Wfn norm (restricted sum):", 5, 0); 0.95206031114892464
match ; Grid Value  ; GREP(xct.000001_s1.a3Dr, "#    real", 3, 4); 4.04207E-01
match ; Hole z pos  ; GREP(xct.000001_s1.a3Dr, "# rh = ",   6, 0); 0.89
match ; Spin        ; GREP(xct.000001_s1.a3Dr, "# spin = ", 4, 0); 1

Executable : summarize_eigenvectors.cplx.x
Processors : serial
Output : summarize_eigenvectors.out
Input : summarize_eigenvectors.inp

match ; v1 -> c1 wtot    ; GREP(summarize_eigenvectors.out, "25.1681", 3, 2); 0.99106
match ; v1 -> c1 wmax    ; GREP(summarize_eigenvectors.out, "25.1681", 4, 2); 0.65113
match ; v1 -> c1 main k  ; GREP(summarize_eigenvectors.out, "25.1681", 5, 2); 1
match ; Gamma contribution ; LINE(exciton_01, 3, 4); 0.01282
