# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 4.0499990060925475*${_u_distance}
variable latticeconst_converted equal 4.0499990060925475*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04999900609255
Lattice spacing in x,y,z = 4.0499990 4.0499990 4.0499990
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.499990 40.499990 40.499990)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  create_atoms CPU = 0.001 seconds

variable mass_converted equal 26.981538*${_u_mass}
variable mass_converted equal 26.981538*1

kim_interactions Al

WARNING: 'kim_<command>' has been renamed to 'kim <command>'. Please update your input.

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_DickelBaskesAslam_2018_MgAlZn__MO_093637366498_000
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

# initial volume
variable      v equal vol        # assign formula
variable      V0 equal ${v}    # evaluate initial value
variable      V0 equal 66430.0760923112    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0760923112/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0760923112/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0760923112/(1*1*${_u_distance})
variable      V0_metal equal 66430.0760923112/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 66430.0760923112*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66430.0760923112 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 313.15*${_u_temperature}
variable temp_converted equal 313.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 313.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "313.15 - 0.2"
variable      T_up  equal  "313.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_093637366498_000#item-citation

CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13278.129   -13278.129       -13440       -13440       313.15       313.15    66430.076    66430.076    2602.7061    2602.7061 
    1000    -13102.77    -13102.77   -13274.126   -13274.126    331.49868    331.49868    67631.572    67631.572    313.17392    313.17392 
Loop time of 113.395 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.762 ns/day, 31.499 hours/ns, 8.819 timesteps/s
99.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.19     | 113.19     | 113.19     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035412   | 0.035412   | 0.035412   |   0.0 |  0.03
Output  | 4.13e-05   | 4.13e-05   | 4.13e-05   |   0.0 |  0.00
Modify  | 0.1517     | 0.1517     | 0.1517     |   0.0 |  0.13
Other   |            | 0.01798    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      536000.0 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000    -13102.77    -13102.77   -13274.126   -13274.126    331.49868    331.49868    67631.572    67631.572    313.17392    313.17392 
    2000   -13117.504   -13117.504    -13279.45    -13279.45    313.29592    313.29592    67649.125    67649.125   -475.28093   -475.28093 
Loop time of 115.767 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.746 ns/day, 32.157 hours/ns, 8.638 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.57     | 115.57     | 115.57     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034367   | 0.034367   | 0.034367   |   0.0 |  0.03
Output  | 5.57e-05   | 5.57e-05   | 5.57e-05   |   0.0 |  0.00
Modify  | 0.14668    | 0.14668    | 0.14668    |   0.0 |  0.13
Other   |            | 0.01776    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5927.00 ave        5927 max        5927 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538580.0 ave      538580 max      538580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538580
Ave neighs/atom = 134.64500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13117.504   -13117.504    -13279.45    -13279.45    313.29592    313.29592    67649.125    67649.125   -475.28093   -475.28093 
    3000   -13111.123   -13111.123   -13271.405   -13271.405    310.07757    310.07757    67671.765    67671.765   -238.47275   -238.47275 
Loop time of 116.274 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.743 ns/day, 32.298 hours/ns, 8.600 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.07     | 116.07     | 116.07     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034957   | 0.034957   | 0.034957   |   0.0 |  0.03
Output  | 3.77e-05   | 3.77e-05   | 3.77e-05   |   0.0 |  0.00
Modify  | 0.14704    | 0.14704    | 0.14704    |   0.0 |  0.13
Other   |            | 0.01761    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6000.00 ave        6000 max        6000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538544.0 ave      538544 max      538544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538544
Ave neighs/atom = 134.63600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13111.123   -13111.123   -13271.405   -13271.405    310.07757    310.07757    67671.765    67671.765   -238.47275   -238.47275 
    4000   -13111.857   -13111.857   -13279.233   -13279.233    323.80032    323.80032    67677.188    67677.188   -677.56305   -677.56305 
Loop time of 117.019 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.738 ns/day, 32.505 hours/ns, 8.546 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.82     | 116.82     | 116.82     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034686   | 0.034686   | 0.034686   |   0.0 |  0.03
Output  | 4.69e-05   | 4.69e-05   | 4.69e-05   |   0.0 |  0.00
Modify  | 0.14823    | 0.14823    | 0.14823    |   0.0 |  0.13
Other   |            | 0.01781    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5948.00 ave        5948 max        5948 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538578.0 ave      538578 max      538578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538578
Ave neighs/atom = 134.64450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13111.857   -13111.857   -13279.233   -13279.233    323.80032    323.80032    67677.188    67677.188   -677.56305   -677.56305 
    5000   -13113.919   -13113.919   -13272.554   -13272.554    306.89082    306.89082    67611.408    67611.408    410.01963    410.01963 
Loop time of 116.577 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.741 ns/day, 32.383 hours/ns, 8.578 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.38     | 116.38     | 116.38     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034877   | 0.034877   | 0.034877   |   0.0 |  0.03
Output  | 3.54e-05   | 3.54e-05   | 3.54e-05   |   0.0 |  0.00
Modify  | 0.1479     | 0.1479     | 0.1479     |   0.0 |  0.13
Other   |            | 0.01777    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5974.00 ave        5974 max        5974 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538492.0 ave      538492 max      538492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538492
Ave neighs/atom = 134.62300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.248278421005, Press = 368.169691796572
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13113.919   -13113.919   -13272.554   -13272.554    306.89082    306.89082    67611.408    67611.408    410.01963    410.01963 
    6000    -13110.71    -13110.71   -13272.018   -13272.018    312.06199    312.06199    67583.018    67583.018    806.36198    806.36198 
Loop time of 115.461 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.748 ns/day, 32.073 hours/ns, 8.661 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.26     | 115.26     | 115.26     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03452    | 0.03452    | 0.03452    |   0.0 |  0.03
Output  | 2.83e-05   | 2.83e-05   | 2.83e-05   |   0.0 |  0.00
Modify  | 0.15229    | 0.15229    | 0.15229    |   0.0 |  0.13
Other   |            | 0.01765    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5973.00 ave        5973 max        5973 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538608.0 ave      538608 max      538608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538608
Ave neighs/atom = 134.65200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.784765133022, Press = 32.5891517252751
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000    -13110.71    -13110.71   -13272.018   -13272.018    312.06199    312.06199    67583.018    67583.018    806.36198    806.36198 
    7000   -13115.108   -13115.108   -13274.115   -13274.115    307.60896    307.60896    67502.501    67502.501    1599.1581    1599.1581 
Loop time of 113.732 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.760 ns/day, 31.592 hours/ns, 8.793 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.53     | 113.53     | 113.53     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03438    | 0.03438    | 0.03438    |   0.0 |  0.03
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.14962    | 0.14962    | 0.14962    |   0.0 |  0.13
Other   |            | 0.01753    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5984.00 ave        5984 max        5984 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538736.0 ave      538736 max      538736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538736
Ave neighs/atom = 134.68400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.113222185294, Press = -2.03564570185374
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13115.108   -13115.108   -13274.115   -13274.115    307.60896    307.60896    67502.501    67502.501    1599.1581    1599.1581 
    8000   -13108.435   -13108.435   -13272.591   -13272.591    317.57104    317.57104    67671.509    67671.509     -271.319     -271.319 
Loop time of 114.555 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.821 hours/ns, 8.729 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.35     | 114.35     | 114.35     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034475   | 0.034475   | 0.034475   |   0.0 |  0.03
Output  | 2.78e-05   | 2.78e-05   | 2.78e-05   |   0.0 |  0.00
Modify  | 0.15057    | 0.15057    | 0.15057    |   0.0 |  0.13
Other   |            | 0.01762    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6020.00 ave        6020 max        6020 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538804.0 ave      538804 max      538804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538804
Ave neighs/atom = 134.70100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.159980705281, Press = -8.24404281883001
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13108.435   -13108.435   -13272.591   -13272.591    317.57104    317.57104    67671.509    67671.509     -271.319     -271.319 
    9000   -13115.473   -13115.473   -13275.798   -13275.798    310.15834    310.15834    67680.297    67680.297   -577.08063   -577.08063 
Loop time of 112.989 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.386 hours/ns, 8.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.79     | 112.79     | 112.79     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033982   | 0.033982   | 0.033982   |   0.0 |  0.03
Output  | 2.86e-05   | 2.86e-05   | 2.86e-05   |   0.0 |  0.00
Modify  | 0.14919    | 0.14919    | 0.14919    |   0.0 |  0.13
Other   |            | 0.01744    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5940.00 ave        5940 max        5940 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538592.0 ave      538592 max      538592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538592
Ave neighs/atom = 134.64800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.9123639693, Press = 1.88068655825073
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13115.473   -13115.473   -13275.798   -13275.798    310.15834    310.15834    67680.297    67680.297   -577.08063   -577.08063 
   10000   -13109.027   -13109.027   -13269.398   -13269.398    310.24852    310.24852    67670.875    67670.875   -65.677523   -65.677523 
Loop time of 113.889 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.636 hours/ns, 8.780 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.69     | 113.69     | 113.69     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034234   | 0.034234   | 0.034234   |   0.0 |  0.03
Output  | 3.46e-05   | 3.46e-05   | 3.46e-05   |   0.0 |  0.00
Modify  | 0.15043    | 0.15043    | 0.15043    |   0.0 |  0.13
Other   |            | 0.0175     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5978.00 ave        5978 max        5978 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538396.0 ave      538396 max      538396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538396
Ave neighs/atom = 134.59900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.169491903967, Press = 5.71236081200486
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13109.027   -13109.027   -13269.398   -13269.398    310.24852    310.24852    67670.875    67670.875   -65.677523   -65.677523 
   11000   -13111.848   -13111.848   -13272.736   -13272.736    311.24897    311.24897    67612.255    67612.255    373.40737    373.40737 
Loop time of 114.907 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.919 hours/ns, 8.703 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.7      | 114.7      | 114.7      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034505   | 0.034505   | 0.034505   |   0.0 |  0.03
Output  | 2.79e-05   | 2.79e-05   | 2.79e-05   |   0.0 |  0.00
Modify  | 0.15095    | 0.15095    | 0.15095    |   0.0 |  0.13
Other   |            | 0.01774    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5984.00 ave        5984 max        5984 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538596.0 ave      538596 max      538596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538596
Ave neighs/atom = 134.64900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.068244223803, Press = 6.40225388921195
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13111.848   -13111.848   -13272.736   -13272.736    311.24897    311.24897    67612.255    67612.255    373.40737    373.40737 
   12000   -13117.437   -13117.437   -13279.271   -13279.271    313.07876    313.07876    67518.011    67518.011    1032.0086    1032.0086 
Loop time of 114.999 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.751 ns/day, 31.944 hours/ns, 8.696 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.8      | 114.8      | 114.8      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034711   | 0.034711   | 0.034711   |   0.0 |  0.03
Output  | 2.83e-05   | 2.83e-05   | 2.83e-05   |   0.0 |  0.00
Modify  | 0.15099    | 0.15099    | 0.15099    |   0.0 |  0.13
Other   |            | 0.01764    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6002.00 ave        6002 max        6002 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538758.0 ave      538758 max      538758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538758
Ave neighs/atom = 134.68950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.952649740218, Press = 3.58142926162029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13117.437   -13117.437   -13279.271   -13279.271    313.07876    313.07876    67518.011    67518.011    1032.0086    1032.0086 
   13000   -13108.601   -13108.601   -13274.841   -13274.841    321.60232    321.60232    67571.753    67571.753    814.12937    814.12937 
Loop time of 114.715 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.865 hours/ns, 8.717 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.51     | 114.51     | 114.51     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03479    | 0.03479    | 0.03479    |   0.0 |  0.03
Output  | 3.67e-05   | 3.67e-05   | 3.67e-05   |   0.0 |  0.00
Modify  | 0.15039    | 0.15039    | 0.15039    |   0.0 |  0.13
Other   |            | 0.0177     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6034.00 ave        6034 max        6034 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538868.0 ave      538868 max      538868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538868
Ave neighs/atom = 134.71700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.873383695581, Press = -3.04412407584351
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13108.601   -13108.601   -13274.841   -13274.841    321.60232    321.60232    67571.753    67571.753    814.12937    814.12937 
   14000   -13113.404   -13113.404   -13272.285   -13272.285     307.3673     307.3673     67701.22     67701.22   -660.19562   -660.19562 
Loop time of 115.184 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.750 ns/day, 31.995 hours/ns, 8.682 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.98     | 114.98     | 114.98     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034462   | 0.034462   | 0.034462   |   0.0 |  0.03
Output  | 3.51e-05   | 3.51e-05   | 3.51e-05   |   0.0 |  0.00
Modify  | 0.15129    | 0.15129    | 0.15129    |   0.0 |  0.13
Other   |            | 0.01757    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5956.00 ave        5956 max        5956 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538798.0 ave      538798 max      538798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538798
Ave neighs/atom = 134.69950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.797862313929, Press = -1.41002115453505
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13113.404   -13113.404   -13272.285   -13272.285     307.3673     307.3673     67701.22     67701.22   -660.19562   -660.19562 
   15000   -13116.457   -13116.457   -13275.854   -13275.854    308.36433    308.36433    67714.293    67714.293   -1028.9312   -1028.9312 
Loop time of 114.687 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.858 hours/ns, 8.719 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.48     | 114.48     | 114.48     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034376   | 0.034376   | 0.034376   |   0.0 |  0.03
Output  | 2.76e-05   | 2.76e-05   | 2.76e-05   |   0.0 |  0.00
Modify  | 0.15023    | 0.15023    | 0.15023    |   0.0 |  0.13
Other   |            | 0.01762    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5988.00 ave        5988 max        5988 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538470.0 ave      538470 max      538470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538470
Ave neighs/atom = 134.61750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.847669095975, Press = 2.12645371864222
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13116.457   -13116.457   -13275.854   -13275.854    308.36433    308.36433    67714.293    67714.293   -1028.9312   -1028.9312 
   16000   -13111.182   -13111.182   -13274.757   -13274.757     316.4479     316.4479     67692.81     67692.81   -665.80084   -665.80084 
Loop time of 114.373 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.755 ns/day, 31.770 hours/ns, 8.743 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.17     | 114.17     | 114.17     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034158   | 0.034158   | 0.034158   |   0.0 |  0.03
Output  | 2.88e-05   | 2.88e-05   | 2.88e-05   |   0.0 |  0.00
Modify  | 0.14966    | 0.14966    | 0.14966    |   0.0 |  0.13
Other   |            | 0.01747    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5947.00 ave        5947 max        5947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538378.0 ave      538378 max      538378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538378
Ave neighs/atom = 134.59450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.718960212402, Press = 4.19707633759094
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13111.182   -13111.182   -13274.757   -13274.757     316.4479     316.4479     67692.81     67692.81   -665.80084   -665.80084 
   17000   -13112.294   -13112.294   -13274.115   -13274.115    313.05377    313.05377    67597.385    67597.385    510.99729    510.99729 
Loop time of 114.195 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.721 hours/ns, 8.757 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.99     | 113.99     | 113.99     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034319   | 0.034319   | 0.034319   |   0.0 |  0.03
Output  | 4.86e-05   | 4.86e-05   | 4.86e-05   |   0.0 |  0.00
Modify  | 0.14987    | 0.14987    | 0.14987    |   0.0 |  0.13
Other   |            | 0.01738    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5962.00 ave        5962 max        5962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538468.0 ave      538468 max      538468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538468
Ave neighs/atom = 134.61700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.676529282952, Press = 4.22370360678285
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13112.294   -13112.294   -13274.115   -13274.115    313.05377    313.05377    67597.385    67597.385    510.99729    510.99729 
   18000   -13112.668   -13112.668   -13274.683   -13274.683    313.42821    313.42821    67560.973    67560.973    856.72234    856.72234 
Loop time of 110.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.784 ns/day, 30.614 hours/ns, 9.073 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.01     | 110.01     | 110.01     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033479   | 0.033479   | 0.033479   |   0.0 |  0.03
Output  | 2.88e-05   | 2.88e-05   | 2.88e-05   |   0.0 |  0.00
Modify  | 0.14646    | 0.14646    | 0.14646    |   0.0 |  0.13
Other   |            | 0.01712    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6024.00 ave        6024 max        6024 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538622.0 ave      538622 max      538622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538622
Ave neighs/atom = 134.65550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.726045274546, Press = 1.80221608797307
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13112.668   -13112.668   -13274.683   -13274.683    313.42821    313.42821    67560.973    67560.973    856.72234    856.72234 
   19000   -13115.125   -13115.125   -13275.451   -13275.451    310.15971    310.15971    67599.396    67599.396    335.69222    335.69222 
Loop time of 109.33 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.790 ns/day, 30.370 hours/ns, 9.147 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.13     | 109.13     | 109.13     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033302   | 0.033302   | 0.033302   |   0.0 |  0.03
Output  | 3.71e-05   | 3.71e-05   | 3.71e-05   |   0.0 |  0.00
Modify  | 0.14555    | 0.14555    | 0.14555    |   0.0 |  0.13
Other   |            | 0.01699    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5976.00 ave        5976 max        5976 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538512.0 ave      538512 max      538512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538512
Ave neighs/atom = 134.62800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.603202027252, Press = 0.761712070889233
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13115.125   -13115.125   -13275.451   -13275.451    310.15971    310.15971    67599.396    67599.396    335.69222    335.69222 
   20000   -13109.384   -13109.384   -13272.052   -13272.052    314.69334    314.69334     67651.01     67651.01   -5.6794633   -5.6794633 
Loop time of 106.415 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.812 ns/day, 29.560 hours/ns, 9.397 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.22     | 106.22     | 106.22     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032673   | 0.032673   | 0.032673   |   0.0 |  0.03
Output  | 3.51e-05   | 3.51e-05   | 3.51e-05   |   0.0 |  0.00
Modify  | 0.14258    | 0.14258    | 0.14258    |   0.0 |  0.13
Other   |            | 0.01673    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6005.00 ave        6005 max        6005 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538512.0 ave      538512 max      538512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538512
Ave neighs/atom = 134.62800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.662461037921, Press = 0.305127909588388
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13109.384   -13109.384   -13272.052   -13272.052    314.69334    314.69334     67651.01     67651.01   -5.6794633   -5.6794633 
   21000   -13111.913   -13111.913   -13273.538   -13273.538    312.67342    312.67342    67670.289    67670.289    -311.1313    -311.1313 
Loop time of 113.195 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.763 ns/day, 31.443 hours/ns, 8.834 timesteps/s
98.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113        | 113        | 113        |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03418    | 0.03418    | 0.03418    |   0.0 |  0.03
Output  | 3.83e-05   | 3.83e-05   | 3.83e-05   |   0.0 |  0.00
Modify  | 0.14803    | 0.14803    | 0.14803    |   0.0 |  0.13
Other   |            | 0.01731    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5967.00 ave        5967 max        5967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538612.0 ave      538612 max      538612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538612
Ave neighs/atom = 134.65300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.684032622553, Press = 1.00115443516167
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13111.913   -13111.913   -13273.538   -13273.538    312.67342    312.67342    67670.289    67670.289    -311.1313    -311.1313 
   22000   -13109.938   -13109.938   -13272.645   -13272.645     314.7661     314.7661    67651.645    67651.645   -2.1443471   -2.1443471 
Loop time of 115.189 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.750 ns/day, 31.997 hours/ns, 8.681 timesteps/s
97.2% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.99     | 114.99     | 114.99     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033742   | 0.033742   | 0.033742   |   0.0 |  0.03
Output  | 2.65e-05   | 2.65e-05   | 2.65e-05   |   0.0 |  0.00
Modify  | 0.14877    | 0.14877    | 0.14877    |   0.0 |  0.13
Other   |            | 0.01727    |            |       |  0.01

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5966.00 ave        5966 max        5966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538468.0 ave      538468 max      538468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538468
Ave neighs/atom = 134.61700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.867029718927, Press = 1.78655282164289
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13109.938   -13109.938   -13272.645   -13272.645     314.7661     314.7661    67651.645    67651.645   -2.1443471   -2.1443471 
   23000   -13112.251   -13112.251   -13276.174   -13276.174    317.11947    317.11947    67571.219    67571.219    663.12867    663.12867 
Loop time of 105.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.324 hours/ns, 9.473 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.37     | 105.37     | 105.37     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032607   | 0.032607   | 0.032607   |   0.0 |  0.03
Output  | 2.83e-05   | 2.83e-05   | 2.83e-05   |   0.0 |  0.00
Modify  | 0.14261    | 0.14261    | 0.14261    |   0.0 |  0.14
Other   |            | 0.01666    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6007.00 ave        6007 max        6007 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538540.0 ave      538540 max      538540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538540
Ave neighs/atom = 134.63500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.878888944435, Press = 2.75148612347525
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13112.251   -13112.251   -13276.174   -13276.174    317.11947    317.11947    67571.219    67571.219    663.12867    663.12867 
   24000   -13110.226   -13110.226   -13274.936   -13274.936    318.64344    318.64344    67521.798    67521.798    1356.4094    1356.4094 
Loop time of 106.873 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.808 ns/day, 29.687 hours/ns, 9.357 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.68     | 106.68     | 106.68     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032642   | 0.032642   | 0.032642   |   0.0 |  0.03
Output  | 2.85e-05   | 2.85e-05   | 2.85e-05   |   0.0 |  0.00
Modify  | 0.14313    | 0.14313    | 0.14313    |   0.0 |  0.13
Other   |            | 0.01676    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5978.00 ave        5978 max        5978 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538682.0 ave      538682 max      538682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538682
Ave neighs/atom = 134.67050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.865696454724, Press = 0.524159958098164
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13110.226   -13110.226   -13274.936   -13274.936    318.64344    318.64344    67521.798    67521.798    1356.4094    1356.4094 
   25000   -13114.126   -13114.126   -13276.847   -13276.847    314.79547    314.79547    67606.238    67606.238     203.3466     203.3466 
Loop time of 105.322 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.256 hours/ns, 9.495 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.13     | 105.13     | 105.13     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032586   | 0.032586   | 0.032586   |   0.0 |  0.03
Output  | 2.9e-05    | 2.9e-05    | 2.9e-05    |   0.0 |  0.00
Modify  | 0.14205    | 0.14205    | 0.14205    |   0.0 |  0.13
Other   |            | 0.0167     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6028.00 ave        6028 max        6028 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538824.0 ave      538824 max      538824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538824
Ave neighs/atom = 134.70600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.822924010289, Press = -0.545242444914504
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13114.126   -13114.126   -13276.847   -13276.847    314.79547    314.79547    67606.238    67606.238     203.3466     203.3466 
   26000   -13111.373   -13111.373   -13271.057   -13271.057    308.92036    308.92036    67678.029    67678.029   -308.24038   -308.24038 
Loop time of 101.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.125 hours/ns, 9.876 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.07     | 101.07     | 101.07     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.031333   | 0.031333   | 0.031333   |   0.0 |  0.03
Output  | 2.83e-05   | 2.83e-05   | 2.83e-05   |   0.0 |  0.00
Modify  | 0.13801    | 0.13801    | 0.13801    |   0.0 |  0.14
Other   |            | 0.01598    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5975.00 ave        5975 max        5975 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538514.0 ave      538514 max      538514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538514
Ave neighs/atom = 134.62850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.742815792658, Press = 0.0391471457897771
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13111.373   -13111.373   -13271.057   -13271.057    308.92036    308.92036    67678.029    67678.029   -308.24038   -308.24038 
   27000   -13115.408   -13115.408   -13275.294   -13275.294    309.30997    309.30997    67660.292    67660.292   -369.38469   -369.38469 
Loop time of 102.128 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.846 ns/day, 28.369 hours/ns, 9.792 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.94     | 101.94     | 101.94     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03145    | 0.03145    | 0.03145    |   0.0 |  0.03
Output  | 2.64e-05   | 2.64e-05   | 2.64e-05   |   0.0 |  0.00
Modify  | 0.13871    | 0.13871    | 0.13871    |   0.0 |  0.14
Other   |            | 0.01613    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5942.00 ave        5942 max        5942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538556.0 ave      538556 max      538556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538556
Ave neighs/atom = 134.63900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.737219180231, Press = 1.13195002731551
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13115.408   -13115.408   -13275.294   -13275.294    309.30997    309.30997    67660.292    67660.292   -369.38469   -369.38469 
   28000   -13108.131   -13108.131   -13271.231   -13271.231     315.5285     315.5285    67653.391    67653.391    43.218171    43.218171 
Loop time of 101.861 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.848 ns/day, 28.295 hours/ns, 9.817 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.67     | 101.67     | 101.67     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.031726   | 0.031726   | 0.031726   |   0.0 |  0.03
Output  | 2.84e-05   | 2.84e-05   | 2.84e-05   |   0.0 |  0.00
Modify  | 0.13901    | 0.13901    | 0.13901    |   0.0 |  0.14
Other   |            | 0.01612    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5979.00 ave        5979 max        5979 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538438.0 ave      538438 max      538438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538438
Ave neighs/atom = 134.60950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.820151178735, Press = 1.01219730061537
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13108.131   -13108.131   -13271.231   -13271.231     315.5285     315.5285    67653.391    67653.391    43.218171    43.218171 
   29000   -13115.101   -13115.101    -13273.43    -13273.43    306.29795    306.29795    67619.328    67619.328    225.98631    225.98631 
Loop time of 102.442 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.843 ns/day, 28.456 hours/ns, 9.762 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.25     | 102.25     | 102.25     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.031356   | 0.031356   | 0.031356   |   0.0 |  0.03
Output  | 2.87e-05   | 2.87e-05   | 2.87e-05   |   0.0 |  0.00
Modify  | 0.13945    | 0.13945    | 0.13945    |   0.0 |  0.14
Other   |            | 0.01615    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5958.00 ave        5958 max        5958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538610.0 ave      538610 max      538610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538610
Ave neighs/atom = 134.65250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.885703221661, Press = 0.975258964899782
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13115.101   -13115.101    -13273.43    -13273.43    306.29795    306.29795    67619.328    67619.328    225.98631    225.98631 
   30000   -13108.959   -13108.959   -13273.894   -13273.894    319.07765    319.07765    67595.143    67595.143    528.02616    528.02616 
Loop time of 101.505 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.196 hours/ns, 9.852 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.32     | 101.32     | 101.32     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.031588   | 0.031588   | 0.031588   |   0.0 |  0.03
Output  | 6.22e-05   | 6.22e-05   | 6.22e-05   |   0.0 |  0.00
Modify  | 0.13833    | 0.13833    | 0.13833    |   0.0 |  0.14
Other   |            | 0.01613    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6009.00 ave        6009 max        6009 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538588.0 ave      538588 max      538588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538588
Ave neighs/atom = 134.64700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.972948137202, Press = 1.07540006978707
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13108.959   -13108.959   -13273.894   -13273.894    319.07765    319.07765    67595.143    67595.143    528.02616    528.02616 
   31000   -13111.817   -13111.817   -13271.722   -13271.722    309.34716    309.34716    67549.914    67549.914    1204.0812    1204.0812 
Loop time of 101.376 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.160 hours/ns, 9.864 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.19     | 101.19     | 101.19     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.031495   | 0.031495   | 0.031495   |   0.0 |  0.03
Output  | 2.84e-05   | 2.84e-05   | 2.84e-05   |   0.0 |  0.00
Modify  | 0.13811    | 0.13811    | 0.13811    |   0.0 |  0.14
Other   |            | 0.0161     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5989.00 ave        5989 max        5989 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      538630.0 ave      538630 max      538630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538630
Ave neighs/atom = 134.65750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
67635.6574721538

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0