# 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 3.613315641880036*${_u_distance}
variable latticeconst_converted equal 3.613315641880036*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331564188004
Lattice spacing in x,y,z = 3.6133156 3.6133156 3.6133156
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 (36.133156 36.133156 36.133156)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.133156 36.133156 36.133156)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WangOhLee_2020_CuCo__MO_849011491644_001
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6294254851 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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_849011491644_001#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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -14029.144   -14029.144       -14160       -14160       253.15       253.15    47175.629    47175.629    2962.7532    2962.7532 
    1000   -13891.154   -13891.154   -14025.485   -14025.485    259.87077    259.87077    47819.315    47819.315    442.31513    442.31513 
Loop time of 166.034 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.520 ns/day, 46.120 hours/ns, 6.023 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    | 165.09     | 165.09     | 165.09     |   0.0 | 99.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15202    | 0.15202    | 0.15202    |   0.0 |  0.09
Output  | 0.0002209  | 0.0002209  | 0.0002209  |   0.0 |  0.00
Modify  | 0.68942    | 0.68942    | 0.68942    |   0.0 |  0.42
Other   |            | 0.09916    |            |       |  0.06

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:      216000.0 ave      216000 max      216000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216000
Ave neighs/atom = 54.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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13891.154   -13891.154   -14025.485   -14025.485    259.87077    259.87077    47819.315    47819.315    442.31513    442.31513 
    2000   -13900.169   -13900.169   -14032.673   -14032.673    256.33861    256.33861    47811.972    47811.972   -61.728756   -61.728756 
Loop time of 183.797 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.470 ns/day, 51.055 hours/ns, 5.441 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    | 182.86     | 182.86     | 182.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14906    | 0.14906    | 0.14906    |   0.0 |  0.08
Output  | 0.00022541 | 0.00022541 | 0.00022541 |   0.0 |  0.00
Modify  | 0.68477    | 0.68477    | 0.68477    |   0.0 |  0.37
Other   |            | 0.09884    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 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:      249250.0 ave      249250 max      249250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249250
Ave neighs/atom = 62.312500
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13900.169   -13900.169   -14032.673   -14032.673    256.33861    256.33861    47811.972    47811.972   -61.728756   -61.728756 
    3000   -13897.662   -13897.662   -14031.622   -14031.622    259.15446    259.15446    47835.404    47835.404   -463.39871   -463.39871 
Loop time of 182.937 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.472 ns/day, 50.816 hours/ns, 5.466 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    | 182.01     | 182.01     | 182.01     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14775    | 0.14775    | 0.14775    |   0.0 |  0.08
Output  | 0.00021652 | 0.00021652 | 0.00021652 |   0.0 |  0.00
Modify  | 0.67817    | 0.67817    | 0.67817    |   0.0 |  0.37
Other   |            | 0.09869    |            |       |  0.05

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:      248858.0 ave      248858 max      248858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248858
Ave neighs/atom = 62.214500
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13897.662   -13897.662   -14031.622   -14031.622    259.15446    259.15446    47835.404    47835.404   -463.39871   -463.39871 
    4000   -13897.892   -13897.892   -14028.238   -14028.238    252.16278    252.16278     47854.41     47854.41   -787.92381   -787.92381 
Loop time of 185.078 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.411 hours/ns, 5.403 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    | 184.14     | 184.14     | 184.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15008    | 0.15008    | 0.15008    |   0.0 |  0.08
Output  | 0.00022057 | 0.00022057 | 0.00022057 |   0.0 |  0.00
Modify  | 0.69023    | 0.69023    | 0.69023    |   0.0 |  0.37
Other   |            | 0.1007     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 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:      248676.0 ave      248676 max      248676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248676
Ave neighs/atom = 62.169000
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13897.892   -13897.892   -14028.238   -14028.238    252.16278    252.16278     47854.41     47854.41   -787.92381   -787.92381 
    5000   -13900.495   -13900.495   -14027.377   -14027.377    245.46265    245.46265    47857.258    47857.258   -765.09366   -765.09366 
Loop time of 183.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.471 ns/day, 50.990 hours/ns, 5.448 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    | 182.63     | 182.63     | 182.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14751    | 0.14751    | 0.14751    |   0.0 |  0.08
Output  | 0.00022717 | 0.00022717 | 0.00022717 |   0.0 |  0.00
Modify  | 0.68605    | 0.68605    | 0.68605    |   0.0 |  0.37
Other   |            | 0.09891    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 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:      248680.0 ave      248680 max      248680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248680
Ave neighs/atom = 62.170000
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 = 254.404964642176, Press = -50.0285102821197
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13900.495   -13900.495   -14027.377   -14027.377    245.46265    245.46265    47857.258    47857.258   -765.09366   -765.09366 
    6000   -13895.302   -13895.302    -14030.37    -14030.37    261.29721    261.29721    47874.139    47874.139   -1380.0524   -1380.0524 
Loop time of 187.296 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.461 ns/day, 52.027 hours/ns, 5.339 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    | 186.32     | 186.32     | 186.32     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15163    | 0.15163    | 0.15163    |   0.0 |  0.08
Output  | 0.00017675 | 0.00017675 | 0.00017675 |   0.0 |  0.00
Modify  | 0.72629    | 0.72629    | 0.72629    |   0.0 |  0.39
Other   |            | 0.09995    |            |       |  0.05

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:      248432.0 ave      248432 max      248432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248432
Ave neighs/atom = 62.108000
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 = 252.675427040044, Press = 10.9561326193758
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13895.302   -13895.302    -14030.37    -14030.37    261.29721    261.29721    47874.139    47874.139   -1380.0524   -1380.0524 
    7000   -13900.818   -13900.818   -14030.162   -14030.162    250.22521    250.22521    47860.016    47860.016   -1100.7327   -1100.7327 
Loop time of 184.418 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.469 ns/day, 51.227 hours/ns, 5.422 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    | 183.46     | 183.46     | 183.46     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14877    | 0.14877    | 0.14877    |   0.0 |  0.08
Output  | 0.00023124 | 0.00023124 | 0.00023124 |   0.0 |  0.00
Modify  | 0.71373    | 0.71373    | 0.71373    |   0.0 |  0.39
Other   |            | 0.09928    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 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:      247876.0 ave      247876 max      247876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247876
Ave neighs/atom = 61.969000
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 = 253.062926440514, Press = 8.16225318298536
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13900.818   -13900.818   -14030.162   -14030.162    250.22521    250.22521    47860.016    47860.016   -1100.7327   -1100.7327 
    8000   -13899.619   -13899.619   -14028.371   -14028.371    249.08023    249.08023    47857.003    47857.003   -844.14076   -844.14076 
Loop time of 183.278 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.471 ns/day, 50.911 hours/ns, 5.456 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    | 182.32     | 182.32     | 182.32     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14909    | 0.14909    | 0.14909    |   0.0 |  0.08
Output  | 0.00021628 | 0.00021628 | 0.00021628 |   0.0 |  0.00
Modify  | 0.71239    | 0.71239    | 0.71239    |   0.0 |  0.39
Other   |            | 0.09905    |            |       |  0.05

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:      248296.0 ave      248296 max      248296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248296
Ave neighs/atom = 62.074000
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 = 253.076891944129, Press = 9.7157804816905
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13899.619   -13899.619   -14028.371   -14028.371    249.08023    249.08023    47857.003    47857.003   -844.14076   -844.14076 
    9000   -13894.193   -13894.193   -14025.313   -14025.313    253.66064    253.66064    47851.931    47851.931    -210.6159    -210.6159 
Loop time of 185.067 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.407 hours/ns, 5.403 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    | 184.1      | 184.1      | 184.1      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15094    | 0.15094    | 0.15094    |   0.0 |  0.08
Output  | 0.00017901 | 0.00017901 | 0.00017901 |   0.0 |  0.00
Modify  | 0.72008    | 0.72008    | 0.72008    |   0.0 |  0.39
Other   |            | 0.0997     |            |       |  0.05

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:      248402.0 ave      248402 max      248402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248402
Ave neighs/atom = 62.100500
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 = 253.342493907335, Press = 8.70241731930785
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13894.193   -13894.193   -14025.313   -14025.313    253.66064    253.66064    47851.931    47851.931    -210.6159    -210.6159 
   10000   -13896.962   -13896.962    -14026.68    -14026.68    250.94912    250.94912     47840.66     47840.66   -155.94223   -155.94223 
Loop time of 183.246 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.471 ns/day, 50.902 hours/ns, 5.457 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    | 182.29     | 182.29     | 182.29     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14921    | 0.14921    | 0.14921    |   0.0 |  0.08
Output  | 0.00017701 | 0.00017701 | 0.00017701 |   0.0 |  0.00
Modify  | 0.70604    | 0.70604    | 0.70604    |   0.0 |  0.39
Other   |            | 0.09859    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 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:      248658.0 ave      248658 max      248658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248658
Ave neighs/atom = 62.164500
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 = 253.253097214102, Press = 8.98708496586452
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13896.962   -13896.962    -14026.68    -14026.68    250.94912    250.94912     47840.66     47840.66   -155.94223   -155.94223 
   11000    -13900.07    -13900.07   -14029.121   -14029.121    249.65846    249.65846    47811.119    47811.119    347.91507    347.91507 
Loop time of 185.014 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.393 hours/ns, 5.405 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    | 184.05     | 184.05     | 184.05     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14963    | 0.14963    | 0.14963    |   0.0 |  0.08
Output  | 0.00017653 | 0.00017653 | 0.00017653 |   0.0 |  0.00
Modify  | 0.7184     | 0.7184     | 0.7184     |   0.0 |  0.39
Other   |            | 0.1002     |            |       |  0.05

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:      248808.0 ave      248808 max      248808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248808
Ave neighs/atom = 62.202000
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 = 253.050301903312, Press = 3.79463382151427
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -13900.07    -13900.07   -14029.121   -14029.121    249.65846    249.65846    47811.119    47811.119    347.91507    347.91507 
   12000   -13894.356   -13894.356   -14027.856   -14027.856    258.26515    258.26515    47817.165    47817.165    554.51753    554.51753 
Loop time of 186.298 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.464 ns/day, 51.749 hours/ns, 5.368 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    | 185.33     | 185.33     | 185.33     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1499     | 0.1499     | 0.1499     |   0.0 |  0.08
Output  | 0.00029449 | 0.00029449 | 0.00029449 |   0.0 |  0.00
Modify  | 0.72128    | 0.72128    | 0.72128    |   0.0 |  0.39
Other   |            | 0.1006     |            |       |  0.05

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:      248940.0 ave      248940 max      248940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248940
Ave neighs/atom = 62.235000
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 = 253.121100217379, Press = 2.24810535576076
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13894.356   -13894.356   -14027.856   -14027.856    258.26515    258.26515    47817.165    47817.165    554.51753    554.51753 
   13000   -13899.102   -13899.102   -14029.904   -14029.904    253.04455    253.04455    47778.245    47778.245    1272.6692    1272.6692 
Loop time of 183.391 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.471 ns/day, 50.942 hours/ns, 5.453 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    | 182.44     | 182.44     | 182.44     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14734    | 0.14734    | 0.14734    |   0.0 |  0.08
Output  | 0.00022362 | 0.00022362 | 0.00022362 |   0.0 |  0.00
Modify  | 0.70568    | 0.70568    | 0.70568    |   0.0 |  0.38
Other   |            | 0.09901    |            |       |  0.05

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:      248604.0 ave      248604 max      248604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248604
Ave neighs/atom = 62.151000
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 = 253.199221595618, Press = 1.40322254891724
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13899.102   -13899.102   -14029.904   -14029.904    253.04455    253.04455    47778.245    47778.245    1272.6692    1272.6692 
   14000   -13897.677   -13897.677   -14027.659   -14027.659    251.45892    251.45892    47769.826    47769.826     1708.336     1708.336 
Loop time of 183.59 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.471 ns/day, 50.997 hours/ns, 5.447 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    | 182.64     | 182.64     | 182.64     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14832    | 0.14832    | 0.14832    |   0.0 |  0.08
Output  | 0.00017969 | 0.00017969 | 0.00017969 |   0.0 |  0.00
Modify  | 0.70821    | 0.70821    | 0.70821    |   0.0 |  0.39
Other   |            | 0.09836    |            |       |  0.05

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:      249436.0 ave      249436 max      249436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249436
Ave neighs/atom = 62.359000
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 = 253.407295218345, Press = -0.956037812069403
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13897.677   -13897.677   -14027.659   -14027.659    251.45892    251.45892    47769.826    47769.826     1708.336     1708.336 
   15000   -13898.711   -13898.711   -14029.579   -14029.579    253.17327    253.17327    47774.288    47774.288    1492.7833    1492.7833 
Loop time of 182.009 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.475 ns/day, 50.558 hours/ns, 5.494 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    | 181.07     | 181.07     | 181.07     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14773    | 0.14773    | 0.14773    |   0.0 |  0.08
Output  | 0.00049802 | 0.00049802 | 0.00049802 |   0.0 |  0.00
Modify  | 0.69552    | 0.69552    | 0.69552    |   0.0 |  0.38
Other   |            | 0.0977     |            |       |  0.05

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:      249708.0 ave      249708 max      249708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249708
Ave neighs/atom = 62.427000
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 = 253.362240374586, Press = -1.73354509840595
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13898.711   -13898.711   -14029.579   -14029.579    253.17327    253.17327    47774.288    47774.288    1492.7833    1492.7833 
   16000   -13897.931   -13897.931   -14029.162   -14029.162    253.87659    253.87659     47801.39     47801.39    713.16232    713.16232 
Loop time of 185.442 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.466 ns/day, 51.512 hours/ns, 5.393 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    | 184.48     | 184.48     | 184.48     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15052    | 0.15052    | 0.15052    |   0.0 |  0.08
Output  | 0.00028551 | 0.00028551 | 0.00028551 |   0.0 |  0.00
Modify  | 0.7157     | 0.7157     | 0.7157     |   0.0 |  0.39
Other   |            | 0.1        |            |       |  0.05

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:      249638.0 ave      249638 max      249638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249638
Ave neighs/atom = 62.409500
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 = 253.356513836829, Press = -2.66221821105308
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13897.931   -13897.931   -14029.162   -14029.162    253.87659    253.87659     47801.39     47801.39    713.16232    713.16232 
   17000   -13900.897   -13900.897   -14028.274   -14028.274     246.4204     246.4204     47820.92     47820.92    210.97267    210.97267 
Loop time of 183.994 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.470 ns/day, 51.109 hours/ns, 5.435 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    | 183.04     | 183.04     | 183.04     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14963    | 0.14963    | 0.14963    |   0.0 |  0.08
Output  | 0.00017827 | 0.00017827 | 0.00017827 |   0.0 |  0.00
Modify  | 0.70838    | 0.70838    | 0.70838    |   0.0 |  0.39
Other   |            | 0.09877    |            |       |  0.05

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:      249082.0 ave      249082 max      249082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249082
Ave neighs/atom = 62.270500
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 = 253.3449200935, Press = -1.47550920420547
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13900.897   -13900.897   -14028.274   -14028.274     246.4204     246.4204     47820.92     47820.92    210.97267    210.97267 
   18000   -13898.668   -13898.668   -14028.974   -14028.974    252.08494    252.08494    47834.119    47834.119   -220.37949   -220.37949 
Loop time of 183.937 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.470 ns/day, 51.093 hours/ns, 5.437 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    | 182.98     | 182.98     | 182.98     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1485     | 0.1485     | 0.1485     |   0.0 |  0.08
Output  | 0.00017592 | 0.00017592 | 0.00017592 |   0.0 |  0.00
Modify  | 0.71006    | 0.71006    | 0.71006    |   0.0 |  0.39
Other   |            | 0.09877    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 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:      248718.0 ave      248718 max      248718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248718
Ave neighs/atom = 62.179500
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 = 253.363012908728, Press = -0.476437959431139
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13898.668   -13898.668   -14028.974   -14028.974    252.08494    252.08494    47834.119    47834.119   -220.37949   -220.37949 
   19000    -13898.54    -13898.54   -14026.558   -14026.558    247.66104    247.66104        47827        47827    208.65871    208.65871 
Loop time of 182.954 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.472 ns/day, 50.821 hours/ns, 5.466 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    | 182        | 182        | 182        |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14873    | 0.14873    | 0.14873    |   0.0 |  0.08
Output  | 0.00017598 | 0.00017598 | 0.00017598 |   0.0 |  0.00
Modify  | 0.70569    | 0.70569    | 0.70569    |   0.0 |  0.39
Other   |            | 0.09844    |            |       |  0.05

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:      248694.0 ave      248694 max      248694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248694
Ave neighs/atom = 62.173500
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 = 253.295566358647, Press = 0.652293706539266
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -13898.54    -13898.54   -14026.558   -14026.558    247.66104    247.66104        47827        47827    208.65871    208.65871 
   20000   -13897.311   -13897.311   -14027.746   -14027.746    252.33465    252.33465      47835.5      47835.5    -112.0763    -112.0763 
Loop time of 181.027 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.477 ns/day, 50.285 hours/ns, 5.524 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    | 180.09     | 180.09     | 180.09     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.146      | 0.146      | 0.146      |   0.0 |  0.08
Output  | 0.00017795 | 0.00017795 | 0.00017795 |   0.0 |  0.00
Modify  | 0.69537    | 0.69537    | 0.69537    |   0.0 |  0.38
Other   |            | 0.09758    |            |       |  0.05

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:      248688.0 ave      248688 max      248688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248688
Ave neighs/atom = 62.172000
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 = 253.258418090781, Press = 0.699430133114411
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13897.311   -13897.311   -14027.746   -14027.746    252.33465    252.33465      47835.5      47835.5    -112.0763    -112.0763 
   21000   -13900.263   -13900.263   -14029.287   -14029.287    249.60611    249.60611    47800.677    47800.677    713.47606    713.47606 
Loop time of 182.533 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.473 ns/day, 50.704 hours/ns, 5.478 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    | 181.58     | 181.58     | 181.58     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14897    | 0.14897    | 0.14897    |   0.0 |  0.08
Output  | 0.00017825 | 0.00017825 | 0.00017825 |   0.0 |  0.00
Modify  | 0.70478    | 0.70478    | 0.70478    |   0.0 |  0.39
Other   |            | 0.09872    |            |       |  0.05

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:      248536.0 ave      248536 max      248536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248536
Ave neighs/atom = 62.134000
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 = 253.28692433105, Press = 0.955244565835294
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13900.263   -13900.263   -14029.287   -14029.287    249.60611    249.60611    47800.677    47800.677    713.47606    713.47606 
   22000   -13895.804   -13895.804    -14028.28    -14028.28    256.28438    256.28438    47788.002    47788.002    1252.3411    1252.3411 
Loop time of 184.735 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.468 ns/day, 51.315 hours/ns, 5.413 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    | 183.77     | 183.77     | 183.77     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14849    | 0.14849    | 0.14849    |   0.0 |  0.08
Output  | 0.00017614 | 0.00017614 | 0.00017614 |   0.0 |  0.00
Modify  | 0.71586    | 0.71586    | 0.71586    |   0.0 |  0.39
Other   |            | 0.1        |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 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:      249282.0 ave      249282 max      249282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249282
Ave neighs/atom = 62.320500
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 = 253.344173005738, Press = 0.481695918565459
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13895.804   -13895.804    -14028.28    -14028.28    256.28438    256.28438    47788.002    47788.002    1252.3411    1252.3411 
   23000   -13897.624   -13897.624   -14029.152   -14029.152    254.44952    254.44952    47780.151    47780.151    1324.4685    1324.4685 
Loop time of 184.145 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.469 ns/day, 51.151 hours/ns, 5.431 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    | 183.18     | 183.18     | 183.18     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14971    | 0.14971    | 0.14971    |   0.0 |  0.08
Output  | 0.00017647 | 0.00017647 | 0.00017647 |   0.0 |  0.00
Modify  | 0.71378    | 0.71378    | 0.71378    |   0.0 |  0.39
Other   |            | 0.1003     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 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:      249446.0 ave      249446 max      249446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249446
Ave neighs/atom = 62.361500
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 = 253.342350445789, Press = 0.257222282922906
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13897.624   -13897.624   -14029.152   -14029.152    254.44952    254.44952    47780.151    47780.151    1324.4685    1324.4685 
   24000   -13898.934   -13898.934   -14031.361   -14031.361    256.18889    256.18889    47781.192    47781.192    1050.2776    1050.2776 
Loop time of 183.865 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.470 ns/day, 51.074 hours/ns, 5.439 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    | 182.91     | 182.91     | 182.91     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14931    | 0.14931    | 0.14931    |   0.0 |  0.08
Output  | 0.00017861 | 0.00017861 | 0.00017861 |   0.0 |  0.00
Modify  | 0.71029    | 0.71029    | 0.71029    |   0.0 |  0.39
Other   |            | 0.09864    |            |       |  0.05

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:      249404.0 ave      249404 max      249404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249404
Ave neighs/atom = 62.351000
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 = 253.40681958891, Press = -0.859606779858275
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13898.934   -13898.934   -14031.361   -14031.361    256.18889    256.18889    47781.192    47781.192    1050.2776    1050.2776 
   25000   -13899.618   -13899.618   -14029.698   -14029.698     251.6487     251.6487     47768.82     47768.82    1652.3378    1652.3378 
Loop time of 183.809 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.470 ns/day, 51.058 hours/ns, 5.440 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    | 182.85     | 182.85     | 182.85     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14798    | 0.14798    | 0.14798    |   0.0 |  0.08
Output  | 0.00022173 | 0.00022173 | 0.00022173 |   0.0 |  0.00
Modify  | 0.71125    | 0.71125    | 0.71125    |   0.0 |  0.39
Other   |            | 0.09869    |            |       |  0.05

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:      249140.0 ave      249140 max      249140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249140
Ave neighs/atom = 62.285000
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 = 253.432323313037, Press = -2.554743817224
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13899.618   -13899.618   -14029.698   -14029.698     251.6487     251.6487     47768.82     47768.82    1652.3378    1652.3378 
   26000   -13896.243   -13896.243   -14028.189   -14028.189    255.25917    255.25917    47818.438    47818.438     266.1682     266.1682 
Loop time of 183.349 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.471 ns/day, 50.930 hours/ns, 5.454 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    | 182.39     | 182.39     | 182.39     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14838    | 0.14838    | 0.14838    |   0.0 |  0.08
Output  | 0.00017673 | 0.00017673 | 0.00017673 |   0.0 |  0.00
Modify  | 0.70665    | 0.70665    | 0.70665    |   0.0 |  0.39
Other   |            | 0.09914    |            |       |  0.05

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:      249628.0 ave      249628 max      249628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249628
Ave neighs/atom = 62.407000
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 = 253.451866570181, Press = -2.76665191461382
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13896.243   -13896.243   -14028.189   -14028.189    255.25917    255.25917    47818.438    47818.438     266.1682     266.1682 
   27000   -13896.343   -13896.343   -14029.431   -14029.431     257.4671     257.4671    47841.112    47841.112    -413.1292    -413.1292 
Loop time of 184.89 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.358 hours/ns, 5.409 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    | 183.93     | 183.93     | 183.93     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14976    | 0.14976    | 0.14976    |   0.0 |  0.08
Output  | 0.0001804  | 0.0001804  | 0.0001804  |   0.0 |  0.00
Modify  | 0.71254    | 0.71254    | 0.71254    |   0.0 |  0.39
Other   |            | 0.09973    |            |       |  0.05

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:      249118.0 ave      249118 max      249118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249118
Ave neighs/atom = 62.279500
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 = 253.426832932512, Press = -0.592640170479227
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13896.343   -13896.343   -14029.431   -14029.431     257.4671     257.4671    47841.112    47841.112    -413.1292    -413.1292 
   28000   -13899.379   -13899.379   -14028.442   -14028.442    249.68106    249.68106    47842.248    47842.248   -413.90702   -413.90702 
Loop time of 184.538 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.468 ns/day, 51.261 hours/ns, 5.419 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    | 183.58     | 183.58     | 183.58     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14995    | 0.14995    | 0.14995    |   0.0 |  0.08
Output  | 0.0001745  | 0.0001745  | 0.0001745  |   0.0 |  0.00
Modify  | 0.71279    | 0.71279    | 0.71279    |   0.0 |  0.39
Other   |            | 0.09947    |            |       |  0.05

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:      248324.0 ave      248324 max      248324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248324
Ave neighs/atom = 62.081000
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 = 253.473254146921, Press = -0.0919635524528976
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13899.379   -13899.379   -14028.442   -14028.442    249.68106    249.68106    47842.248    47842.248   -413.90702   -413.90702 
   29000   -13895.206   -13895.206   -14026.277   -14026.277    253.56546    253.56546    47882.245    47882.245    -1373.156    -1373.156 
Loop time of 184.018 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.470 ns/day, 51.116 hours/ns, 5.434 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    | 183.06     | 183.06     | 183.06     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14832    | 0.14832    | 0.14832    |   0.0 |  0.08
Output  | 0.00021836 | 0.00021836 | 0.00021836 |   0.0 |  0.00
Modify  | 0.70558    | 0.70558    | 0.70558    |   0.0 |  0.38
Other   |            | 0.1        |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 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:      248478.0 ave      248478 max      248478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248478
Ave neighs/atom = 62.119500
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 = 253.518310284666, Press = 1.15737715558908
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13895.206   -13895.206   -14026.277   -14026.277    253.56546    253.56546    47882.245    47882.245    -1373.156    -1373.156 
   30000   -13900.931   -13900.931   -14030.641   -14030.641    250.93358    250.93358    47866.881    47866.881    -1395.672    -1395.672 
Loop time of 181.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.475 ns/day, 50.482 hours/ns, 5.502 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    | 180.79     | 180.79     | 180.79     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14769    | 0.14769    | 0.14769    |   0.0 |  0.08
Output  | 0.00022282 | 0.00022282 | 0.00022282 |   0.0 |  0.00
Modify  | 0.69724    | 0.69724    | 0.69724    |   0.0 |  0.38
Other   |            | 0.09904    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5837.00 ave        5837 max        5837 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:      248024.0 ave      248024 max      248024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248024
Ave neighs/atom = 62.006000
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 = 253.484581743926, Press = 2.2064346244579
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13900.931   -13900.931   -14030.641   -14030.641    250.93358    250.93358    47866.881    47866.881    -1395.672    -1395.672 
   31000    -13897.12    -13897.12    -14027.53    -14027.53    252.28797    252.28797    47823.642    47823.642    139.72765    139.72765 
Loop time of 180.164 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.480 ns/day, 50.046 hours/ns, 5.550 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    | 179.22     | 179.22     | 179.22     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14839    | 0.14839    | 0.14839    |   0.0 |  0.08
Output  | 0.00017781 | 0.00017781 | 0.00017781 |   0.0 |  0.00
Modify  | 0.69373    | 0.69373    | 0.69373    |   0.0 |  0.39
Other   |            | 0.09863    |            |       |  0.05

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:      247978.0 ave      247978 max      247978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247978
Ave neighs/atom = 61.994500
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 = 253.470457353155, Press = 0.85596703812929
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000    -13897.12    -13897.12    -14027.53    -14027.53    252.28797    252.28797    47823.642    47823.642    139.72765    139.72765 
   32000   -13897.996   -13897.996    -14031.73    -14031.73    258.71737    258.71737    47833.345    47833.345   -455.27608   -455.27608 
Loop time of 179.904 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.480 ns/day, 49.973 hours/ns, 5.559 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    | 178.97     | 178.97     | 178.97     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14562    | 0.14562    | 0.14562    |   0.0 |  0.08
Output  | 0.00017944 | 0.00017944 | 0.00017944 |   0.0 |  0.00
Modify  | 0.68667    | 0.68667    | 0.68667    |   0.0 |  0.38
Other   |            | 0.09804    |            |       |  0.05

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:      249008.0 ave      249008 max      249008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249008
Ave neighs/atom = 62.252000
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 = 253.391156049669, Press = 0.503321626314475
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13897.996   -13897.996    -14031.73    -14031.73    258.71737    258.71737    47833.345    47833.345   -455.27608   -455.27608 
   33000   -13901.313   -13901.313   -14030.789   -14030.789    250.47853    250.47853    47817.099    47817.099    104.42801    104.42801 
Loop time of 179.612 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.481 ns/day, 49.892 hours/ns, 5.568 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    | 178.67     | 178.67     | 178.67     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14814    | 0.14814    | 0.14814    |   0.0 |  0.08
Output  | 0.00022337 | 0.00022337 | 0.00022337 |   0.0 |  0.00
Modify  | 0.69036    | 0.69036    | 0.69036    |   0.0 |  0.38
Other   |            | 0.09843    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 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:      248322.0 ave      248322 max      248322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248322
Ave neighs/atom = 62.080500
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 = 253.36028115221, Press = 1.22582597654089
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13901.313   -13901.313   -14030.789   -14030.789    250.47853    250.47853    47817.099    47817.099    104.42801    104.42801 
   34000    -13896.19    -13896.19   -14028.042   -14028.042    255.07556    255.07556    47802.734    47802.734    823.59452    823.59452 
Loop time of 184.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.367 hours/ns, 5.408 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    | 183.95     | 183.95     | 183.95     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15016    | 0.15016    | 0.15016    |   0.0 |  0.08
Output  | 0.00017685 | 0.00017685 | 0.00017685 |   0.0 |  0.00
Modify  | 0.71679    | 0.71679    | 0.71679    |   0.0 |  0.39
Other   |            | 0.09898    |            |       |  0.05

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:      248822.0 ave      248822 max      248822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248822
Ave neighs/atom = 62.205500
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 = 253.349032814035, Press = 1.70587321240551
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -13896.19    -13896.19   -14028.042   -14028.042    255.07556    255.07556    47802.734    47802.734    823.59452    823.59452 
   35000   -13898.244   -13898.244   -14027.364   -14027.364    249.79162    249.79162    47747.566    47747.566    2404.1023    2404.1023 
Loop time of 179.98 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.480 ns/day, 49.995 hours/ns, 5.556 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    | 179.05     | 179.05     | 179.05     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14569    | 0.14569    | 0.14569    |   0.0 |  0.08
Output  | 0.00017951 | 0.00017951 | 0.00017951 |   0.0 |  0.00
Modify  | 0.69039    | 0.69039    | 0.69039    |   0.0 |  0.38
Other   |            | 0.09839    |            |       |  0.05

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:      249412.0 ave      249412 max      249412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249412
Ave neighs/atom = 62.353000
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 = 253.373472286509, Press = 1.60656086777347
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13898.244   -13898.244   -14027.364   -14027.364    249.79162    249.79162    47747.566    47747.566    2404.1023    2404.1023 
   36000   -13894.933   -13894.933   -14027.668   -14027.668     256.7844     256.7844    47799.974    47799.974    1008.0477    1008.0477 
Loop time of 180.894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.478 ns/day, 50.248 hours/ns, 5.528 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    | 179.96     | 179.96     | 179.96     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14599    | 0.14599    | 0.14599    |   0.0 |  0.08
Output  | 0.00017215 | 0.00017215 | 0.00017215 |   0.0 |  0.00
Modify  | 0.68778    | 0.68778    | 0.68778    |   0.0 |  0.38
Other   |            | 0.09805    |            |       |  0.05

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:      249830.0 ave      249830 max      249830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249830
Ave neighs/atom = 62.457500
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 = 253.383836879419, Press = 0.376084331372004
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13894.933   -13894.933   -14027.668   -14027.668     256.7844     256.7844    47799.974    47799.974    1008.0477    1008.0477 
   37000   -13899.239   -13899.239   -14028.224   -14028.224    249.52937    249.52937    47784.403    47784.403    1236.5297    1236.5297 
Loop time of 181.044 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.477 ns/day, 50.290 hours/ns, 5.524 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    | 180.11     | 180.11     | 180.11     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14615    | 0.14615    | 0.14615    |   0.0 |  0.08
Output  | 0.00017935 | 0.00017935 | 0.00017935 |   0.0 |  0.00
Modify  | 0.69066    | 0.69066    | 0.69066    |   0.0 |  0.38
Other   |            | 0.09838    |            |       |  0.05

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:      249102.0 ave      249102 max      249102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249102
Ave neighs/atom = 62.275500
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 = 253.361526993566, Press = 0.181716500465411
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13899.239   -13899.239   -14028.224   -14028.224    249.52937    249.52937    47784.403    47784.403    1236.5297    1236.5297 
   38000   -13900.566   -13900.566   -14030.452   -14030.452    251.27257    251.27257    47787.114    47787.114    1014.6568    1014.6568 
Loop time of 178.516 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.484 ns/day, 49.588 hours/ns, 5.602 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    | 177.6      | 177.6      | 177.6      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14347    | 0.14347    | 0.14347    |   0.0 |  0.08
Output  | 0.00023501 | 0.00023501 | 0.00023501 |   0.0 |  0.00
Modify  | 0.67707    | 0.67707    | 0.67707    |   0.0 |  0.38
Other   |            | 0.09728    |            |       |  0.05

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:      249398.0 ave      249398 max      249398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249398
Ave neighs/atom = 62.349500
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 = 253.342662732608, Press = 0.211635874686482
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13900.566   -13900.566   -14030.452   -14030.452    251.27257    251.27257    47787.114    47787.114    1014.6568    1014.6568 
   39000   -13897.715   -13897.715   -14029.802   -14029.802    255.53147    255.53147    47757.904    47757.904     1942.022     1942.022 
Loop time of 179.625 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.481 ns/day, 49.896 hours/ns, 5.567 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    | 178.7      | 178.7      | 178.7      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14499    | 0.14499    | 0.14499    |   0.0 |  0.08
Output  | 0.00017699 | 0.00017699 | 0.00017699 |   0.0 |  0.00
Modify  | 0.68572    | 0.68572    | 0.68572    |   0.0 |  0.38
Other   |            | 0.09765    |            |       |  0.05

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:      249084.0 ave      249084 max      249084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249084
Ave neighs/atom = 62.271000
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 = 253.282060013887, Press = 0.513922202827183
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13897.715   -13897.715   -14029.802   -14029.802    255.53147    255.53147    47757.904    47757.904     1942.022     1942.022 
   40000   -13900.231   -13900.231    -14028.61    -14028.61    248.35621    248.35621    47748.149    47748.149    2299.7478    2299.7478 
Loop time of 180.409 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.479 ns/day, 50.114 hours/ns, 5.543 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    | 179.48     | 179.48     | 179.48     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14463    | 0.14463    | 0.14463    |   0.0 |  0.08
Output  | 0.00018013 | 0.00018013 | 0.00018013 |   0.0 |  0.00
Modify  | 0.69048    | 0.69048    | 0.69048    |   0.0 |  0.38
Other   |            | 0.09837    |            |       |  0.05

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:      249338.0 ave      249338 max      249338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249338
Ave neighs/atom = 62.334500
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 = 253.274826139986, Press = -0.465829999493225
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13900.231   -13900.231    -14028.61    -14028.61    248.35621    248.35621    47748.149    47748.149    2299.7478    2299.7478 
   41000    -13896.84    -13896.84   -14029.124   -14029.124    255.91236    255.91236    47805.786    47805.786    636.85448    636.85448 
Loop time of 181.038 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.477 ns/day, 50.288 hours/ns, 5.524 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    | 180.1      | 180.1      | 180.1      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14581    | 0.14581    | 0.14581    |   0.0 |  0.08
Output  | 0.00050756 | 0.00050756 | 0.00050756 |   0.0 |  0.00
Modify  | 0.69056    | 0.69056    | 0.69056    |   0.0 |  0.38
Other   |            | 0.09692    |            |       |  0.05

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:      249668.0 ave      249668 max      249668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249668
Ave neighs/atom = 62.417000
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 = 253.253990271191, Press = -0.293030529899379
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000    -13896.84    -13896.84   -14029.124   -14029.124    255.91236    255.91236    47805.786    47805.786    636.85448    636.85448 
   42000   -13901.627   -13901.627   -14029.805   -14029.805    247.96905    247.96905    47808.265    47808.265    334.42377    334.42377 
Loop time of 180.319 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.479 ns/day, 50.088 hours/ns, 5.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    | 179.39     | 179.39     | 179.39     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14535    | 0.14535    | 0.14535    |   0.0 |  0.08
Output  | 0.00017503 | 0.00017503 | 0.00017503 |   0.0 |  0.00
Modify  | 0.68774    | 0.68774    | 0.68774    |   0.0 |  0.38
Other   |            | 0.09751    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 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:      248702.0 ave      248702 max      248702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248702
Ave neighs/atom = 62.175500
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 = 253.218096476576, Press = -0.311867387722696
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13901.627   -13901.627   -14029.805   -14029.805    247.96905    247.96905    47808.265    47808.265    334.42377    334.42377 
   43000   -13895.841   -13895.841   -14028.709   -14028.709    257.04072    257.04072    47825.837    47825.837    60.193632    60.193632 
Loop time of 180.109 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.480 ns/day, 50.030 hours/ns, 5.552 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    | 179.17     | 179.17     | 179.17     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14608    | 0.14608    | 0.14608    |   0.0 |  0.08
Output  | 0.00018045 | 0.00018045 | 0.00018045 |   0.0 |  0.00
Modify  | 0.69181    | 0.69181    | 0.69181    |   0.0 |  0.38
Other   |            | 0.09759    |            |       |  0.05

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:      249082.0 ave      249082 max      249082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249082
Ave neighs/atom = 62.270500
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 = 253.191002980715, Press = -0.25950082363658
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13895.841   -13895.841   -14028.709   -14028.709    257.04072    257.04072    47825.837    47825.837    60.193632    60.193632 
   44000   -13899.554   -13899.554   -14031.188   -14031.188    254.65383    254.65383    47843.414    47843.414   -728.05141   -728.05141 
Loop time of 180.494 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.479 ns/day, 50.137 hours/ns, 5.540 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    | 179.56     | 179.56     | 179.56     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14692    | 0.14692    | 0.14692    |   0.0 |  0.08
Output  | 0.00017456 | 0.00017456 | 0.00017456 |   0.0 |  0.00
Modify  | 0.6892     | 0.6892     | 0.6892     |   0.0 |  0.38
Other   |            | 0.0984     |            |       |  0.05

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:      248902.0 ave      248902 max      248902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248902
Ave neighs/atom = 62.225500
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 = 253.154055957784, Press = -1.49260621051702
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13899.554   -13899.554   -14031.188   -14031.188    254.65383    254.65383    47843.414    47843.414   -728.05141   -728.05141 
   45000   -13895.108   -13895.108   -14026.509   -14026.509    254.20387    254.20387    47898.193    47898.193   -1700.7869   -1700.7869 
Loop time of 180.591 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.478 ns/day, 50.164 hours/ns, 5.537 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    | 179.66     | 179.66     | 179.66     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14568    | 0.14568    | 0.14568    |   0.0 |  0.08
Output  | 0.00017972 | 0.00017972 | 0.00017972 |   0.0 |  0.00
Modify  | 0.69214    | 0.69214    | 0.69214    |   0.0 |  0.38
Other   |            | 0.09821    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 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:      248280.0 ave      248280 max      248280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248280
Ave neighs/atom = 62.070000
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 = 253.152113502562, Press = -1.53358503291889
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13895.108   -13895.108   -14026.509   -14026.509    254.20387    254.20387    47898.193    47898.193   -1700.7869   -1700.7869 
   46000   -13899.362   -13899.362   -14030.421   -14030.421    253.54097    253.54097    47856.796    47856.796   -1015.5713   -1015.5713 
Loop time of 181.064 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.477 ns/day, 50.295 hours/ns, 5.523 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    | 180.12     | 180.12     | 180.12     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14712    | 0.14712    | 0.14712    |   0.0 |  0.08
Output  | 0.00018393 | 0.00018393 | 0.00018393 |   0.0 |  0.00
Modify  | 0.69596    | 0.69596    | 0.69596    |   0.0 |  0.38
Other   |            | 0.09791    |            |       |  0.05

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:      248154.0 ave      248154 max      248154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248154
Ave neighs/atom = 62.038500
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 = 253.169996834908, Press = -0.474806222269486
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.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13899.362   -13899.362   -14030.421   -14030.421    253.54097    253.54097    47856.796    47856.796   -1015.5713   -1015.5713 
   47000   -13897.632   -13897.632   -14029.719   -14029.719    255.53116    255.53116    47860.767    47860.767   -1001.8706   -1001.8706 
Loop time of 180.005 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.480 ns/day, 50.001 hours/ns, 5.555 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    | 179.07     | 179.07     | 179.07     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14531    | 0.14531    | 0.14531    |   0.0 |  0.08
Output  | 0.0002023  | 0.0002023  | 0.0002023  |   0.0 |  0.00
Modify  | 0.69087    | 0.69087    | 0.69087    |   0.0 |  0.38
Other   |            | 0.0974     |            |       |  0.05

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:      248524.0 ave      248524 max      248524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248524
Ave neighs/atom = 62.131000
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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
47826.4355907052

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0