# 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 2.863657340407371*${_u_distance}
variable latticeconst_converted equal 2.863657340407371*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86365734040737
Lattice spacing in x,y,z = 2.8636573 2.8636573 2.8636573
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 (28.636573 28.636573 28.636573)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.636573 28.636573 28.636573)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeBaskesKim_2001_Fe__MO_196726067688_000
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23483.5175609808 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_196726067688_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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8509.4205   -8509.4205        -8580        -8580       273.15       273.15    23483.518    23483.518    3210.2051    3210.2051 
    1000   -8435.9645   -8435.9645    -8504.112    -8504.112    263.73805    263.73805     23735.03     23735.03    -1633.172    -1633.172 
Loop time of 95.5074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.905 ns/day, 26.530 hours/ns, 10.470 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.027     | 95.027     | 95.027     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076892   | 0.076892   | 0.076892   |   0.0 |  0.08
Output  | 0.00019359 | 0.00019359 | 0.00019359 |   0.0 |  0.00
Modify  | 0.34654    | 0.34654    | 0.34654    |   0.0 |  0.36
Other   |            | 0.05638    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      116000.0 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58.000000
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8435.9645   -8435.9645    -8504.112    -8504.112    263.73805    263.73805     23735.03     23735.03    -1633.172    -1633.172 
    2000   -8436.1934   -8436.1934   -8504.6273   -8504.6273    264.84645    264.84645    23705.147    23705.147    384.22125    384.22125 
Loop time of 97.5145 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.087 hours/ns, 10.255 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.042     | 97.042     | 97.042     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075353   | 0.075353   | 0.075353   |   0.0 |  0.08
Output  | 0.00018935 | 0.00018935 | 0.00018935 |   0.0 |  0.00
Modify  | 0.33999    | 0.33999    | 0.33999    |   0.0 |  0.35
Other   |            | 0.05667    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 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:      116746.0 ave      116746 max      116746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116746
Ave neighs/atom = 58.373000
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8436.1934   -8436.1934   -8504.6273   -8504.6273    264.84645    264.84645    23705.147    23705.147    384.22125    384.22125 
    3000   -8437.3673   -8437.3673   -8507.9353   -8507.9353    273.10558    273.10558     23699.07     23699.07    479.45668    479.45668 
Loop time of 98.4136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.337 hours/ns, 10.161 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.937     | 97.937     | 97.937     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07498    | 0.07498    | 0.07498    |   0.0 |  0.08
Output  | 0.00018661 | 0.00018661 | 0.00018661 |   0.0 |  0.00
Modify  | 0.34455    | 0.34455    | 0.34455    |   0.0 |  0.35
Other   |            | 0.05709    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2950.00 ave        2950 max        2950 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:      116774.0 ave      116774 max      116774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116774
Ave neighs/atom = 58.387000
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8437.3673   -8437.3673   -8507.9353   -8507.9353    273.10558    273.10558     23699.07     23699.07    479.45668    479.45668 
    4000    -8434.763    -8434.763   -8504.8188   -8504.8188    271.12332    271.12332    23713.377    23713.377   -145.50202   -145.50202 
Loop time of 98.259 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.294 hours/ns, 10.177 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.783     | 97.783     | 97.783     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075699   | 0.075699   | 0.075699   |   0.0 |  0.08
Output  | 0.00018969 | 0.00018969 | 0.00018969 |   0.0 |  0.00
Modify  | 0.34418    | 0.34418    | 0.34418    |   0.0 |  0.35
Other   |            | 0.05636    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 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:      116664.0 ave      116664 max      116664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116664
Ave neighs/atom = 58.332000
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000    -8434.763    -8434.763   -8504.8188   -8504.8188    271.12332    271.12332    23713.377    23713.377   -145.50202   -145.50202 
    5000   -8437.9706   -8437.9706   -8507.9334   -8507.9334    270.76324    270.76324    23696.466    23696.466    512.39745    512.39745 
Loop time of 98.1071 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.252 hours/ns, 10.193 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.631     | 97.631     | 97.631     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074342   | 0.074342   | 0.074342   |   0.0 |  0.08
Output  | 0.00018922 | 0.00018922 | 0.00018922 |   0.0 |  0.00
Modify  | 0.34478    | 0.34478    | 0.34478    |   0.0 |  0.35
Other   |            | 0.05691    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 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:      116630.0 ave      116630 max      116630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116630
Ave neighs/atom = 58.315000
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 = 270.903036686662, Press = -148.386614191195
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8437.9706   -8437.9706   -8507.9334   -8507.9334    270.76324    270.76324    23696.466    23696.466    512.39745    512.39745 
    6000   -8435.9883   -8435.9883   -8504.2454   -8504.2454    264.16182    264.16182    23704.561    23704.561    623.51992    623.51992 
Loop time of 98.7319 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.426 hours/ns, 10.128 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.234     | 98.234     | 98.234     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075793   | 0.075793   | 0.075793   |   0.0 |  0.08
Output  | 0.00015219 | 0.00015219 | 0.00015219 |   0.0 |  0.00
Modify  | 0.36481    | 0.36481    | 0.36481    |   0.0 |  0.37
Other   |            | 0.05664    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2953.00 ave        2953 max        2953 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:      116646.0 ave      116646 max      116646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116646
Ave neighs/atom = 58.323000
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 = 271.713492968998, Press = -7.77804586094036
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8435.9883   -8435.9883   -8504.2454   -8504.2454    264.16182    264.16182    23704.561    23704.561    623.51992    623.51992 
    7000   -8436.2418   -8436.2418   -8507.9277   -8507.9277    277.43164    277.43164    23724.846    23724.846   -1279.2769   -1279.2769 
Loop time of 99.578 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.661 hours/ns, 10.042 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.078     | 99.078     | 99.078     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07646    | 0.07646    | 0.07646    |   0.0 |  0.08
Output  | 0.00015017 | 0.00015017 | 0.00015017 |   0.0 |  0.00
Modify  | 0.36628    | 0.36628    | 0.36628    |   0.0 |  0.37
Other   |            | 0.05722    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2964.00 ave        2964 max        2964 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:      116764.0 ave      116764 max      116764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116764
Ave neighs/atom = 58.382000
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 = 272.514931972989, Press = -16.2650552773
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8436.2418   -8436.2418   -8507.9277   -8507.9277    277.43164    277.43164    23724.846    23724.846   -1279.2769   -1279.2769 
    8000   -8439.2681   -8439.2681    -8509.575    -8509.575    272.09486    272.09486    23678.145    23678.145    1661.9322    1661.9322 
Loop time of 98.9286 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.480 hours/ns, 10.108 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.431     | 98.431     | 98.431     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075623   | 0.075623   | 0.075623   |   0.0 |  0.08
Output  | 0.00015519 | 0.00015519 | 0.00015519 |   0.0 |  0.00
Modify  | 0.36551    | 0.36551    | 0.36551    |   0.0 |  0.37
Other   |            | 0.05681    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2950.00 ave        2950 max        2950 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:      116656.0 ave      116656 max      116656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116656
Ave neighs/atom = 58.328000
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 = 272.21702860804, Press = -7.89563402999982
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8439.2681   -8439.2681    -8509.575    -8509.575    272.09486    272.09486    23678.145    23678.145    1661.9322    1661.9322 
    9000   -8435.0973   -8435.0973   -8506.8513   -8506.8513     277.6956     277.6956    23724.641    23724.641   -1232.9204   -1232.9204 
Loop time of 98.7491 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.430 hours/ns, 10.127 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.25      | 98.25      | 98.25      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076359   | 0.076359   | 0.076359   |   0.0 |  0.08
Output  | 0.00015527 | 0.00015527 | 0.00015527 |   0.0 |  0.00
Modify  | 0.36501    | 0.36501    | 0.36501    |   0.0 |  0.37
Other   |            | 0.05727    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 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:      116608.0 ave      116608 max      116608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116608
Ave neighs/atom = 58.304000
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 = 272.291277541873, Press = 7.36406711100549
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8435.0973   -8435.0973   -8506.8513   -8506.8513     277.6956     277.6956    23724.641    23724.641   -1232.9204   -1232.9204 
   10000   -8433.4159   -8433.4159   -8502.8897   -8502.8897    268.87064    268.87064      23746.5      23746.5   -1996.5791   -1996.5791 
Loop time of 99.3471 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.596 hours/ns, 10.066 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.846     | 98.846     | 98.846     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07687    | 0.07687    | 0.07687    |   0.0 |  0.08
Output  | 0.00015049 | 0.00015049 | 0.00015049 |   0.0 |  0.00
Modify  | 0.36739    | 0.36739    | 0.36739    |   0.0 |  0.37
Other   |            | 0.05682    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2952.00 ave        2952 max        2952 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:      116638.0 ave      116638 max      116638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116638
Ave neighs/atom = 58.319000
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 = 272.505000043408, Press = -13.1321278095114
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8433.4159   -8433.4159   -8502.8897   -8502.8897    268.87064    268.87064      23746.5      23746.5   -1996.5791   -1996.5791 
   11000   -8436.6435   -8436.6435   -8506.2176   -8506.2176    269.25896    269.25896    23661.783    23661.783     3424.525     3424.525 
Loop time of 98.0802 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.245 hours/ns, 10.196 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.585     | 97.585     | 97.585     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076193   | 0.076193   | 0.076193   |   0.0 |  0.08
Output  | 0.00020064 | 0.00020064 | 0.00020064 |   0.0 |  0.00
Modify  | 0.36181    | 0.36181    | 0.36181    |   0.0 |  0.37
Other   |            | 0.05693    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 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:      116648.0 ave      116648 max      116648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116648
Ave neighs/atom = 58.324000
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 = 273.011463909365, Press = -6.95989117743325
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8436.6435   -8436.6435   -8506.2176   -8506.2176    269.25896    269.25896    23661.783    23661.783     3424.525     3424.525 
   12000   -8432.8691   -8432.8691   -8505.2378   -8505.2378    280.07428    280.07428    23715.754    23715.754   -101.91257   -101.91257 
Loop time of 98.4282 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.341 hours/ns, 10.160 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.93      | 97.93      | 97.93      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076372   | 0.076372   | 0.076372   |   0.0 |  0.08
Output  | 0.00015364 | 0.00015364 | 0.00015364 |   0.0 |  0.00
Modify  | 0.3649     | 0.3649     | 0.3649     |   0.0 |  0.37
Other   |            | 0.05727    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2959.00 ave        2959 max        2959 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:      116714.0 ave      116714 max      116714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116714
Ave neighs/atom = 58.357000
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 = 273.165878481414, Press = 4.11848546096514
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8432.8691   -8432.8691   -8505.2378   -8505.2378    280.07428    280.07428    23715.754    23715.754   -101.91257   -101.91257 
   13000   -8437.1873   -8437.1873    -8507.532    -8507.532    272.24142    272.24142    23717.547    23717.547   -856.88428   -856.88428 
Loop time of 98.9323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.481 hours/ns, 10.108 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.435     | 98.435     | 98.435     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075421   | 0.075421   | 0.075421   |   0.0 |  0.08
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.36498    | 0.36498    | 0.36498    |   0.0 |  0.37
Other   |            | 0.05656    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2950.00 ave        2950 max        2950 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:      116622.0 ave      116622 max      116622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116622
Ave neighs/atom = 58.311000
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 = 273.353441889646, Press = -5.33230667963618
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8437.1873   -8437.1873    -8507.532    -8507.532    272.24142    272.24142    23717.547    23717.547   -856.88428   -856.88428 
   14000   -8435.1318   -8435.1318   -8505.1277   -8505.1277    270.89146    270.89146    23699.971    23699.971    1010.5286    1010.5286 
Loop time of 98.0688 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.241 hours/ns, 10.197 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.577     | 97.577     | 97.577     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074871   | 0.074871   | 0.074871   |   0.0 |  0.08
Output  | 0.00023354 | 0.00023354 | 0.00023354 |   0.0 |  0.00
Modify  | 0.3604     | 0.3604     | 0.3604     |   0.0 |  0.37
Other   |            | 0.05678    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2947.00 ave        2947 max        2947 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:      116574.0 ave      116574 max      116574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116574
Ave neighs/atom = 58.287000
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 = 273.287917043919, Press = -2.29711319169548
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8435.1318   -8435.1318   -8505.1277   -8505.1277    270.89146    270.89146    23699.971    23699.971    1010.5286    1010.5286 
   15000   -8438.2536   -8438.2536   -8508.1397   -8508.1397    270.46665    270.46665    23705.438    23705.438   -146.62581   -146.62581 
Loop time of 98.7374 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.427 hours/ns, 10.128 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.242     | 98.242     | 98.242     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075161   | 0.075161   | 0.075161   |   0.0 |  0.08
Output  | 0.00041964 | 0.00041964 | 0.00041964 |   0.0 |  0.00
Modify  | 0.3629     | 0.3629     | 0.3629     |   0.0 |  0.37
Other   |            | 0.0566     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 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:      116610.0 ave      116610 max      116610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116610
Ave neighs/atom = 58.305000
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 = 273.224998984038, Press = 1.16344083226445
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8438.2536   -8438.2536   -8508.1397   -8508.1397    270.46665    270.46665    23705.438    23705.438   -146.62581   -146.62581 
   16000   -8436.1128   -8436.1128   -8506.9749   -8506.9749    274.24366    274.24366    23736.709    23736.709   -2107.9171   -2107.9171 
Loop time of 98.8051 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.446 hours/ns, 10.121 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.308     | 98.308     | 98.308     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076497   | 0.076497   | 0.076497   |   0.0 |  0.08
Output  | 0.00014998 | 0.00014998 | 0.00014998 |   0.0 |  0.00
Modify  | 0.3639     | 0.3639     | 0.3639     |   0.0 |  0.37
Other   |            | 0.05658    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2962.00 ave        2962 max        2962 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:      116632.0 ave      116632 max      116632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116632
Ave neighs/atom = 58.316000
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 = 272.98184069018, Press = -6.43003493127639
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8436.1128   -8436.1128   -8506.9749   -8506.9749    274.24366    274.24366    23736.709    23736.709   -2107.9171   -2107.9171 
   17000    -8439.431    -8439.431   -8508.0304   -8508.0304    265.48666    265.48666    23660.576    23660.576     3155.362     3155.362 
Loop time of 98.5129 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.365 hours/ns, 10.151 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.018     | 98.018     | 98.018     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075666   | 0.075666   | 0.075666   |   0.0 |  0.08
Output  | 0.00015358 | 0.00015358 | 0.00015358 |   0.0 |  0.00
Modify  | 0.36236    | 0.36236    | 0.36236    |   0.0 |  0.37
Other   |            | 0.05718    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 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:      116610.0 ave      116610 max      116610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116610
Ave neighs/atom = 58.305000
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 = 272.885352594814, Press = -3.3708265255424
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -8439.431    -8439.431   -8508.0304   -8508.0304    265.48666    265.48666    23660.576    23660.576     3155.362     3155.362 
   18000   -8435.0814   -8435.0814   -8507.0948   -8507.0948    278.69924    278.69924    23714.942    23714.942   -456.50785   -456.50785 
Loop time of 99.0428 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.512 hours/ns, 10.097 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.546     | 98.546     | 98.546     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075739   | 0.075739   | 0.075739   |   0.0 |  0.08
Output  | 0.00015315 | 0.00015315 | 0.00015315 |   0.0 |  0.00
Modify  | 0.36442    | 0.36442    | 0.36442    |   0.0 |  0.37
Other   |            | 0.05661    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 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:      116634.0 ave      116634 max      116634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116634
Ave neighs/atom = 58.317000
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 = 272.838770634945, Press = 3.5262608113362
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8435.0814   -8435.0814   -8507.0948   -8507.0948    278.69924    278.69924    23714.942    23714.942   -456.50785   -456.50785 
   19000   -8437.3922   -8437.3922   -8507.3891   -8507.3891    270.89508    270.89508    23728.744    23728.744   -1514.3817   -1514.3817 
Loop time of 98.4207 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.339 hours/ns, 10.160 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.927     | 97.927     | 97.927     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075632   | 0.075632   | 0.075632   |   0.0 |  0.08
Output  | 0.00019807 | 0.00019807 | 0.00019807 |   0.0 |  0.00
Modify  | 0.36082    | 0.36082    | 0.36082    |   0.0 |  0.37
Other   |            | 0.05689    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2966.00 ave        2966 max        2966 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:      116610.0 ave      116610 max      116610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116610
Ave neighs/atom = 58.305000
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 = 272.838740024584, Press = -2.84912551362656
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8437.3922   -8437.3922   -8507.3891   -8507.3891    270.89508    270.89508    23728.744    23728.744   -1514.3817   -1514.3817 
   20000   -8435.5179   -8435.5179   -8506.4091   -8506.4091    274.35612    274.35612    23697.514    23697.514    959.46527    959.46527 
Loop time of 98.3197 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.311 hours/ns, 10.171 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.828     | 97.828     | 97.828     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0752     | 0.0752     | 0.0752     |   0.0 |  0.08
Output  | 0.00014993 | 0.00014993 | 0.00014993 |   0.0 |  0.00
Modify  | 0.36013    | 0.36013    | 0.36013    |   0.0 |  0.37
Other   |            | 0.05669    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 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:      116608.0 ave      116608 max      116608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116608
Ave neighs/atom = 58.304000
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 = 272.822230621483, Press = -1.95011638142384
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8435.5179   -8435.5179   -8506.4091   -8506.4091    274.35612    274.35612    23697.514    23697.514    959.46527    959.46527 
   21000   -8440.5958   -8440.5958   -8508.3552   -8508.3552    262.23581    262.23581    23696.353    23696.353    421.02083    421.02083 
Loop time of 98.201 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.278 hours/ns, 10.183 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.707     | 97.707     | 97.707     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074824   | 0.074824   | 0.074824   |   0.0 |  0.08
Output  | 0.00015507 | 0.00015507 | 0.00015507 |   0.0 |  0.00
Modify  | 0.36219    | 0.36219    | 0.36219    |   0.0 |  0.37
Other   |            | 0.05673    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2949.00 ave        2949 max        2949 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:      116650.0 ave      116650 max      116650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116650
Ave neighs/atom = 58.325000
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 = 272.718379986263, Press = -0.765399500245693
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8440.5958   -8440.5958   -8508.3552   -8508.3552    262.23581    262.23581    23696.353    23696.353    421.02083    421.02083 
   22000   -8436.9461   -8436.9461    -8507.389    -8507.389     272.6211     272.6211    23705.149    23705.149    181.58452    181.58452 
Loop time of 97.9437 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.207 hours/ns, 10.210 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.451     | 97.451     | 97.451     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075883   | 0.075883   | 0.075883   |   0.0 |  0.08
Output  | 0.0001872  | 0.0001872  | 0.0001872  |   0.0 |  0.00
Modify  | 0.35911    | 0.35911    | 0.35911    |   0.0 |  0.37
Other   |            | 0.05725    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2948.00 ave        2948 max        2948 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:      116600.0 ave      116600 max      116600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116600
Ave neighs/atom = 58.300000
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 = 272.733655794204, Press = -1.32530023189721
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8436.9461   -8436.9461    -8507.389    -8507.389     272.6211     272.6211    23705.149    23705.149    181.58452    181.58452 
   23000   -8433.5635   -8433.5635    -8504.289    -8504.289    273.71506    273.71506    23713.641    23713.641    79.857149    79.857149 
Loop time of 98.4894 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.358 hours/ns, 10.153 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.993     | 97.993     | 97.993     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075724   | 0.075724   | 0.075724   |   0.0 |  0.08
Output  | 0.00015104 | 0.00015104 | 0.00015104 |   0.0 |  0.00
Modify  | 0.36347    | 0.36347    | 0.36347    |   0.0 |  0.37
Other   |            | 0.0569     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2954.00 ave        2954 max        2954 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:      116678.0 ave      116678 max      116678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116678
Ave neighs/atom = 58.339000
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 = 272.799924943546, Press = -0.908569549116164
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8433.5635   -8433.5635    -8504.289    -8504.289    273.71506    273.71506    23713.641    23713.641    79.857149    79.857149 
   24000   -8438.4361   -8438.4361   -8507.6611   -8507.6611    267.90811    267.90811    23695.957    23695.957    711.52712    711.52712 
Loop time of 99.5105 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.642 hours/ns, 10.049 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.01      | 99.01      | 99.01      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076139   | 0.076139   | 0.076139   |   0.0 |  0.08
Output  | 0.00015387 | 0.00015387 | 0.00015387 |   0.0 |  0.00
Modify  | 0.36785    | 0.36785    | 0.36785    |   0.0 |  0.37
Other   |            | 0.05679    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 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:      116712.0 ave      116712 max      116712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116712
Ave neighs/atom = 58.356000
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 = 272.919091005439, Press = -0.776799878418957
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8438.4361   -8438.4361   -8507.6611   -8507.6611    267.90811    267.90811    23695.957    23695.957    711.52712    711.52712 
   25000   -8433.0483   -8433.0483   -8505.9321   -8505.9321    282.06785    282.06785    23721.838    23721.838   -815.99068   -815.99068 
Loop time of 98.3133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.309 hours/ns, 10.172 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.817     | 97.817     | 97.817     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076297   | 0.076297   | 0.076297   |   0.0 |  0.08
Output  | 0.00015375 | 0.00015375 | 0.00015375 |   0.0 |  0.00
Modify  | 0.36351    | 0.36351    | 0.36351    |   0.0 |  0.37
Other   |            | 0.05638    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 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:      116638.0 ave      116638 max      116638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116638
Ave neighs/atom = 58.319000
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 = 272.996124475079, Press = -0.30656806554093
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8433.0483   -8433.0483   -8505.9321   -8505.9321    282.06785    282.06785    23721.838    23721.838   -815.99068   -815.99068 
   26000    -8438.018    -8438.018   -8509.6741   -8509.6741    277.31622    277.31622    23723.796    23723.796   -1519.4378   -1519.4378 
Loop time of 98.4118 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.337 hours/ns, 10.161 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.918     | 97.918     | 97.918     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075246   | 0.075246   | 0.075246   |   0.0 |  0.08
Output  | 0.00019911 | 0.00019911 | 0.00019911 |   0.0 |  0.00
Modify  | 0.36156    | 0.36156    | 0.36156    |   0.0 |  0.37
Other   |            | 0.05697    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2950.00 ave        2950 max        2950 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:      116656.0 ave      116656 max      116656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116656
Ave neighs/atom = 58.328000
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 = 273.056962737841, Press = -2.94077764050534
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -8438.018    -8438.018   -8509.6741   -8509.6741    277.31622    277.31622    23723.796    23723.796   -1519.4378   -1519.4378 
   27000   -8434.8222   -8434.8222   -8506.7326   -8506.7326    278.30084    278.30084    23671.527    23671.527    2673.1436    2673.1436 
Loop time of 99.7808 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.866 ns/day, 27.717 hours/ns, 10.022 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.275     | 99.275     | 99.275     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076616   | 0.076616   | 0.076616   |   0.0 |  0.08
Output  | 0.00018663 | 0.00018663 | 0.00018663 |   0.0 |  0.00
Modify  | 0.37107    | 0.37107    | 0.37107    |   0.0 |  0.37
Other   |            | 0.05769    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2954.00 ave        2954 max        2954 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:      116574.0 ave      116574 max      116574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116574
Ave neighs/atom = 58.287000
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 = 273.093852874406, Press = -1.73363533018195
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8434.8222   -8434.8222   -8506.7326   -8506.7326    278.30084    278.30084    23671.527    23671.527    2673.1436    2673.1436 
   28000   -8437.4428   -8437.4428   -8509.4387   -8509.4387    278.63166    278.63166    23713.554    23713.554   -798.73944   -798.73944 
Loop time of 97.8699 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.186 hours/ns, 10.218 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.38      | 97.38      | 97.38      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075292   | 0.075292   | 0.075292   |   0.0 |  0.08
Output  | 0.00015205 | 0.00015205 | 0.00015205 |   0.0 |  0.00
Modify  | 0.35818    | 0.35818    | 0.35818    |   0.0 |  0.37
Other   |            | 0.05621    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2947.00 ave        2947 max        2947 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:      116652.0 ave      116652 max      116652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116652
Ave neighs/atom = 58.326000
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 = 273.104769277196, Press = 2.04817544155107
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8437.4428   -8437.4428   -8509.4387   -8509.4387    278.63166    278.63166    23713.554    23713.554   -798.73944   -798.73944 
   29000   -8434.6629   -8434.6629   -8504.2832   -8504.2832    269.43812    269.43812    23717.713    23717.713   -254.38083   -254.38083 
Loop time of 97.4311 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.064 hours/ns, 10.264 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.94      | 96.94      | 96.94      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074663   | 0.074663   | 0.074663   |   0.0 |  0.08
Output  | 0.00015761 | 0.00015761 | 0.00015761 |   0.0 |  0.00
Modify  | 0.35994    | 0.35994    | 0.35994    |   0.0 |  0.37
Other   |            | 0.05631    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 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:      116600.0 ave      116600 max      116600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116600
Ave neighs/atom = 58.300000
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 = 273.007219749301, Press = -2.03623450963554
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8434.6629   -8434.6629   -8504.2832   -8504.2832    269.43812    269.43812    23717.713    23717.713   -254.38083   -254.38083 
   30000   -8436.4621   -8436.4621   -8507.0915   -8507.0915    273.34312    273.34312    23703.836    23703.836    297.33166    297.33166 
Loop time of 98.2201 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.283 hours/ns, 10.181 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.724     | 97.724     | 97.724     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075805   | 0.075805   | 0.075805   |   0.0 |  0.08
Output  | 0.00014487 | 0.00014487 | 0.00014487 |   0.0 |  0.00
Modify  | 0.36364    | 0.36364    | 0.36364    |   0.0 |  0.37
Other   |            | 0.05674    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 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:      116680.0 ave      116680 max      116680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116680
Ave neighs/atom = 58.340000
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 = 273.022404720759, Press = -1.38181891217179
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8436.4621   -8436.4621   -8507.0915   -8507.0915    273.34312    273.34312    23703.836    23703.836    297.33166    297.33166 
   31000   -8433.7275   -8433.7275     -8505.66     -8505.66    278.38617    278.38617    23700.819    23700.819     749.8824     749.8824 
Loop time of 97.7871 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.163 hours/ns, 10.226 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.296     | 97.296     | 97.296     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076075   | 0.076075   | 0.076075   |   0.0 |  0.08
Output  | 0.00015302 | 0.00015302 | 0.00015302 |   0.0 |  0.00
Modify  | 0.3586     | 0.3586     | 0.3586     |   0.0 |  0.37
Other   |            | 0.05655    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 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:      116654.0 ave      116654 max      116654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116654
Ave neighs/atom = 58.327000
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 = 273.143586865034, Press = -0.524446677835267
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8433.7275   -8433.7275     -8505.66     -8505.66    278.38617    278.38617    23700.819    23700.819     749.8824     749.8824 
   32000   -8435.6164   -8435.6164   -8506.4274   -8506.4274     274.0461     274.0461    23725.635    23725.635   -1190.1474   -1190.1474 
Loop time of 98.7551 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.432 hours/ns, 10.126 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.258     | 98.258     | 98.258     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07615    | 0.07615    | 0.07615    |   0.0 |  0.08
Output  | 0.00021424 | 0.00021424 | 0.00021424 |   0.0 |  0.00
Modify  | 0.3643     | 0.3643     | 0.3643     |   0.0 |  0.37
Other   |            | 0.0569     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 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:      116686.0 ave      116686 max      116686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116686
Ave neighs/atom = 58.343000
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 = 273.153086122411, Press = -0.321083650525037
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8435.6164   -8435.6164   -8506.4274   -8506.4274     274.0461     274.0461    23725.635    23725.635   -1190.1474   -1190.1474 
   33000   -8434.7708   -8434.7708   -8506.7854   -8506.7854     278.7039     278.7039    23722.285    23722.285   -979.25363   -979.25363 
Loop time of 98.6598 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.406 hours/ns, 10.136 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.166     | 98.166     | 98.166     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075698   | 0.075698   | 0.075698   |   0.0 |  0.08
Output  | 0.00015384 | 0.00015384 | 0.00015384 |   0.0 |  0.00
Modify  | 0.36231    | 0.36231    | 0.36231    |   0.0 |  0.37
Other   |            | 0.05606    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2948.00 ave        2948 max        2948 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:      116638.0 ave      116638 max      116638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116638
Ave neighs/atom = 58.319000
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 = 273.186140356949, Press = -3.43893528069039
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8434.7708   -8434.7708   -8506.7854   -8506.7854     278.7039     278.7039    23722.285    23722.285   -979.25363   -979.25363 
   34000    -8438.315    -8438.315   -8507.2709   -8507.2709    266.86664    266.86664    23665.867    23665.867    2837.1034    2837.1034 
Loop time of 98.8252 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.451 hours/ns, 10.119 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.325     | 98.325     | 98.325     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076084   | 0.076084   | 0.076084   |   0.0 |  0.08
Output  | 0.00015147 | 0.00015147 | 0.00015147 |   0.0 |  0.00
Modify  | 0.36685    | 0.36685    | 0.36685    |   0.0 |  0.37
Other   |            | 0.05676    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 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:      116630.0 ave      116630 max      116630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116630
Ave neighs/atom = 58.315000
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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
23708.1224122186

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0