Test    : GaAs with EPM (cplx)
Enabled : Yes

# for density
Copy : gsphere_input
Executable : ../Visual/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", 5); 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.2710614199849326
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(q1,0,0)       ; LINE(chi_converge.dat, 50, 2) ; -0.24928474E-01
match ; Re chi(q1,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); -13.941629
match ; n5, k2 Exchange             ; GREP(sigma_hp.log, "ik =   2",  4, 7);  -4.539395

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.013894
match ; n2, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1",  6, 4);  -8.242853
match ; n2, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 4);  -5.125515

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

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); -13.941629
match ; n2, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 4);   9.163257
match ; n2, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1", 11, 4);  -6.460437
match ; n2, k1 CH + Static Remainder; GREP(sigma_hp.log, "ik =   1",  6, 4);  -7.257382
match ; n2, k1 Linear QP Correction ; GREP(sigma_hp.log, "ik =   1", 10, 4);  -1.656150

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.539395
match ; n5, k2 Screened Exchange    ; GREP(sigma_hp.log, "ik =   2",  5, 7);   2.687100
match ; n5, k2 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   2", 11, 7);  -6.101776
match ; n5, k2 CH + Static Remainder; GREP(sigma_hp.log, "ik =   2",  6, 7);  -6.760831
match ; n5, k2 Linear QP Correction ; GREP(sigma_hp.log, "ik =   2", 10, 7);   2.978894

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-10
match ; max head ; GREP(kernel.out, "maximum: head       ", 3); 1.000000000000004
#match ; max wing ; GREP(kernel.out, "         wing       ", 2); 0.088271689456953
#match ; max body ; GREP(kernel.out, "         body       ", 2); 0.661960815982543
match ; max x    ; GREP(kernel.out, "         x          ", 2);  1.542516945192045

# 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.22912654E+01
Precision : 5e-5
match ; Transition mtxel 1     ; LINE(eigenvalues.dat,  5, 2);  0.60749908E+02
match ; Eigenvalue 10          ; LINE(eigenvalues.dat, 14, 1);  0.37592100E+01
Precision : 5e-4
match ; Transition mtxel 10    ; LINE(eigenvalues.dat, 14, 2);  0.40330278E+01
Precision : 2e-7
match ; Sum rule               ; GREP(absp.out, "Sum rule (BSE)", 5);  0.84853631872362578

# 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.22923932E+01
Precision : 5e-5
match ; Transition mtxel 1     ; LINE(eigenvalues.dat,  5, 2);  0.60259743E+02
match ; Eigenvalue 10          ; LINE(eigenvalues.dat, 14, 1);  0.37524628E+01
Precision : 5e-4
match ; Transition mtxel 10    ; LINE(eigenvalues.dat, 14, 2);  0.29821788E+01
Precision : 2e-7
match ; Sum rule               ; GREP(absp_mom.out, "Sum rule (BSE)", 5);  0.84794266585135802

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.22836856E+01
Precision : 5e-5
match ; Transition mtxel 1     ; LINE(eigenvalues.dat,  5, 2);  0.61862347E+02
match ; Eigenvalue 10          ; LINE(eigenvalues.dat, 14, 1);  0.37509133E+01
Precision : 5e-4
match ; Transition mtxel 10    ; LINE(eigenvalues.dat, 14, 2);  0.29824380E+01
Precision : 2e-7
match ; Sum rule               ; GREP(absp_mom_ca.out, "Sum rule (BSE)", 5);  0.84201441267706967

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.581698313
match ; Peak   epsilon 2 ; GREP(absorption_eh.dat, " 3.850000000 ", 2); 17.138157501
match ; Peak   epsilon 1 ; GREP(absorption_eh.dat, " 3.850000000 ", 3); -4.523406720

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.388180397
match ; Peak   epsilon 2 ; GREP(absorption_eh.dat, " 3.850000000 ", 2); 3.338233999
match ; Peak   epsilon 1 ; GREP(absorption_eh.dat, " 3.850000000 ", 3); 13.021215419

# Full frequency

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 ; ret Re eps q1          ; GREP(eps_ff.out, "q-pt      1: Retarded Head of Epsilon",          8, 0); 6.13955386367811
Precision : 3e-13
match ; ret Im eps q1          ; GREP(eps_ff.out, "q-pt      1: Retarded Head of Epsilon",          9, 0); 0.0
match ; ret Re epsinv q1       ; GREP(eps_ff.out, "q-pt      1: Retarded Head of Epsilon Inverse",  9, 0); 0.180539609777306
match ; ret Im epsinv q1       ; GREP(eps_ff.out, "q-pt      1: Retarded Head of Epsilon Inverse", 10, 0); 0.0
# Advanced must equal Retarded for static.
Precision : 7e-12
match ; adv Re eps q1          ; GREP(eps_ff.out, "q-pt      1: Advanced Head of Epsilon",          8, 0); 6.13955386367811
Precision : 3e-13
match ; adv Im eps q1          ; GREP(eps_ff.out, "q-pt      1: Advanced Head of Epsilon",          9, 0); 0.0
match ; adv Re epsinv q1       ; GREP(eps_ff.out, "q-pt      1: Advanced Head of Epsilon Inverse",  9, 0); 0.180539609777306
match ; adv Im epsinv q1       ; GREP(eps_ff.out, "q-pt      1: Advanced Head of Epsilon Inverse", 10, 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.log

# Uses WFN_outer
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, 6);   8.045074
match ; n2, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 6); -13.941629
match ; n2, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 6);   8.162144
match ; n2, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1",  6, 6);  -4.497780
match ; n2, k1 Imag SX              ; GREP(sigma_hp.log, "ik =   1",  1, 7);   1.333958
match ; n2, k1 Imag CH              ; GREP(sigma_hp.log, "ik =   1",  2, 7);  -2.166783

Command : mv sigma_hp.log sig_hp_ff.log

#Test for full-frequency with ggpsum set to 2. The numbers are slightly different due
#to the fact that W(G,G') is slightly asymmetric in the wings because V(0) is averaged
#in Sigma but not in Epsilon.

# Uses WFN_outer
Executable : sigma.cplx.x
Processors : 4
Output : sig_ff.out
Input  : sig_ff_ggp2.inp sigma.inp

Precision : 2e-5
match ; n2, k1 Initial Eigenvalue   ; GREP(sigma_hp.log, "ik =   1",  2, 6);   8.045074
match ; n2, k1 Exchange             ; GREP(sigma_hp.log, "ik =   1",  4, 6); -13.941629
match ; n2, k1 Screened Exchange    ; GREP(sigma_hp.log, "ik =   1",  5, 6);   8.162143
match ; n2, k1 Coulomb Hole         ; GREP(sigma_hp.log, "ik =   1", 11, 6);  -4.497778
match ; n2, k1 Correlation          ; GREP(sigma_hp.log, "ik =   1", 11, 6);  -4.497778
match ; n2, k1 CH + Static Remainder; GREP(sigma_hp.log, "ik =   1",  6, 6);  -5.196544
match ; n2, k1 Imag SX              ; GREP(sigma_hp.log, "ik =   1",  1, 7);   1.333968
match ; n2, k1 Imag CH              ; GREP(sigma_hp.log, "ik =   1",  2, 7);  -2.166784

Command : mv sigma_hp.log sig_hp_ff_ggp2.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 ; ret Re eps q1          ; GREP(eps_ff_elements.out, "q-pt      1: Retarded Head of Epsilon",          8, 0); 6.13955386367811
Precision : 3e-13
match ; ret Im eps q1          ; GREP(eps_ff_elements.out, "q-pt      1: Retarded Head of Epsilon",          9, 0); 0.0
match ; ret Re epsinv q1       ; GREP(eps_ff_elements.out, "q-pt      1: Retarded Head of Epsilon Inverse",  9, 0); 0.180539609777306
match ; ret Im epsinv q1       ; GREP(eps_ff_elements.out, "q-pt      1: Retarded Head of Epsilon Inverse", 10, 0); 0.0
# Advanced must equal Retarded for static.
Precision : 7e-12
match ; adv Re eps q1          ; GREP(eps_ff_elements.out, "q-pt      1: Advanced Head of Epsilon",          8, 0); 6.13955386367811
Precision : 3e-13
match ; adv Im eps q1          ; GREP(eps_ff_elements.out, "q-pt      1: Advanced Head of Epsilon",          9, 0); 0.0
match ; adv Re epsinv q1       ; GREP(eps_ff_elements.out, "q-pt      1: Advanced Head of Epsilon Inverse",  9, 0); 0.180539609777306
match ; adv Im epsinv q1       ; GREP(eps_ff_elements.out, "q-pt      1: Advanced Head of Epsilon Inverse", 10, 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

Command : mv WFN_fi WFN_fi_bse

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

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.291825000

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.669135828
match ; Difference          ; LINE(bandstructure.dat,    6, 8);  -8.743553048
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.600361383
match ; Difference          ; LINE(bandstructure.dat, 1010, 8);  -5.895936252
# 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.600361383

# 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 ; ret Re eps q1          ; GREP(eps_ff1_elements.out, "q-pt      1: Retarded Head of Epsilon",          8, 0); 6.08611192290713
Precision : 3e-13
match ; ret Im eps q1          ; GREP(eps_ff1_elements.out, "q-pt      1: Retarded Head of Epsilon",          9, 0); 0.0
match ; ret Re epsinv q1       ; GREP(eps_ff1_elements.out, "q-pt      1: Retarded Head of Epsilon Inverse",  9, 0); 0.182134209423543
match ; ret Im epsinv q1       ; GREP(eps_ff1_elements.out, "q-pt      1: Retarded Head of Epsilon Inverse", 10, 0); 0.0
Precision : 7e-12
match ; adv Re eps q1          ; GREP(eps_ff1_elements.out, "q-pt      1: Advanced Head of Epsilon",          8, 0); 6.08611192290713
Precision : 3e-13
match ; adv Im eps q1          ; GREP(eps_ff1_elements.out, "q-pt      1: Advanced Head of Epsilon",          9, 0); 0.0
match ; adv Re epsinv q1       ; GREP(eps_ff1_elements.out, "q-pt      1: Advanced Head of Epsilon Inverse",  9, 0); 0.182134209423543
match ; adv Im epsinv q1       ; GREP(eps_ff1_elements.out, "q-pt      1: Advanced Head of Epsilon Inverse", 10, 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
