# 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.619999974966049*${_u_distance}
variable latticeconst_converted equal 3.619999974966049*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61999997496605
Lattice spacing in x,y,z = 3.6200000 3.6200000 3.6200000
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.200000 36.200000 36.200000)
  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.200000 36.200000 36.200000)
  create_atoms CPU = 0.004 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_Wagner_2007_Cu__MO_313717476091_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 47437.9270158353    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47437.9270158353/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47437.9270158353/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 47437.9270158353/(1*1*${_u_distance})
variable      V0_metal equal 47437.9270158353/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 47437.9270158353*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_313717476091_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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -14018.806   -14018.806       -14160       -14160       273.15       273.15    47437.927    47437.927    3179.1678    3179.1678 
    1000   -13896.407   -13896.407   -14034.852   -14034.852    267.83013    267.83013     47805.75     47805.75     106.2064     106.2064 
Loop time of 194.752 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.098 hours/ns, 5.135 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    | 193.82     | 193.82     | 193.82     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15488    | 0.15488    | 0.15488    |   0.0 |  0.08
Output  | 0.0002761  | 0.0002761  | 0.0002761  |   0.0 |  0.00
Modify  | 0.67716    | 0.67716    | 0.67716    |   0.0 |  0.35
Other   |            | 0.09697    |            |       |  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:      312000.0 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78.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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13896.407   -13896.407   -14034.852   -14034.852    267.83013    267.83013     47805.75     47805.75     106.2064     106.2064 
    2000   -13888.442   -13888.442   -14032.826   -14032.826    279.32134    279.32134    47832.368    47832.368   -777.66863   -777.66863 
Loop time of 202.426 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.229 hours/ns, 4.940 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    | 201.51     | 201.51     | 201.51     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15312    | 0.15312    | 0.15312    |   0.0 |  0.08
Output  | 0.00026349 | 0.00026349 | 0.00026349 |   0.0 |  0.00
Modify  | 0.6701     | 0.6701     | 0.6701     |   0.0 |  0.33
Other   |            | 0.09724    |            |       |  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:      311706.0 ave      311706 max      311706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311706
Ave neighs/atom = 77.926500
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13888.442   -13888.442   -14032.826   -14032.826    279.32134    279.32134    47832.368    47832.368   -777.66863   -777.66863 
    3000   -13892.643   -13892.643   -14035.569   -14035.569    276.49896    276.49896    47756.666    47756.666     1198.151     1198.151 
Loop time of 203.089 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.414 hours/ns, 4.924 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    | 202.17     | 202.17     | 202.17     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15372    | 0.15372    | 0.15372    |   0.0 |  0.08
Output  | 0.00021104 | 0.00021104 | 0.00021104 |   0.0 |  0.00
Modify  | 0.67051    | 0.67051    | 0.67051    |   0.0 |  0.33
Other   |            | 0.09777    |            |       |  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:      311638.0 ave      311638 max      311638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311638
Ave neighs/atom = 77.909500
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13892.643   -13892.643   -14035.569   -14035.569    276.49896    276.49896    47756.666    47756.666     1198.151     1198.151 
    4000   -13893.475   -13893.475   -14033.534   -14033.534    270.95312    270.95312    47831.344    47831.344   -961.25823   -961.25823 
Loop time of 202.579 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.272 hours/ns, 4.936 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    | 201.66     | 201.66     | 201.66     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15157    | 0.15157    | 0.15157    |   0.0 |  0.07
Output  | 0.00021722 | 0.00021722 | 0.00021722 |   0.0 |  0.00
Modify  | 0.66875    | 0.66875    | 0.66875    |   0.0 |  0.33
Other   |            | 0.09781    |            |       |  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:      311750.0 ave      311750 max      311750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311750
Ave neighs/atom = 77.937500
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13893.475   -13893.475   -14033.534   -14033.534    270.95312    270.95312    47831.344    47831.344   -961.25823   -961.25823 
    5000   -13890.728   -13890.728   -14033.315   -14033.315    275.84475    275.84475     47810.28     47810.28   -65.045484   -65.045484 
Loop time of 203.045 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.401 hours/ns, 4.925 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    | 202.12     | 202.12     | 202.12     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15165    | 0.15165    | 0.15165    |   0.0 |  0.07
Output  | 0.00017837 | 0.00017837 | 0.00017837 |   0.0 |  0.00
Modify  | 0.67228    | 0.67228    | 0.67228    |   0.0 |  0.33
Other   |            | 0.09895    |            |       |  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:      311684.0 ave      311684 max      311684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311684
Ave neighs/atom = 77.921000
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 = 275.549534778812, Press = 317.18362491047
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13890.728   -13890.728   -14033.315   -14033.315    275.84475    275.84475     47810.28     47810.28   -65.045484   -65.045484 
    6000   -13892.889   -13892.889   -14033.468   -14033.468    271.95989    271.95989    47765.003    47765.003    1018.6914    1018.6914 
Loop time of 203.427 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.508 hours/ns, 4.916 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    | 202.48     | 202.48     | 202.48     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15121    | 0.15121    | 0.15121    |   0.0 |  0.07
Output  | 0.00017848 | 0.00017848 | 0.00017848 |   0.0 |  0.00
Modify  | 0.69639    | 0.69639    | 0.69639    |   0.0 |  0.34
Other   |            | 0.09861    |            |       |  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:      311660.0 ave      311660 max      311660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311660
Ave neighs/atom = 77.915000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.113330999165, Press = -7.15961052130919
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13892.889   -13892.889   -14033.468   -14033.468    271.95989    271.95989    47765.003    47765.003    1018.6914    1018.6914 
    7000   -13895.175   -13895.175   -14035.892   -14035.892    272.22701    272.22701     47856.91     47856.91   -1464.6158   -1464.6158 
Loop time of 202.735 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.315 hours/ns, 4.933 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    | 201.79     | 201.79     | 201.79     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15192    | 0.15192    | 0.15192    |   0.0 |  0.07
Output  | 0.0001792  | 0.0001792  | 0.0001792  |   0.0 |  0.00
Modify  | 0.69395    | 0.69395    | 0.69395    |   0.0 |  0.34
Other   |            | 0.09815    |            |       |  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:      311702.0 ave      311702 max      311702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311702
Ave neighs/atom = 77.925500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.303532474388, Press = 3.66230377707243
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13895.175   -13895.175   -14035.892   -14035.892    272.22701    272.22701     47856.91     47856.91   -1464.6158   -1464.6158 
    8000   -13889.526   -13889.526   -14032.946   -14032.946    277.45627    277.45627    47770.259    47770.259    906.93376    906.93376 
Loop time of 202.089 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.136 hours/ns, 4.948 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    | 201.14     | 201.14     | 201.14     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15243    | 0.15243    | 0.15243    |   0.0 |  0.08
Output  | 0.00017929 | 0.00017929 | 0.00017929 |   0.0 |  0.00
Modify  | 0.69629    | 0.69629    | 0.69629    |   0.0 |  0.34
Other   |            | 0.09777    |            |       |  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:      311644.0 ave      311644 max      311644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311644
Ave neighs/atom = 77.911000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.801353992736, Press = 13.2726336092695
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13889.526   -13889.526   -14032.946   -14032.946    277.45627    277.45627    47770.259    47770.259    906.93376    906.93376 
    9000   -13891.367   -13891.367   -14032.672   -14032.672    273.36384    273.36384    47763.969    47763.969     995.3072     995.3072 
Loop time of 202.006 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.113 hours/ns, 4.950 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    | 201.07     | 201.07     | 201.07     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15198    | 0.15198    | 0.15198    |   0.0 |  0.08
Output  | 0.00018325 | 0.00018325 | 0.00018325 |   0.0 |  0.00
Modify  | 0.68896    | 0.68896    | 0.68896    |   0.0 |  0.34
Other   |            | 0.09757    |            |       |  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:      311612.0 ave      311612 max      311612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311612
Ave neighs/atom = 77.903000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.723937028041, Press = -6.07781744659235
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13891.367   -13891.367   -14032.672   -14032.672    273.36384    273.36384    47763.969    47763.969     995.3072     995.3072 
   10000   -13894.766   -13894.766   -14035.058   -14035.058    271.40383    271.40383     47830.76     47830.76   -1068.1783   -1068.1783 
Loop time of 202.633 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.287 hours/ns, 4.935 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    | 201.69     | 201.69     | 201.69     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1541     | 0.1541     | 0.1541     |   0.0 |  0.08
Output  | 0.000221   | 0.000221   | 0.000221   |   0.0 |  0.00
Modify  | 0.69329    | 0.69329    | 0.69329    |   0.0 |  0.34
Other   |            | 0.09755    |            |       |  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:      311708.0 ave      311708 max      311708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311708
Ave neighs/atom = 77.927000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.962207559981, Press = -1.49945495534573
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13894.766   -13894.766   -14035.058   -14035.058    271.40383    271.40383     47830.76     47830.76   -1068.1783   -1068.1783 
   11000   -13895.879   -13895.879   -14035.241   -14035.241    269.60403    269.60403    47811.555    47811.555   -281.03258   -281.03258 
Loop time of 203.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.622 hours/ns, 4.906 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    | 202.89     | 202.89     | 202.89     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15388    | 0.15388    | 0.15388    |   0.0 |  0.08
Output  | 0.00017909 | 0.00017909 | 0.00017909 |   0.0 |  0.00
Modify  | 0.69851    | 0.69851    | 0.69851    |   0.0 |  0.34
Other   |            | 0.09752    |            |       |  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:      311642.0 ave      311642 max      311642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311642
Ave neighs/atom = 77.910500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.864089922855, Press = 9.11961720869861
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13895.879   -13895.879   -14035.241   -14035.241    269.60403    269.60403    47811.555    47811.555   -281.03258   -281.03258 
   12000   -13890.318   -13890.318    -14030.32    -14030.32     270.8434     270.8434    47756.401    47756.401    1011.6907    1011.6907 
Loop time of 201.961 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.100 hours/ns, 4.951 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    | 201.02     | 201.02     | 201.02     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15114    | 0.15114    | 0.15114    |   0.0 |  0.07
Output  | 0.0001785  | 0.0001785  | 0.0001785  |   0.0 |  0.00
Modify  | 0.68897    | 0.68897    | 0.68897    |   0.0 |  0.34
Other   |            | 0.09745    |            |       |  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:      311678.0 ave      311678 max      311678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311678
Ave neighs/atom = 77.919500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.524514980519, Press = -1.36654692783446
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13890.318   -13890.318    -14030.32    -14030.32     270.8434     270.8434    47756.401    47756.401    1011.6907    1011.6907 
   13000   -13887.843   -13887.843   -14034.047   -14034.047    282.84007    282.84007    47851.903    47851.903   -1438.4068   -1438.4068 
Loop time of 202.827 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.341 hours/ns, 4.930 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    | 201.88     | 201.88     | 201.88     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1529     | 0.1529     | 0.1529     |   0.0 |  0.08
Output  | 0.0001785  | 0.0001785  | 0.0001785  |   0.0 |  0.00
Modify  | 0.69091    | 0.69091    | 0.69091    |   0.0 |  0.34
Other   |            | 0.09811    |            |       |  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:      311628.0 ave      311628 max      311628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311628
Ave neighs/atom = 77.907000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.515345460079, Press = 2.19928994632876
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13887.843   -13887.843   -14034.047   -14034.047    282.84007    282.84007    47851.903    47851.903   -1438.4068   -1438.4068 
   14000   -13894.037   -13894.037   -14036.142   -14036.142    274.91036    274.91036    47779.174    47779.174    541.16483    541.16483 
Loop time of 203.147 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.430 hours/ns, 4.923 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    | 202.2      | 202.2      | 202.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15316    | 0.15316    | 0.15316    |   0.0 |  0.08
Output  | 0.00017757 | 0.00017757 | 0.00017757 |   0.0 |  0.00
Modify  | 0.6945     | 0.6945     | 0.6945     |   0.0 |  0.34
Other   |            | 0.09826    |            |       |  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:      311576.0 ave      311576 max      311576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311576
Ave neighs/atom = 77.894000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.642796417245, Press = 2.44843699486638
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13894.037   -13894.037   -14036.142   -14036.142    274.91036    274.91036    47779.174    47779.174    541.16483    541.16483 
   15000   -13888.292   -13888.292   -14030.083   -14030.083     274.3042     274.3042    47814.574    47814.574   -473.56715   -473.56715 
Loop time of 203.441 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.511 hours/ns, 4.915 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    | 202.49     | 202.49     | 202.49     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.152      | 0.152      | 0.152      |   0.0 |  0.07
Output  | 0.00022728 | 0.00022728 | 0.00022728 |   0.0 |  0.00
Modify  | 0.69612    | 0.69612    | 0.69612    |   0.0 |  0.34
Other   |            | 0.09835    |            |       |  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:      311664.0 ave      311664 max      311664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311664
Ave neighs/atom = 77.916000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.721975073721, Press = 0.620784778209606
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13888.292   -13888.292   -14030.083   -14030.083     274.3042     274.3042    47814.574    47814.574   -473.56715   -473.56715 
   16000   -13889.556   -13889.556    -14031.61    -14031.61    274.81366    274.81366     47797.92     47797.92    127.94096    127.94096 
Loop time of 203.169 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.436 hours/ns, 4.922 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    | 202.22     | 202.22     | 202.22     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15164    | 0.15164    | 0.15164    |   0.0 |  0.07
Output  | 0.00017819 | 0.00017819 | 0.00017819 |   0.0 |  0.00
Modify  | 0.69632    | 0.69632    | 0.69632    |   0.0 |  0.34
Other   |            | 0.09833    |            |       |  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:      311568.0 ave      311568 max      311568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311568
Ave neighs/atom = 77.892000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.702244945163, Press = 3.17515179241432
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13889.556   -13889.556    -14031.61    -14031.61    274.81366    274.81366     47797.92     47797.92    127.94096    127.94096 
   17000   -13891.955   -13891.955   -14031.844   -14031.844    270.62547    270.62547    47773.919    47773.919    817.68304    817.68304 
Loop time of 204.084 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.690 hours/ns, 4.900 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    | 203.13     | 203.13     | 203.13     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15299    | 0.15299    | 0.15299    |   0.0 |  0.07
Output  | 0.00017433 | 0.00017433 | 0.00017433 |   0.0 |  0.00
Modify  | 0.69966    | 0.69966    | 0.69966    |   0.0 |  0.34
Other   |            | 0.09813    |            |       |  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:      311646.0 ave      311646 max      311646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311646
Ave neighs/atom = 77.911500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.652293379447, Press = 1.28339268823471
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13891.955   -13891.955   -14031.844   -14031.844    270.62547    270.62547    47773.919    47773.919    817.68304    817.68304 
   18000   -13895.373   -13895.373   -14035.339   -14035.339    270.77443    270.77443    47811.493    47811.493   -386.38672   -386.38672 
Loop time of 203.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.605 hours/ns, 4.907 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.83     | 202.83     | 202.83     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15335    | 0.15335    | 0.15335    |   0.0 |  0.08
Output  | 0.00017918 | 0.00017918 | 0.00017918 |   0.0 |  0.00
Modify  | 0.70006    | 0.70006    | 0.70006    |   0.0 |  0.34
Other   |            | 0.09793    |            |       |  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:      311676.0 ave      311676 max      311676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311676
Ave neighs/atom = 77.919000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.613910267491, Press = -0.14034182111389
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13895.373   -13895.373   -14035.339   -14035.339    270.77443    270.77443    47811.493    47811.493   -386.38672   -386.38672 
   19000   -13890.748   -13890.748   -14033.421   -14033.421    276.01043    276.01043    47834.151    47834.151   -694.84994   -694.84994 
Loop time of 205.188 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.997 hours/ns, 4.874 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    | 204.23     | 204.23     | 204.23     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15468    | 0.15468    | 0.15468    |   0.0 |  0.08
Output  | 0.00017864 | 0.00017864 | 0.00017864 |   0.0 |  0.00
Modify  | 0.70494    | 0.70494    | 0.70494    |   0.0 |  0.34
Other   |            | 0.09873    |            |       |  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:      311634.0 ave      311634 max      311634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311634
Ave neighs/atom = 77.908500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.550805246895, Press = 2.77674276168694
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13890.748   -13890.748   -14033.421   -14033.421    276.01043    276.01043    47834.151    47834.151   -694.84994   -694.84994 
   20000    -13888.38    -13888.38    -14032.52    -14032.52    278.84738    278.84738    47751.607    47751.607    1510.7109    1510.7109 
Loop time of 203.598 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.555 hours/ns, 4.912 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    | 202.65     | 202.65     | 202.65     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15337    | 0.15337    | 0.15337    |   0.0 |  0.08
Output  | 0.00022357 | 0.00022357 | 0.00022357 |   0.0 |  0.00
Modify  | 0.6993     | 0.6993     | 0.6993     |   0.0 |  0.34
Other   |            | 0.09802    |            |       |  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:      311702.0 ave      311702 max      311702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311702
Ave neighs/atom = 77.925500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.542371038732, Press = 2.22836838050798
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000    -13888.38    -13888.38    -14032.52    -14032.52    278.84738    278.84738    47751.607    47751.607    1510.7109    1510.7109 
   21000   -13893.918   -13893.918   -14034.736   -14034.736    272.42139    272.42139    47832.052    47832.052    -965.0383    -965.0383 
Loop time of 202.768 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.324 hours/ns, 4.932 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    | 201.83     | 201.83     | 201.83     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15123    | 0.15123    | 0.15123    |   0.0 |  0.07
Output  | 0.00018308 | 0.00018308 | 0.00018308 |   0.0 |  0.00
Modify  | 0.68984    | 0.68984    | 0.68984    |   0.0 |  0.34
Other   |            | 0.09778    |            |       |  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:      311696.0 ave      311696 max      311696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311696
Ave neighs/atom = 77.924000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.606512087883, Press = -1.85139751201974
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13893.918   -13893.918   -14034.736   -14034.736    272.42139    272.42139    47832.052    47832.052    -965.0383    -965.0383 
   22000   -13895.557   -13895.557   -14034.112   -14034.112    268.04488    268.04488    47814.879    47814.879   -288.58352   -288.58352 
Loop time of 202.525 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.257 hours/ns, 4.938 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    | 201.59     | 201.59     | 201.59     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15227    | 0.15227    | 0.15227    |   0.0 |  0.08
Output  | 0.00018022 | 0.00018022 | 0.00018022 |   0.0 |  0.00
Modify  | 0.68971    | 0.68971    | 0.68971    |   0.0 |  0.34
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:      311668.0 ave      311668 max      311668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311668
Ave neighs/atom = 77.917000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.660092264368, Press = 3.6201201866795
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13895.557   -13895.557   -14034.112   -14034.112    268.04488    268.04488    47814.879    47814.879   -288.58352   -288.58352 
   23000   -13893.472   -13893.472   -14033.448   -14033.448    270.79273    270.79273    47753.857    47753.857    1307.2179    1307.2179 
Loop time of 203.473 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.520 hours/ns, 4.915 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    | 202.52     | 202.52     | 202.52     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15455    | 0.15455    | 0.15455    |   0.0 |  0.08
Output  | 0.00023112 | 0.00023112 | 0.00023112 |   0.0 |  0.00
Modify  | 0.69792    | 0.69792    | 0.69792    |   0.0 |  0.34
Other   |            | 0.09773    |            |       |  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:      311686.0 ave      311686 max      311686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311686
Ave neighs/atom = 77.921500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.663672031946, Press = -0.803846290389604
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13893.472   -13893.472   -14033.448   -14033.448    270.79273    270.79273    47753.857    47753.857    1307.2179    1307.2179 
   24000   -13887.538   -13887.538   -14030.823   -14030.823    277.19458    277.19458    47838.603    47838.603   -1072.4103   -1072.4103 
Loop time of 204.915 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.921 hours/ns, 4.880 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    | 203.95     | 203.95     | 203.95     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15467    | 0.15467    | 0.15467    |   0.0 |  0.08
Output  | 0.00023229 | 0.00023229 | 0.00023229 |   0.0 |  0.00
Modify  | 0.70774    | 0.70774    | 0.70774    |   0.0 |  0.35
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:      311656.0 ave      311656 max      311656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311656
Ave neighs/atom = 77.914000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.674638678885, Press = 0.34827652155794
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13887.538   -13887.538   -14030.823   -14030.823    277.19458    277.19458    47838.603    47838.603   -1072.4103   -1072.4103 
   25000   -13894.882   -13894.882   -14035.158   -14035.158    271.37232    271.37232    47772.908    47772.908    667.45277    667.45277 
Loop time of 203.764 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.601 hours/ns, 4.908 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    | 202.81     | 202.81     | 202.81     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15357    | 0.15357    | 0.15357    |   0.0 |  0.08
Output  | 0.00022945 | 0.00022945 | 0.00022945 |   0.0 |  0.00
Modify  | 0.70241    | 0.70241    | 0.70241    |   0.0 |  0.34
Other   |            | 0.09816    |            |       |  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:      311634.0 ave      311634 max      311634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311634
Ave neighs/atom = 77.908500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.726600970215, Press = 2.43215025696423
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13894.882   -13894.882   -14035.158   -14035.158    271.37232    271.37232    47772.908    47772.908    667.45277    667.45277 
   26000   -13896.618   -13896.618   -14035.225   -14035.225    268.14395    268.14395    47764.222    47764.222    742.53686    742.53686 
Loop time of 203.923 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.645 hours/ns, 4.904 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    | 202.97     | 202.97     | 202.97     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15357    | 0.15357    | 0.15357    |   0.0 |  0.08
Output  | 0.00017359 | 0.00017359 | 0.00017359 |   0.0 |  0.00
Modify  | 0.69955    | 0.69955    | 0.69955    |   0.0 |  0.34
Other   |            | 0.09668    |            |       |  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:      311660.0 ave      311660 max      311660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311660
Ave neighs/atom = 77.915000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.701162579926, Press = -1.05570450582617
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13896.618   -13896.618   -14035.225   -14035.225    268.14395    268.14395    47764.222    47764.222    742.53686    742.53686 
   27000   -13892.841   -13892.841   -14034.652   -14034.652    274.34186    274.34186    47895.469    47895.469   -2647.8577   -2647.8577 
Loop time of 202.396 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.221 hours/ns, 4.941 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    | 201.45     | 201.45     | 201.45     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15218    | 0.15218    | 0.15218    |   0.0 |  0.08
Output  | 0.00017641 | 0.00017641 | 0.00017641 |   0.0 |  0.00
Modify  | 0.69283    | 0.69283    | 0.69283    |   0.0 |  0.34
Other   |            | 0.09776    |            |       |  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:      311670.0 ave      311670 max      311670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311670
Ave neighs/atom = 77.917500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.687046494814, Press = 0.742790151766979
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13892.841   -13892.841   -14034.652   -14034.652    274.34186    274.34186    47895.469    47895.469   -2647.8577   -2647.8577 
   28000   -13889.133   -13889.133    -14031.48    -14031.48    275.37818    275.37818    47792.191    47792.191    411.85795    411.85795 
Loop time of 202.265 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.185 hours/ns, 4.944 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    | 201.32     | 201.32     | 201.32     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15331    | 0.15331    | 0.15331    |   0.0 |  0.08
Output  | 0.00017413 | 0.00017413 | 0.00017413 |   0.0 |  0.00
Modify  | 0.68977    | 0.68977    | 0.68977    |   0.0 |  0.34
Other   |            | 0.0972     |            |       |  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:      311568.0 ave      311568 max      311568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311568
Ave neighs/atom = 77.892000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.721046293765, Press = 2.80206265046685
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13889.133   -13889.133    -14031.48    -14031.48    275.37818    275.37818    47792.191    47792.191    411.85795    411.85795 
   29000   -13890.648   -13890.648    -14031.06    -14031.06    271.63646    271.63646    47781.911    47781.911    677.37525    677.37525 
Loop time of 201.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.047 hours/ns, 4.956 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    | 200.83     | 200.83     | 200.83     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1521     | 0.1521     | 0.1521     |   0.0 |  0.08
Output  | 0.00017786 | 0.00017786 | 0.00017786 |   0.0 |  0.00
Modify  | 0.68806    | 0.68806    | 0.68806    |   0.0 |  0.34
Other   |            | 0.09727    |            |       |  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:      311606.0 ave      311606 max      311606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311606
Ave neighs/atom = 77.901500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.719122898776, Press = 0.0859209997237532
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13890.648   -13890.648    -14031.06    -14031.06    271.63646    271.63646    47781.911    47781.911    677.37525    677.37525 
   30000   -13891.916   -13891.916   -14032.958   -14032.958    272.85555    272.85555      47837.7      47837.7   -1028.3458   -1028.3458 
Loop time of 202.579 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.272 hours/ns, 4.936 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    | 201.63     | 201.63     | 201.63     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15202    | 0.15202    | 0.15202    |   0.0 |  0.08
Output  | 0.0012951  | 0.0012951  | 0.0012951  |   0.0 |  0.00
Modify  | 0.69391    | 0.69391    | 0.69391    |   0.0 |  0.34
Other   |            | 0.09802    |            |       |  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:      311668.0 ave      311668 max      311668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311668
Ave neighs/atom = 77.917000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.718992853151, Press = 0.259269174748081
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13891.916   -13891.916   -14032.958   -14032.958    272.85555    272.85555      47837.7      47837.7   -1028.3458   -1028.3458 
   31000    -13895.65    -13895.65   -14034.108   -14034.108    267.85708    267.85708    47816.345    47816.345    -370.6026    -370.6026 
Loop time of 202.226 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.174 hours/ns, 4.945 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    | 201.29     | 201.29     | 201.29     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15265    | 0.15265    | 0.15265    |   0.0 |  0.08
Output  | 0.0001763  | 0.0001763  | 0.0001763  |   0.0 |  0.00
Modify  | 0.69047    | 0.69047    | 0.69047    |   0.0 |  0.34
Other   |            | 0.0979     |            |       |  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:      311690.0 ave      311690 max      311690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311690
Ave neighs/atom = 77.922500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.743651170341, Press = 1.90209661353558
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000    -13895.65    -13895.65   -14034.108   -14034.108    267.85708    267.85708    47816.345    47816.345    -370.6026    -370.6026 
   32000   -13890.768   -13890.768   -14032.322   -14032.322    273.84574    273.84574    47731.255    47731.255    2001.2936    2001.2936 
Loop time of 203.515 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.532 hours/ns, 4.914 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    | 202.56     | 202.56     | 202.56     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15237    | 0.15237    | 0.15237    |   0.0 |  0.07
Output  | 0.00017825 | 0.00017825 | 0.00017825 |   0.0 |  0.00
Modify  | 0.70016    | 0.70016    | 0.70016    |   0.0 |  0.34
Other   |            | 0.09849    |            |       |  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:      311682.0 ave      311682 max      311682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311682
Ave neighs/atom = 77.920500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.7314420806, Press = 0.491000556457376
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13890.768   -13890.768   -14032.322   -14032.322    273.84574    273.84574    47731.255    47731.255    2001.2936    2001.2936 
   33000   -13892.016   -13892.016   -14032.358   -14032.358    271.50169    271.50169    47841.365    47841.365   -1163.8291   -1163.8291 
Loop time of 203.537 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.538 hours/ns, 4.913 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    | 202.58     | 202.58     | 202.58     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15346    | 0.15346    | 0.15346    |   0.0 |  0.08
Output  | 0.00017637 | 0.00017637 | 0.00017637 |   0.0 |  0.00
Modify  | 0.70218    | 0.70218    | 0.70218    |   0.0 |  0.34
Other   |            | 0.09897    |            |       |  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:      311584.0 ave      311584 max      311584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311584
Ave neighs/atom = 77.896000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.690631412082, Press = -1.19958098212508
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13892.016   -13892.016   -14032.358   -14032.358    271.50169    271.50169    47841.365    47841.365   -1163.8291   -1163.8291 
   34000    -13893.27    -13893.27   -14035.005   -14035.005    274.19564    274.19564    47816.005    47816.005   -537.48435   -537.48435 
Loop time of 204.511 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.809 hours/ns, 4.890 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    | 203.56     | 203.56     | 203.56     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15346    | 0.15346    | 0.15346    |   0.0 |  0.08
Output  | 0.0001894  | 0.0001894  | 0.0001894  |   0.0 |  0.00
Modify  | 0.69846    | 0.69846    | 0.69846    |   0.0 |  0.34
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:      311560.0 ave      311560 max      311560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311560
Ave neighs/atom = 77.890000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.688536636474, Press = 1.80068064227758
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -13893.27    -13893.27   -14035.005   -14035.005    274.19564    274.19564    47816.005    47816.005   -537.48435   -537.48435 
   35000   -13890.046   -13890.046   -14032.484   -14032.484    275.55655    275.55655    47763.393    47763.393    1180.5334    1180.5334 
Loop time of 202.43 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.231 hours/ns, 4.940 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    | 201.48     | 201.48     | 201.48     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15298    | 0.15298    | 0.15298    |   0.0 |  0.08
Output  | 0.00021721 | 0.00021721 | 0.00021721 |   0.0 |  0.00
Modify  | 0.69494    | 0.69494    | 0.69494    |   0.0 |  0.34
Other   |            | 0.09817    |            |       |  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:      311634.0 ave      311634 max      311634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311634
Ave neighs/atom = 77.908500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.664191581229, Press = -0.0719215850662041
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13890.046   -13890.046   -14032.484   -14032.484    275.55655    275.55655    47763.393    47763.393    1180.5334    1180.5334 
   36000   -13895.362   -13895.362   -14034.587   -14034.587    269.34037    269.34037    47834.728    47834.728   -955.96175   -955.96175 
Loop time of 202.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.151 hours/ns, 4.947 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    | 201.2      | 201.2      | 201.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15118    | 0.15118    | 0.15118    |   0.0 |  0.07
Output  | 0.00022939 | 0.00022939 | 0.00022939 |   0.0 |  0.00
Modify  | 0.69135    | 0.69135    | 0.69135    |   0.0 |  0.34
Other   |            | 0.09816    |            |       |  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:      311622.0 ave      311622 max      311622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311622
Ave neighs/atom = 77.905500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.566030858536, Press = -0.172785750867752
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13895.362   -13895.362   -14034.587   -14034.587    269.34037    269.34037    47834.728    47834.728   -955.96175   -955.96175 
   37000   -13891.018   -13891.018   -14032.647   -14032.647    273.99067    273.99067    47808.679    47808.679   -253.55273   -253.55273 
Loop time of 204.418 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.783 hours/ns, 4.892 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    | 203.46     | 203.46     | 203.46     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15462    | 0.15462    | 0.15462    |   0.0 |  0.08
Output  | 0.00017301 | 0.00017301 | 0.00017301 |   0.0 |  0.00
Modify  | 0.70117    | 0.70117    | 0.70117    |   0.0 |  0.34
Other   |            | 0.09894    |            |       |  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:      311622.0 ave      311622 max      311622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311622
Ave neighs/atom = 77.905500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.519591427755, Press = 1.43429416432629
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13891.018   -13891.018   -14032.647   -14032.647    273.99067    273.99067    47808.679    47808.679   -253.55273   -253.55273 
   38000   -13896.551   -13896.551   -14034.979   -14034.979    267.79842    267.79842    47782.541    47782.541    187.00423    187.00423 
Loop time of 203.457 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.516 hours/ns, 4.915 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    | 202.51     | 202.51     | 202.51     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15308    | 0.15308    | 0.15308    |   0.0 |  0.08
Output  | 0.00023565 | 0.00023565 | 0.00023565 |   0.0 |  0.00
Modify  | 0.69486    | 0.69486    | 0.69486    |   0.0 |  0.34
Other   |            | 0.09886    |            |       |  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:      311646.0 ave      311646 max      311646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311646
Ave neighs/atom = 77.911500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.479442259109, Press = 0.518708253868879
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13896.551   -13896.551   -14034.979   -14034.979    267.79842    267.79842    47782.541    47782.541    187.00423    187.00423 
   39000   -13893.775   -13893.775   -14032.354   -14032.354    268.09092    268.09092    47807.376    47807.376   -209.20034   -209.20034 
Loop time of 204.016 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.671 hours/ns, 4.902 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    | 203.07     | 203.07     | 203.07     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15327    | 0.15327    | 0.15327    |   0.0 |  0.08
Output  | 0.00017643 | 0.00017643 | 0.00017643 |   0.0 |  0.00
Modify  | 0.69428    | 0.69428    | 0.69428    |   0.0 |  0.34
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:      311688.0 ave      311688 max      311688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311688
Ave neighs/atom = 77.922000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.496085699077, Press = 0.664445543468201
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13893.775   -13893.775   -14032.354   -14032.354    268.09092    268.09092    47807.376    47807.376   -209.20034   -209.20034 
   40000   -13888.014   -13888.014   -14031.978   -14031.978    278.50759    278.50759    47780.111    47780.111    673.07996    673.07996 
Loop time of 205.028 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.952 hours/ns, 4.877 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    | 204.07     | 204.07     | 204.07     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15394    | 0.15394    | 0.15394    |   0.0 |  0.08
Output  | 0.00017862 | 0.00017862 | 0.00017862 |   0.0 |  0.00
Modify  | 0.70719    | 0.70719    | 0.70719    |   0.0 |  0.34
Other   |            | 0.09873    |            |       |  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:      311648.0 ave      311648 max      311648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311648
Ave neighs/atom = 77.912000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.524441562174, Press = 0.158621357265066
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13888.014   -13888.014   -14031.978   -14031.978    278.50759    278.50759    47780.111    47780.111    673.07996    673.07996 
   41000    -13890.42    -13890.42   -14034.969   -14034.969    279.63933    279.63933    47867.706    47867.706   -1674.2275   -1674.2275 
Loop time of 202.306 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.196 hours/ns, 4.943 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    | 201.36     | 201.36     | 201.36     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15347    | 0.15347    | 0.15347    |   0.0 |  0.08
Output  | 0.00017637 | 0.00017637 | 0.00017637 |   0.0 |  0.00
Modify  | 0.69003    | 0.69003    | 0.69003    |   0.0 |  0.34
Other   |            | 0.09822    |            |       |  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:      311646.0 ave      311646 max      311646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311646
Ave neighs/atom = 77.911500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.527282166936, Press = -0.299862402423623
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000    -13890.42    -13890.42   -14034.969   -14034.969    279.63933    279.63933    47867.706    47867.706   -1674.2275   -1674.2275 
   42000   -13894.157   -13894.157   -14033.599   -14033.599    269.76051    269.76051    47790.252    47790.252    258.29498    258.29498 
Loop time of 202.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.386 hours/ns, 4.926 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    | 202.05     | 202.05     | 202.05     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15248    | 0.15248    | 0.15248    |   0.0 |  0.08
Output  | 0.0001799  | 0.0001799  | 0.0001799  |   0.0 |  0.00
Modify  | 0.69364    | 0.69364    | 0.69364    |   0.0 |  0.34
Other   |            | 0.09788    |            |       |  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:      311592.0 ave      311592 max      311592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311592
Ave neighs/atom = 77.898000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.551910787827, Press = 1.76271558215561
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13894.157   -13894.157   -14033.599   -14033.599    269.76051    269.76051    47790.252    47790.252    258.29498    258.29498 
   43000   -13893.357   -13893.357   -14033.549   -14033.549    271.21076    271.21076     47756.97     47756.97    1242.1776    1242.1776 
Loop time of 203.171 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.436 hours/ns, 4.922 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    | 202.22     | 202.22     | 202.22     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15208    | 0.15208    | 0.15208    |   0.0 |  0.07
Output  | 0.00017333 | 0.00017333 | 0.00017333 |   0.0 |  0.00
Modify  | 0.69917    | 0.69917    | 0.69917    |   0.0 |  0.34
Other   |            | 0.09865    |            |       |  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:      311634.0 ave      311634 max      311634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311634
Ave neighs/atom = 77.908500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.537742495008, Press = -0.139448767129691
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13893.357   -13893.357   -14033.549   -14033.549    271.21076    271.21076     47756.97     47756.97    1242.1776    1242.1776 
   44000   -13890.872   -13890.872   -14034.309   -14034.309    277.48869    277.48869    47847.292    47847.292   -1228.5868   -1228.5868 
Loop time of 203.088 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.413 hours/ns, 4.924 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    | 202.14     | 202.14     | 202.14     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15248    | 0.15248    | 0.15248    |   0.0 |  0.08
Output  | 0.00017614 | 0.00017614 | 0.00017614 |   0.0 |  0.00
Modify  | 0.6993     | 0.6993     | 0.6993     |   0.0 |  0.34
Other   |            | 0.09924    |            |       |  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:      311700.0 ave      311700 max      311700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311700
Ave neighs/atom = 77.925000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.533806147703, Press = -0.121976073059263
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13890.872   -13890.872   -14034.309   -14034.309    277.48869    277.48869    47847.292    47847.292   -1228.5868   -1228.5868 
   45000   -13891.191   -13891.191    -14033.72    -14033.72    275.73169    275.73169    47801.061    47801.061   -93.700728   -93.700728 
Loop time of 200.967 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.824 hours/ns, 4.976 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    | 200.03     | 200.03     | 200.03     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14982    | 0.14982    | 0.14982    |   0.0 |  0.07
Output  | 0.00017998 | 0.00017998 | 0.00017998 |   0.0 |  0.00
Modify  | 0.68719    | 0.68719    | 0.68719    |   0.0 |  0.34
Other   |            | 0.09878    |            |       |  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:      311620.0 ave      311620 max      311620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311620
Ave neighs/atom = 77.905000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.522543934049, Press = 0.762297915360042
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13891.191   -13891.191    -14033.72    -14033.72    275.73169    275.73169    47801.061    47801.061   -93.700728   -93.700728 
   46000   -13893.496   -13893.496   -14035.232   -14035.232    274.19775    274.19775    47796.488    47796.488    45.324866    45.324866 
Loop time of 202.133 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.148 hours/ns, 4.947 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    | 201.19     | 201.19     | 201.19     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1514     | 0.1514     | 0.1514     |   0.0 |  0.07
Output  | 0.00018148 | 0.00018148 | 0.00018148 |   0.0 |  0.00
Modify  | 0.69003    | 0.69003    | 0.69003    |   0.0 |  0.34
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:      311610.0 ave      311610 max      311610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311610
Ave neighs/atom = 77.902500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.475263758563, Press = 0.112297050678051
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13893.496   -13893.496   -14035.232   -14035.232    274.19775    274.19775    47796.488    47796.488    45.324866    45.324866 
   47000   -13895.893   -13895.893    -14033.59    -14033.59     266.3848     266.3848    47806.232    47806.232   -269.28777   -269.28777 
Loop time of 203.28 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.467 hours/ns, 4.919 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    | 202.33     | 202.33     | 202.33     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15251    | 0.15251    | 0.15251    |   0.0 |  0.08
Output  | 0.00017853 | 0.00017853 | 0.00017853 |   0.0 |  0.00
Modify  | 0.69492    | 0.69492    | 0.69492    |   0.0 |  0.34
Other   |            | 0.0998     |            |       |  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:      311652.0 ave      311652 max      311652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311652
Ave neighs/atom = 77.913000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.451438121131, Press = 0.258224297075925
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13895.893   -13895.893    -14033.59    -14033.59     266.3848     266.3848    47806.232    47806.232   -269.28777   -269.28777 
   48000    -13893.48    -13893.48   -14034.739   -14034.739    273.27452    273.27452    47802.074    47802.074   -142.53194   -142.53194 
Loop time of 202.982 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.384 hours/ns, 4.927 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    | 202.03     | 202.03     | 202.03     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15286    | 0.15286    | 0.15286    |   0.0 |  0.08
Output  | 0.00017861 | 0.00017861 | 0.00017861 |   0.0 |  0.00
Modify  | 0.69853    | 0.69853    | 0.69853    |   0.0 |  0.34
Other   |            | 0.09892    |            |       |  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:      311650.0 ave      311650 max      311650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311650
Ave neighs/atom = 77.912500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.432941912273, Press = 0.619610024370999
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000    -13893.48    -13893.48   -14034.739   -14034.739    273.27452    273.27452    47802.074    47802.074   -142.53194   -142.53194 
   49000   -13888.248   -13888.248    -14032.31    -14032.31    278.69786    278.69786    47749.775    47749.775    1469.3438    1469.3438 
Loop time of 200.785 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.774 hours/ns, 4.980 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    | 199.85     | 199.85     | 199.85     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15155    | 0.15155    | 0.15155    |   0.0 |  0.08
Output  | 0.00018023 | 0.00018023 | 0.00018023 |   0.0 |  0.00
Modify  | 0.6848     | 0.6848     | 0.6848     |   0.0 |  0.34
Other   |            | 0.09919    |            |       |  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:      311638.0 ave      311638 max      311638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311638
Ave neighs/atom = 77.909500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.457384435808, Press = 0.126384675125507
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13888.248   -13888.248    -14032.31    -14032.31    278.69786    278.69786    47749.775    47749.775    1469.3438    1469.3438 
   50000   -13890.871   -13890.871   -14033.044   -14033.044    275.04376    275.04376    47831.054    47831.054   -944.73582   -944.73582 
Loop time of 202.219 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.172 hours/ns, 4.945 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    | 201.27     | 201.27     | 201.27     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15289    | 0.15289    | 0.15289    |   0.0 |  0.08
Output  | 0.00017976 | 0.00017976 | 0.00017976 |   0.0 |  0.00
Modify  | 0.69373    | 0.69373    | 0.69373    |   0.0 |  0.34
Other   |            | 0.09955    |            |       |  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:      311644.0 ave      311644 max      311644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311644
Ave neighs/atom = 77.911000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.46160507728, Press = -0.126423304822189
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -13890.871   -13890.871   -14033.044   -14033.044    275.04376    275.04376    47831.054    47831.054   -944.73582   -944.73582 
   51000    -13891.11    -13891.11   -14034.141   -14034.141    276.70217    276.70217    47814.215    47814.215   -82.500489   -82.500489 
Loop time of 202.8 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.333 hours/ns, 4.931 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    | 201.85     | 201.85     | 201.85     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15134    | 0.15134    | 0.15134    |   0.0 |  0.07
Output  | 0.00017422 | 0.00017422 | 0.00017422 |   0.0 |  0.00
Modify  | 0.69623    | 0.69623    | 0.69623    |   0.0 |  0.34
Other   |            | 0.09978    |            |       |  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:      311662.0 ave      311662 max      311662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311662
Ave neighs/atom = 77.915500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.429754064006, Press = 0.850371581503777
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000    -13891.11    -13891.11   -14034.141   -14034.141    276.70217    276.70217    47814.215    47814.215   -82.500489   -82.500489 
   52000   -13894.185   -13894.185   -14034.276   -14034.276    271.01603    271.01603    47739.003    47739.003    1818.0626    1818.0626 
Loop time of 203.336 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.482 hours/ns, 4.918 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    | 202.39     | 202.39     | 202.39     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15111    | 0.15111    | 0.15111    |   0.0 |  0.07
Output  | 0.00017844 | 0.00017844 | 0.00017844 |   0.0 |  0.00
Modify  | 0.69238    | 0.69238    | 0.69238    |   0.0 |  0.34
Other   |            | 0.09882    |            |       |  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:      311630.0 ave      311630 max      311630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311630
Ave neighs/atom = 77.907500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.42624614164, Press = 0.658060428373241
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -13894.185   -13894.185   -14034.276   -14034.276    271.01603    271.01603    47739.003    47739.003    1818.0626    1818.0626 
   53000   -13897.162   -13897.162   -14036.278   -14036.278    269.12801    269.12801    47774.182    47774.182    648.40879    648.40879 
Loop time of 201.212 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.892 hours/ns, 4.970 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    | 200.28     | 200.28     | 200.28     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15126    | 0.15126    | 0.15126    |   0.0 |  0.08
Output  | 0.0002479  | 0.0002479  | 0.0002479  |   0.0 |  0.00
Modify  | 0.68265    | 0.68265    | 0.68265    |   0.0 |  0.34
Other   |            | 0.09865    |            |       |  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:      311654.0 ave      311654 max      311654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311654
Ave neighs/atom = 77.913500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.399178511977, Press = -0.815892966040889
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -13897.162   -13897.162   -14036.278   -14036.278    269.12801    269.12801    47774.182    47774.182    648.40879    648.40879 
   54000   -13891.963   -13891.963   -14034.067   -14034.067    274.90837    274.90837    47858.328    47858.328   -1682.6244   -1682.6244 
Loop time of 201.856 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.071 hours/ns, 4.954 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    | 200.91     | 200.91     | 200.91     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15318    | 0.15318    | 0.15318    |   0.0 |  0.08
Output  | 0.00017566 | 0.00017566 | 0.00017566 |   0.0 |  0.00
Modify  | 0.69326    | 0.69326    | 0.69326    |   0.0 |  0.34
Other   |            | 0.09795    |            |       |  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:      311700.0 ave      311700 max      311700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311700
Ave neighs/atom = 77.925000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.38198817064, Press = -0.286228469337991
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -13891.963   -13891.963   -14034.067   -14034.067    274.90837    274.90837    47858.328    47858.328   -1682.6244   -1682.6244 
   55000   -13891.075   -13891.075   -14033.236   -14033.236    275.02024    275.02024    47808.703    47808.703     -156.901     -156.901 
Loop time of 200.943 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.818 hours/ns, 4.977 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    | 200        | 200        | 200        |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15106    | 0.15106    | 0.15106    |   0.0 |  0.08
Output  | 0.0001782  | 0.0001782  | 0.0001782  |   0.0 |  0.00
Modify  | 0.68843    | 0.68843    | 0.68843    |   0.0 |  0.34
Other   |            | 0.09909    |            |       |  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:      311612.0 ave      311612 max      311612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311612
Ave neighs/atom = 77.903000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.347471601781, Press = 0.842476125032698
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -13891.075   -13891.075   -14033.236   -14033.236    275.02024    275.02024    47808.703    47808.703     -156.901     -156.901 
   56000    -13889.21    -13889.21   -14034.381   -14034.381    280.84277    280.84277     47784.66     47784.66     672.2215     672.2215 
Loop time of 200.849 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.791 hours/ns, 4.979 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    | 199.91     | 199.91     | 199.91     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15077    | 0.15077    | 0.15077    |   0.0 |  0.08
Output  | 0.00017863 | 0.00017863 | 0.00017863 |   0.0 |  0.00
Modify  | 0.68813    | 0.68813    | 0.68813    |   0.0 |  0.34
Other   |            | 0.09896    |            |       |  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:      311682.0 ave      311682 max      311682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311682
Ave neighs/atom = 77.920500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.320197789841, Press = 0.269527382490675
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000    -13889.21    -13889.21   -14034.381   -14034.381    280.84277    280.84277     47784.66     47784.66     672.2215     672.2215 
   57000   -13893.358   -13893.358   -14036.508   -14036.508    276.93392    276.93392    47781.285    47781.285    655.06575    655.06575 
Loop time of 200.498 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.694 hours/ns, 4.988 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    | 199.57     | 199.57     | 199.57     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15044    | 0.15044    | 0.15044    |   0.0 |  0.08
Output  | 0.00017703 | 0.00017703 | 0.00017703 |   0.0 |  0.00
Modify  | 0.68362    | 0.68362    | 0.68362    |   0.0 |  0.34
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:        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:      311690.0 ave      311690 max      311690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311690
Ave neighs/atom = 77.922500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.334014009615, Press = 0.284366487353567
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -13893.358   -13893.358   -14036.508   -14036.508    276.93392    276.93392    47781.285    47781.285    655.06575    655.06575 
   58000   -13890.881   -13890.881   -14033.167   -14033.167    275.26159    275.26159    47818.786    47818.786    -439.1137    -439.1137 
Loop time of 201.502 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.973 hours/ns, 4.963 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    | 200.56     | 200.56     | 200.56     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1524     | 0.1524     | 0.1524     |   0.0 |  0.08
Output  | 0.00017277 | 0.00017277 | 0.00017277 |   0.0 |  0.00
Modify  | 0.6892     | 0.6892     | 0.6892     |   0.0 |  0.34
Other   |            | 0.09903    |            |       |  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:      311650.0 ave      311650 max      311650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311650
Ave neighs/atom = 77.912500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.379426893794, Press = -0.111585827391535
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -13890.881   -13890.881   -14033.167   -14033.167    275.26159    275.26159    47818.786    47818.786    -439.1137    -439.1137 
   59000   -13893.428   -13893.428   -14032.559   -14032.559    269.15877    269.15877      47818.9      47818.9   -602.64897   -602.64897 
Loop time of 201.232 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.898 hours/ns, 4.969 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    | 200.3      | 200.3      | 200.3      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1506     | 0.1506     | 0.1506     |   0.0 |  0.07
Output  | 0.00017753 | 0.00017753 | 0.00017753 |   0.0 |  0.00
Modify  | 0.68502    | 0.68502    | 0.68502    |   0.0 |  0.34
Other   |            | 0.09841    |            |       |  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:      311602.0 ave      311602 max      311602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311602
Ave neighs/atom = 77.900500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.372262593388, Press = 1.06923423377921
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -13893.428   -13893.428   -14032.559   -14032.559    269.15877    269.15877      47818.9      47818.9   -602.64897   -602.64897 
   60000   -13895.399   -13895.399   -14036.552   -14036.552    273.06996    273.06996    47715.944    47715.944    2396.8264    2396.8264 
Loop time of 202.697 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.305 hours/ns, 4.933 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    | 201.75     | 201.75     | 201.75     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15228    | 0.15228    | 0.15228    |   0.0 |  0.08
Output  | 0.00017741 | 0.00017741 | 0.00017741 |   0.0 |  0.00
Modify  | 0.69329    | 0.69329    | 0.69329    |   0.0 |  0.34
Other   |            | 0.09858    |            |       |  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:      311604.0 ave      311604 max      311604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311604
Ave neighs/atom = 77.901000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.373096743336, Press = 0.194236971725091
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -13895.399   -13895.399   -14036.552   -14036.552    273.06996    273.06996    47715.944    47715.944    2396.8264    2396.8264 
   61000   -13891.602   -13891.602   -14032.489   -14032.489    272.55624    272.55624    47822.234    47822.234   -514.17818   -514.17818 
Loop time of 202.133 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.148 hours/ns, 4.947 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    | 201.19     | 201.19     | 201.19     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15183    | 0.15183    | 0.15183    |   0.0 |  0.08
Output  | 0.00017707 | 0.00017707 | 0.00017707 |   0.0 |  0.00
Modify  | 0.69388    | 0.69388    | 0.69388    |   0.0 |  0.34
Other   |            | 0.09902    |            |       |  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:      311744.0 ave      311744 max      311744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0