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

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

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

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23173.504770342 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_492310898779_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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8493.9163   -8493.9163   -8579.9993   -8579.9993       333.15       333.15    23173.505    23173.505    3967.7675    3967.7675 
    1000   -8403.7286   -8403.7286   -8489.8359   -8489.8359    333.24453    333.24453    23447.443    23447.443   -2746.5663   -2746.5663 
Loop time of 175.155 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.654 hours/ns, 5.709 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    | 174.55     | 174.55     | 174.55     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11087    | 0.11087    | 0.11087    |   0.0 |  0.06
Output  | 0.00019891 | 0.00019891 | 0.00019891 |   0.0 |  0.00
Modify  | 0.42945    | 0.42945    | 0.42945    |   0.0 |  0.25
Other   |            | 0.06625    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8403.7286   -8403.7286   -8489.8359   -8489.8359    333.24453    333.24453    23447.443    23447.443   -2746.5663   -2746.5663 
    2000    -8403.715    -8403.715   -8487.6913   -8487.6913    324.99667    324.99667    23387.091    23387.091    1591.3564    1591.3564 
Loop time of 153.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.729 hours/ns, 6.501 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    | 153.33     | 153.33     | 153.33     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097123   | 0.097123   | 0.097123   |   0.0 |  0.06
Output  | 0.0001891  | 0.0001891  | 0.0001891  |   0.0 |  0.00
Modify  | 0.33797    | 0.33797    | 0.33797    |   0.0 |  0.22
Other   |            | 0.05795    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128444.0 ave      128444 max      128444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128444
Ave neighs/atom = 64.222000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -8403.715    -8403.715   -8487.6913   -8487.6913    324.99667    324.99667    23387.091    23387.091    1591.3564    1591.3564 
    3000   -8404.8274   -8404.8274   -8491.7737   -8491.7737     336.4914     336.4914    23411.793    23411.793   -405.02792   -405.02792 
Loop time of 166.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.520 ns/day, 46.159 hours/ns, 6.018 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 165.63     | 165.63     | 165.63     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1027     | 0.1027     | 0.1027     |   0.0 |  0.06
Output  | 0.00019259 | 0.00019259 | 0.00019259 |   0.0 |  0.00
Modify  | 0.37875    | 0.37875    | 0.37875    |   0.0 |  0.23
Other   |            | 0.06261    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4113.00 ave        4113 max        4113 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:      128480.0 ave      128480 max      128480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128480
Ave neighs/atom = 64.240000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8404.8274   -8404.8274   -8491.7737   -8491.7737     336.4914     336.4914    23411.793    23411.793   -405.02792   -405.02792 
    4000   -8403.0026   -8403.0026   -8489.3718   -8489.3718    334.25761    334.25761    23421.335    23421.335   -661.63279   -661.63279 
Loop time of 178.967 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.483 ns/day, 49.713 hours/ns, 5.588 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    | 178.37     | 178.37     | 178.37     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10961    | 0.10961    | 0.10961    |   0.0 |  0.06
Output  | 0.00023412 | 0.00023412 | 0.00023412 |   0.0 |  0.00
Modify  | 0.42176    | 0.42176    | 0.42176    |   0.0 |  0.24
Other   |            | 0.0655     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4115.00 ave        4115 max        4115 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:      128340.0 ave      128340 max      128340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128340
Ave neighs/atom = 64.170000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8403.0026   -8403.0026   -8489.3718   -8489.3718    334.25761    334.25761    23421.335    23421.335   -661.63279   -661.63279 
    5000   -8405.7533   -8405.7533   -8490.7394   -8490.7394    328.90509    328.90509     23388.57     23388.57    1313.6973    1313.6973 
Loop time of 178.99 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.483 ns/day, 49.720 hours/ns, 5.587 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.4      | 178.4      | 178.4      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10869    | 0.10869    | 0.10869    |   0.0 |  0.06
Output  | 0.00023674 | 0.00023674 | 0.00023674 |   0.0 |  0.00
Modify  | 0.41656    | 0.41656    | 0.41656    |   0.0 |  0.23
Other   |            | 0.06476    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128412.0 ave      128412 max      128412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128412
Ave neighs/atom = 64.206000
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 = 331.028943441429, Press = -621.658143320643
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8405.7533   -8405.7533   -8490.7394   -8490.7394    328.90509    328.90509     23388.57     23388.57    1313.6973    1313.6973 
    6000   -8403.8841   -8403.8841   -8490.3271   -8490.3271    334.54364    334.54364    23428.241    23428.241   -1415.2546   -1415.2546 
Loop time of 170.167 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.508 ns/day, 47.269 hours/ns, 5.877 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    | 169.59     | 169.59     | 169.59     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10542    | 0.10542    | 0.10542    |   0.0 |  0.06
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.41007    | 0.41007    | 0.41007    |   0.0 |  0.24
Other   |            | 0.06271    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128430.0 ave      128430 max      128430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128430
Ave neighs/atom = 64.215000
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 = 332.11701546795, Press = -41.3605425392415
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8403.8841   -8403.8841   -8490.3271   -8490.3271    334.54364    334.54364    23428.241    23428.241   -1415.2546   -1415.2546 
    7000   -8401.4557   -8401.4557   -8489.3681   -8489.3681    340.23024    340.23024    23395.857    23395.857    1149.9076    1149.9076 
Loop time of 153.124 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.534 hours/ns, 6.531 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    | 152.62     | 152.62     | 152.62     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096504   | 0.096504   | 0.096504   |   0.0 |  0.06
Output  | 0.0001523  | 0.0001523  | 0.0001523  |   0.0 |  0.00
Modify  | 0.35404    | 0.35404    | 0.35404    |   0.0 |  0.23
Other   |            | 0.05794    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128440.0 ave      128440 max      128440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128440
Ave neighs/atom = 64.220000
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 = 333.79597779069, Press = -13.7745837157323
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8401.4557   -8401.4557   -8489.3681   -8489.3681    340.23024    340.23024    23395.857    23395.857    1149.9076    1149.9076 
    8000   -8404.0355   -8404.0355   -8489.7076   -8489.7076    331.55961    331.55961     23423.18     23423.18   -979.16093   -979.16093 
Loop time of 153.442 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.623 hours/ns, 6.517 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    | 152.94     | 152.94     | 152.94     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095999   | 0.095999   | 0.095999   |   0.0 |  0.06
Output  | 0.00015206 | 0.00015206 | 0.00015206 |   0.0 |  0.00
Modify  | 0.35379    | 0.35379    | 0.35379    |   0.0 |  0.23
Other   |            | 0.05715    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128392.0 ave      128392 max      128392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128392
Ave neighs/atom = 64.196000
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 = 333.428637674364, Press = -19.0000741225045
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8404.0355   -8404.0355   -8489.7076   -8489.7076    331.55961    331.55961     23423.18     23423.18   -979.16093   -979.16093 
    9000   -8407.1706   -8407.1706   -8492.8001   -8492.8001    331.39507    331.39507    23383.044    23383.044     1370.758     1370.758 
Loop time of 152.843 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.456 hours/ns, 6.543 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    | 152.34     | 152.34     | 152.34     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095825   | 0.095825   | 0.095825   |   0.0 |  0.06
Output  | 0.00015296 | 0.00015296 | 0.00015296 |   0.0 |  0.00
Modify  | 0.3525     | 0.3525     | 0.3525     |   0.0 |  0.23
Other   |            | 0.05758    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128400.0 ave      128400 max      128400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128400
Ave neighs/atom = 64.200000
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 = 333.804097489096, Press = -1.52018311920995
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8407.1706   -8407.1706   -8492.8001   -8492.8001    331.39507    331.39507    23383.044    23383.044     1370.758     1370.758 
   10000   -8402.4758   -8402.4758   -8488.7506   -8488.7506    333.89206    333.89206    23432.307    23432.307   -1386.2383   -1386.2383 
Loop time of 153.289 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.580 hours/ns, 6.524 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.78     | 152.78     | 152.78     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09621    | 0.09621    | 0.09621    |   0.0 |  0.06
Output  | 0.00015342 | 0.00015342 | 0.00015342 |   0.0 |  0.00
Modify  | 0.3528     | 0.3528     | 0.3528     |   0.0 |  0.23
Other   |            | 0.05764    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128444.0 ave      128444 max      128444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128444
Ave neighs/atom = 64.222000
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 = 333.072027187899, Press = -30.2200336375677
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8402.4758   -8402.4758   -8488.7506   -8488.7506    333.89206    333.89206    23432.307    23432.307   -1386.2383   -1386.2383 
   11000    -8401.755    -8401.755   -8487.9112   -8487.9112    333.43312    333.43312    23419.447    23419.447   -484.01445   -484.01445 
Loop time of 153.651 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.681 hours/ns, 6.508 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    | 153.14     | 153.14     | 153.14     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096236   | 0.096236   | 0.096236   |   0.0 |  0.06
Output  | 0.00015504 | 0.00015504 | 0.00015504 |   0.0 |  0.00
Modify  | 0.35366    | 0.35366    | 0.35366    |   0.0 |  0.23
Other   |            | 0.05705    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4118.00 ave        4118 max        4118 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:      128382.0 ave      128382 max      128382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128382
Ave neighs/atom = 64.191000
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 = 333.17557392118, Press = 9.08525115821914
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -8401.755    -8401.755   -8487.9112   -8487.9112    333.43312    333.43312    23419.447    23419.447   -484.01445   -484.01445 
   12000   -8405.9355   -8405.9355   -8490.3944   -8490.3944    326.86469    326.86469    23390.256    23390.256    1079.9318    1079.9318 
Loop time of 153.158 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.544 hours/ns, 6.529 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    | 152.65     | 152.65     | 152.65     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095465   | 0.095465   | 0.095465   |   0.0 |  0.06
Output  | 0.00015227 | 0.00015227 | 0.00015227 |   0.0 |  0.00
Modify  | 0.35321    | 0.35321    | 0.35321    |   0.0 |  0.23
Other   |            | 0.05741    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128450.0 ave      128450 max      128450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128450
Ave neighs/atom = 64.225000
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 = 333.216959739966, Press = -11.3496214301327
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8405.9355   -8405.9355   -8490.3944   -8490.3944    326.86469    326.86469    23390.256    23390.256    1079.9318    1079.9318 
   13000   -8402.0809   -8402.0809   -8490.0107   -8490.0107    340.29744    340.29744    23427.522    23427.522   -1189.5032   -1189.5032 
Loop time of 153.385 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.607 hours/ns, 6.520 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    | 152.88     | 152.88     | 152.88     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095887   | 0.095887   | 0.095887   |   0.0 |  0.06
Output  | 0.00015526 | 0.00015526 | 0.00015526 |   0.0 |  0.00
Modify  | 0.35366    | 0.35366    | 0.35366    |   0.0 |  0.23
Other   |            | 0.05719    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128432.0 ave      128432 max      128432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128432
Ave neighs/atom = 64.216000
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 = 333.578036253688, Press = -3.85789983757859
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8402.0809   -8402.0809   -8490.0107   -8490.0107    340.29744    340.29744    23427.522    23427.522   -1189.5032   -1189.5032 
   14000   -8404.1172   -8404.1172   -8490.4577   -8490.4577    334.14646    334.14646    23382.926    23382.926    1684.8466    1684.8466 
Loop time of 153.178 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.549 hours/ns, 6.528 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.67     | 152.67     | 152.67     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096179   | 0.096179   | 0.096179   |   0.0 |  0.06
Output  | 0.00015244 | 0.00015244 | 0.00015244 |   0.0 |  0.00
Modify  | 0.35337    | 0.35337    | 0.35337    |   0.0 |  0.23
Other   |            | 0.05758    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 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:      128380.0 ave      128380 max      128380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128380
Ave neighs/atom = 64.190000
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 = 333.655907635846, Press = -3.65342135459393
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8404.1172   -8404.1172   -8490.4577   -8490.4577    334.14646    334.14646    23382.926    23382.926    1684.8466    1684.8466 
   15000   -8405.4384   -8405.4384   -8490.4804   -8490.4804    329.12159    329.12159    23433.833    23433.833   -1979.6339   -1979.6339 
Loop time of 152.919 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.477 hours/ns, 6.539 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    | 152.41     | 152.41     | 152.41     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096664   | 0.096664   | 0.096664   |   0.0 |  0.06
Output  | 0.00015514 | 0.00015514 | 0.00015514 |   0.0 |  0.00
Modify  | 0.35244    | 0.35244    | 0.35244    |   0.0 |  0.23
Other   |            | 0.05712    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128432.0 ave      128432 max      128432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128432
Ave neighs/atom = 64.216000
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 = 333.90575750918, Press = -6.85938008793946
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8405.4384   -8405.4384   -8490.4804   -8490.4804    329.12159    329.12159    23433.833    23433.833   -1979.6339   -1979.6339 
   16000   -8401.7733   -8401.7733   -8488.1417   -8488.1417     334.2546     334.2546    23377.576    23377.576    2392.8264    2392.8264 
Loop time of 152.881 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.467 hours/ns, 6.541 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    | 152.37     | 152.37     | 152.37     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095889   | 0.095889   | 0.095889   |   0.0 |  0.06
Output  | 0.00019008 | 0.00019008 | 0.00019008 |   0.0 |  0.00
Modify  | 0.35316    | 0.35316    | 0.35316    |   0.0 |  0.23
Other   |            | 0.05746    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128388.0 ave      128388 max      128388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128388
Ave neighs/atom = 64.194000
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 = 333.870136437793, Press = 2.73768716898039
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8401.7733   -8401.7733   -8488.1417   -8488.1417     334.2546     334.2546    23377.576    23377.576    2392.8264    2392.8264 
   17000   -8405.3861   -8405.3861   -8492.6272   -8492.6272    337.63206    337.63206    23426.353    23426.353   -1543.0111   -1543.0111 
Loop time of 153.284 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.579 hours/ns, 6.524 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.78     | 152.78     | 152.78     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09567    | 0.09567    | 0.09567    |   0.0 |  0.06
Output  | 0.0001528  | 0.0001528  | 0.0001528  |   0.0 |  0.00
Modify  | 0.3534     | 0.3534     | 0.3534     |   0.0 |  0.23
Other   |            | 0.0574     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128456.0 ave      128456 max      128456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128456
Ave neighs/atom = 64.228000
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 = 334.001887266015, Press = -12.0014876876975
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8405.3861   -8405.3861   -8492.6272   -8492.6272    337.63206    337.63206    23426.353    23426.353   -1543.0111   -1543.0111 
   18000   -8401.9313   -8401.9313   -8492.4223   -8492.4223    350.20932    350.20932    23415.125    23415.125   -641.71814   -641.71814 
Loop time of 172.176 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.502 ns/day, 47.827 hours/ns, 5.808 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    | 171.59     | 171.59     | 171.59     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1062     | 0.1062     | 0.1062     |   0.0 |  0.06
Output  | 0.00019846 | 0.00019846 | 0.00019846 |   0.0 |  0.00
Modify  | 0.41336    | 0.41336    | 0.41336    |   0.0 |  0.24
Other   |            | 0.0632     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128364.0 ave      128364 max      128364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128364
Ave neighs/atom = 64.182000
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 = 333.829231477811, Press = 2.28023425036644
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8401.9313   -8401.9313   -8492.4223   -8492.4223    350.20932    350.20932    23415.125    23415.125   -641.71814   -641.71814 
   19000   -8407.0811   -8407.0811    -8492.585    -8492.585    330.90902    330.90902    23404.173    23404.173    -131.0639    -131.0639 
Loop time of 153.385 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.607 hours/ns, 6.520 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    | 152.87     | 152.87     | 152.87     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09718    | 0.09718    | 0.09718    |   0.0 |  0.06
Output  | 0.00015949 | 0.00015949 | 0.00015949 |   0.0 |  0.00
Modify  | 0.35598    | 0.35598    | 0.35598    |   0.0 |  0.23
Other   |            | 0.05847    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128350.0 ave      128350 max      128350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128350
Ave neighs/atom = 64.175000
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 = 333.698207891805, Press = -3.58787903077267
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8407.0811   -8407.0811    -8492.585    -8492.585    330.90902    330.90902    23404.173    23404.173    -131.0639    -131.0639 
   20000   -8405.4333   -8405.4333   -8490.6787   -8490.6787    329.90843    329.90843    23405.255    23405.255    110.43222    110.43222 
Loop time of 153.278 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.577 hours/ns, 6.524 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.77     | 152.77     | 152.77     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09749    | 0.09749    | 0.09749    |   0.0 |  0.06
Output  | 0.00015373 | 0.00015373 | 0.00015373 |   0.0 |  0.00
Modify  | 0.35457    | 0.35457    | 0.35457    |   0.0 |  0.23
Other   |            | 0.0591     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128384.0 ave      128384 max      128384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128384
Ave neighs/atom = 64.192000
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 = 333.776829845533, Press = -0.639206459229498
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8405.4333   -8405.4333   -8490.6787   -8490.6787    329.90843    329.90843    23405.255    23405.255    110.43222    110.43222 
   21000   -8403.8213   -8403.8213   -8488.8374   -8488.8374    329.02141    329.02141    23393.239    23393.239    1166.0464    1166.0464 
Loop time of 154 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.561 ns/day, 42.778 hours/ns, 6.494 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    | 153.49     | 153.49     | 153.49     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09762    | 0.09762    | 0.09762    |   0.0 |  0.06
Output  | 0.00015427 | 0.00015427 | 0.00015427 |   0.0 |  0.00
Modify  | 0.35845    | 0.35845    | 0.35845    |   0.0 |  0.23
Other   |            | 0.05835    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128434.0 ave      128434 max      128434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128434
Ave neighs/atom = 64.217000
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 = 333.850675486908, Press = -5.65984350589613
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8403.8213   -8403.8213   -8488.8374   -8488.8374    329.02141    329.02141    23393.239    23393.239    1166.0464    1166.0464 
   22000   -8410.7092   -8410.7092   -8493.3408   -8493.3408     319.7925     319.7925    23432.968    23432.968   -2263.4792   -2263.4792 
Loop time of 153.084 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.523 hours/ns, 6.532 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.58     | 152.58     | 152.58     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096543   | 0.096543   | 0.096543   |   0.0 |  0.06
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.35434    | 0.35434    | 0.35434    |   0.0 |  0.23
Other   |            | 0.05773    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128464.0 ave      128464 max      128464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128464
Ave neighs/atom = 64.232000
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 = 333.792218530876, Press = 0.0613731351536963
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8410.7092   -8410.7092   -8493.3408   -8493.3408     319.7925     319.7925    23432.968    23432.968   -2263.4792   -2263.4792 
   23000   -8403.4683   -8403.4683   -8489.7914   -8489.7914    334.07922    334.07922    23354.429    23354.429    3818.5869    3818.5869 
Loop time of 153.114 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.532 hours/ns, 6.531 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.6      | 152.6      | 152.6      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09597    | 0.09597    | 0.09597    |   0.0 |  0.06
Output  | 0.0001877  | 0.0001877  | 0.0001877  |   0.0 |  0.00
Modify  | 0.35432    | 0.35432    | 0.35432    |   0.0 |  0.23
Other   |            | 0.0586     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128322.0 ave      128322 max      128322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128322
Ave neighs/atom = 64.161000
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 = 333.623103916872, Press = -2.17921136102398
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8403.4683   -8403.4683   -8489.7914   -8489.7914    334.07922    334.07922    23354.429    23354.429    3818.5869    3818.5869 
   24000   -8409.4102   -8409.4102   -8492.1894   -8492.1894    320.36394    320.36394    23428.154    23428.154   -1877.2701   -1877.2701 
Loop time of 153.318 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.588 hours/ns, 6.522 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.81     | 152.81     | 152.81     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096636   | 0.096636   | 0.096636   |   0.0 |  0.06
Output  | 0.00015628 | 0.00015628 | 0.00015628 |   0.0 |  0.00
Modify  | 0.35505    | 0.35505    | 0.35505    |   0.0 |  0.23
Other   |            | 0.05818    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128458.0 ave      128458 max      128458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128458
Ave neighs/atom = 64.229000
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 = 333.482248779002, Press = -3.79151078576102
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8409.4102   -8409.4102   -8492.1894   -8492.1894    320.36394    320.36394    23428.154    23428.154   -1877.2701   -1877.2701 
   25000   -8402.2782   -8402.2782   -8490.7209   -8490.7209    342.28228    342.28228    23399.035    23399.035    554.07496    554.07496 
Loop time of 153.41 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.614 hours/ns, 6.518 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    | 152.9      | 152.9      | 152.9      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09679    | 0.09679    | 0.09679    |   0.0 |  0.06
Output  | 0.00015291 | 0.00015291 | 0.00015291 |   0.0 |  0.00
Modify  | 0.3538     | 0.3538     | 0.3538     |   0.0 |  0.23
Other   |            | 0.05839    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128360.0 ave      128360 max      128360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128360
Ave neighs/atom = 64.180000
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 = 333.377981505846, Press = -1.45802045764905
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8402.2782   -8402.2782   -8490.7209   -8490.7209    342.28228    342.28228    23399.035    23399.035    554.07496    554.07496 
   26000   -8405.4534   -8405.4534   -8490.4303   -8490.4303    328.86949    328.86949    23420.257    23420.257   -934.57567   -934.57567 
Loop time of 153.564 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.657 hours/ns, 6.512 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    | 153.05     | 153.05     | 153.05     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09667    | 0.09667    | 0.09667    |   0.0 |  0.06
Output  | 0.00015422 | 0.00015422 | 0.00015422 |   0.0 |  0.00
Modify  | 0.35454    | 0.35454    | 0.35454    |   0.0 |  0.23
Other   |            | 0.0583     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128384.0 ave      128384 max      128384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128384
Ave neighs/atom = 64.192000
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 = 333.357421072846, Press = -2.94503151290118
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8405.4534   -8405.4534   -8490.4303   -8490.4303    328.86949    328.86949    23420.257    23420.257   -934.57567   -934.57567 
   27000   -8403.6977   -8403.6977   -8489.6777   -8489.6777    332.75128    332.75128    23398.042    23398.042    900.82998    900.82998 
Loop time of 153.32 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.589 hours/ns, 6.522 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    | 152.81     | 152.81     | 152.81     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096918   | 0.096918   | 0.096918   |   0.0 |  0.06
Output  | 0.00015345 | 0.00015345 | 0.00015345 |   0.0 |  0.00
Modify  | 0.35398    | 0.35398    | 0.35398    |   0.0 |  0.23
Other   |            | 0.05808    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128402.0 ave      128402 max      128402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128402
Ave neighs/atom = 64.201000
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 = 333.332088404463, Press = -0.677878654997162
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8403.6977   -8403.6977   -8489.6777   -8489.6777    332.75128    332.75128    23398.042    23398.042    900.82998    900.82998 
   28000    -8404.765    -8404.765   -8489.9103   -8489.9103    329.52099    329.52099    23413.636    23413.636   -479.39723   -479.39723 
Loop time of 153.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.624 hours/ns, 6.517 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    | 152.94     | 152.94     | 152.94     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096559   | 0.096559   | 0.096559   |   0.0 |  0.06
Output  | 0.00015462 | 0.00015462 | 0.00015462 |   0.0 |  0.00
Modify  | 0.35395    | 0.35395    | 0.35395    |   0.0 |  0.23
Other   |            | 0.05816    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128448.0 ave      128448 max      128448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128448
Ave neighs/atom = 64.224000
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 = 333.318977551018, Press = -5.22793846200233
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -8404.765    -8404.765   -8489.9103   -8489.9103    329.52099    329.52099    23413.636    23413.636   -479.39723   -479.39723 
   29000   -8406.0437   -8406.0437   -8492.4028   -8492.4028    334.21836    334.21836     23412.81     23412.81   -741.48887   -741.48887 
Loop time of 153.508 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.641 hours/ns, 6.514 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    | 153        | 153        | 153        |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096437   | 0.096437   | 0.096437   |   0.0 |  0.06
Output  | 0.00019055 | 0.00019055 | 0.00019055 |   0.0 |  0.00
Modify  | 0.35412    | 0.35412    | 0.35412    |   0.0 |  0.23
Other   |            | 0.05867    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128418.0 ave      128418 max      128418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128418
Ave neighs/atom = 64.209000
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 = 333.350952009141, Press = 1.91257083263507
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8406.0437   -8406.0437   -8492.4028   -8492.4028    334.21836    334.21836     23412.81     23412.81   -741.48887   -741.48887 
   30000    -8407.804    -8407.804   -8492.8723   -8492.8723    329.22294    329.22294      23380.1      23380.1    1636.5288    1636.5288 
Loop time of 153.492 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.637 hours/ns, 6.515 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    | 152.98     | 152.98     | 152.98     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096994   | 0.096994   | 0.096994   |   0.0 |  0.06
Output  | 0.00042546 | 0.00042546 | 0.00042546 |   0.0 |  0.00
Modify  | 0.35563    | 0.35563    | 0.35563    |   0.0 |  0.23
Other   |            | 0.05831    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128352.0 ave      128352 max      128352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128352
Ave neighs/atom = 64.176000
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 = 333.291336958038, Press = -4.62007686051259
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000    -8407.804    -8407.804   -8492.8723   -8492.8723    329.22294    329.22294      23380.1      23380.1    1636.5288    1636.5288 
   31000   -8402.9416   -8402.9416   -8489.0561   -8489.0561    333.27216    333.27216    23435.752    23435.752    -1714.898    -1714.898 
Loop time of 155.098 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.557 ns/day, 43.083 hours/ns, 6.448 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 154.58     | 154.58     | 154.58     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097421   | 0.097421   | 0.097421   |   0.0 |  0.06
Output  | 0.00019769 | 0.00019769 | 0.00019769 |   0.0 |  0.00
Modify  | 0.35994    | 0.35994    | 0.35994    |   0.0 |  0.23
Other   |            | 0.05869    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128392.0 ave      128392 max      128392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128392
Ave neighs/atom = 64.196000
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 = 333.201697273864, Press = -0.520924197410696
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8402.9416   -8402.9416   -8489.0561   -8489.0561    333.27216    333.27216    23435.752    23435.752    -1714.898    -1714.898 
   32000   -8404.3593   -8404.3593   -8491.7279   -8491.7279     338.1256     338.1256    23388.077    23388.077    1125.7066    1125.7066 
Loop time of 172.82 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.005 hours/ns, 5.786 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.22     | 172.22     | 172.22     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.107      | 0.107      | 0.107      |   0.0 |  0.06
Output  | 0.00015078 | 0.00015078 | 0.00015078 |   0.0 |  0.00
Modify  | 0.42427    | 0.42427    | 0.42427    |   0.0 |  0.25
Other   |            | 0.06459    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128404.0 ave      128404 max      128404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128404
Ave neighs/atom = 64.202000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.192181342454, Press = -1.25934591121926
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8404.3593   -8404.3593   -8491.7279   -8491.7279     338.1256     338.1256    23388.077    23388.077    1125.7066    1125.7066 
   33000    -8402.212    -8402.212    -8490.168    -8490.168    340.39905    340.39905    23418.387    23418.387   -583.96523   -583.96523 
Loop time of 152.393 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.332 hours/ns, 6.562 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    | 151.89     | 151.89     | 151.89     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0958     | 0.0958     | 0.0958     |   0.0 |  0.06
Output  | 0.00015413 | 0.00015413 | 0.00015413 |   0.0 |  0.00
Modify  | 0.35217    | 0.35217    | 0.35217    |   0.0 |  0.23
Other   |            | 0.0588     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 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:      128404.0 ave      128404 max      128404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128404
Ave neighs/atom = 64.202000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.297117840606, Press = -2.37252603125615
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -8402.212    -8402.212    -8490.168    -8490.168    340.39905    340.39905    23418.387    23418.387   -583.96523   -583.96523 
   34000   -8402.7198   -8402.7198   -8491.8207   -8491.8207    344.82982    344.82982    23413.703    23413.703   -364.11717   -364.11717 
Loop time of 152.524 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.368 hours/ns, 6.556 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    | 152.02     | 152.02     | 152.02     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094644   | 0.094644   | 0.094644   |   0.0 |  0.06
Output  | 0.00019344 | 0.00019344 | 0.00019344 |   0.0 |  0.00
Modify  | 0.35353    | 0.35353    | 0.35353    |   0.0 |  0.23
Other   |            | 0.05891    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128426.0 ave      128426 max      128426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128426
Ave neighs/atom = 64.213000
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 = 333.270558835348, Press = -1.6583966694599
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8402.7198   -8402.7198   -8491.8207   -8491.8207    344.82982    344.82982    23413.703    23413.703   -364.11717   -364.11717 
   35000   -8406.5149   -8406.5149   -8489.4315   -8489.4315    320.89557    320.89557    23399.954    23399.954    621.56391    621.56391 
Loop time of 152.611 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.392 hours/ns, 6.553 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    | 152.1      | 152.1      | 152.1      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095926   | 0.095926   | 0.095926   |   0.0 |  0.06
Output  | 0.00015112 | 0.00015112 | 0.00015112 |   0.0 |  0.00
Modify  | 0.35211    | 0.35211    | 0.35211    |   0.0 |  0.23
Other   |            | 0.05871    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128468.0 ave      128468 max      128468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128468
Ave neighs/atom = 64.234000
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 = 333.294507437153, Press = -1.36650369849239
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8406.5149   -8406.5149   -8489.4315   -8489.4315    320.89557    320.89557    23399.954    23399.954    621.56391    621.56391 
   36000   -8401.2374   -8401.2374   -8487.0101   -8487.0101    331.94917    331.94917      23414.1      23414.1    176.10624    176.10624 
Loop time of 152.537 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.371 hours/ns, 6.556 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    | 152.03     | 152.03     | 152.03     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095107   | 0.095107   | 0.095107   |   0.0 |  0.06
Output  | 0.0001533  | 0.0001533  | 0.0001533  |   0.0 |  0.00
Modify  | 0.35269    | 0.35269    | 0.35269    |   0.0 |  0.23
Other   |            | 0.05911    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128430.0 ave      128430 max      128430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128430
Ave neighs/atom = 64.215000
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 = 333.375798700916, Press = -2.70868452826809
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8401.2374   -8401.2374   -8487.0101   -8487.0101    331.94917    331.94917      23414.1      23414.1    176.10624    176.10624 
   37000    -8404.448    -8404.448   -8489.4376   -8489.4376    328.91817    328.91817    23416.585    23416.585   -509.36847   -509.36847 
Loop time of 152.506 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.363 hours/ns, 6.557 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    | 152        | 152        | 152        |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095652   | 0.095652   | 0.095652   |   0.0 |  0.06
Output  | 0.00015223 | 0.00015223 | 0.00015223 |   0.0 |  0.00
Modify  | 0.35287    | 0.35287    | 0.35287    |   0.0 |  0.23
Other   |            | 0.05892    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128422.0 ave      128422 max      128422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128422
Ave neighs/atom = 64.211000
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 = 333.3912315021, Press = 0.257845676184695
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000    -8404.448    -8404.448   -8489.4376   -8489.4376    328.91817    328.91817    23416.585    23416.585   -509.36847   -509.36847 
   38000   -8400.7624   -8400.7624   -8490.4165   -8490.4165    346.97055    346.97055    23389.298    23389.298    1473.3053    1473.3053 
Loop time of 152.593 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.387 hours/ns, 6.553 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    | 152.09     | 152.09     | 152.09     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096293   | 0.096293   | 0.096293   |   0.0 |  0.06
Output  | 0.00015141 | 0.00015141 | 0.00015141 |   0.0 |  0.00
Modify  | 0.35315    | 0.35315    | 0.35315    |   0.0 |  0.23
Other   |            | 0.05836    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128438.0 ave      128438 max      128438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128438
Ave neighs/atom = 64.219000
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 = 333.488946942078, Press = -3.47432501894141
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8400.7624   -8400.7624   -8490.4165   -8490.4165    346.97055    346.97055    23389.298    23389.298    1473.3053    1473.3053 
   39000   -8403.0927   -8403.0927     -8490.02     -8490.02    336.41783    336.41783    23447.621    23447.621   -2571.2077   -2571.2077 
Loop time of 152.762 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.434 hours/ns, 6.546 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.25     | 152.25     | 152.25     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095468   | 0.095468   | 0.095468   |   0.0 |  0.06
Output  | 0.00015235 | 0.00015235 | 0.00015235 |   0.0 |  0.00
Modify  | 0.35319    | 0.35319    | 0.35319    |   0.0 |  0.23
Other   |            | 0.05928    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 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:      128440.0 ave      128440 max      128440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128440
Ave neighs/atom = 64.220000
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 = 333.45419128979, Press = -1.19764715422058
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8403.0927   -8403.0927     -8490.02     -8490.02    336.41783    336.41783    23447.621    23447.621   -2571.2077   -2571.2077 
   40000   -8405.0858   -8405.0858   -8493.9914   -8493.9914    344.07356    344.07356    23377.503    23377.503    1726.1478    1726.1478 
Loop time of 152.413 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.337 hours/ns, 6.561 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    | 151.91     | 151.91     | 151.91     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095685   | 0.095685   | 0.095685   |   0.0 |  0.06
Output  | 0.00015296 | 0.00015296 | 0.00015296 |   0.0 |  0.00
Modify  | 0.35269    | 0.35269    | 0.35269    |   0.0 |  0.23
Other   |            | 0.05878    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4115.00 ave        4115 max        4115 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:      128360.0 ave      128360 max      128360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128360
Ave neighs/atom = 64.180000
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 = 333.390053791144, Press = -1.30096658394586
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8405.0858   -8405.0858   -8493.9914   -8493.9914    344.07356    344.07356    23377.503    23377.503    1726.1478    1726.1478 
   41000   -8402.1316   -8402.1316   -8488.3488   -8488.3488    333.66951    333.66951    23439.759    23439.759    -1881.916    -1881.916 
Loop time of 153.065 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.518 hours/ns, 6.533 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    | 152.56     | 152.56     | 152.56     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09538    | 0.09538    | 0.09538    |   0.0 |  0.06
Output  | 0.00018998 | 0.00018998 | 0.00018998 |   0.0 |  0.00
Modify  | 0.35301    | 0.35301    | 0.35301    |   0.0 |  0.23
Other   |            | 0.05897    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128392.0 ave      128392 max      128392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128392
Ave neighs/atom = 64.196000
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 = 333.321479961377, Press = -2.17348781386812
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8402.1316   -8402.1316   -8488.3488   -8488.3488    333.66951    333.66951    23439.759    23439.759    -1881.916    -1881.916 
   42000   -8407.9011   -8407.9011   -8492.2861   -8492.2861    326.57864    326.57864    23369.901    23369.901    2345.6162    2345.6162 
Loop time of 152.754 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.432 hours/ns, 6.546 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.25     | 152.25     | 152.25     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095252   | 0.095252   | 0.095252   |   0.0 |  0.06
Output  | 0.00015385 | 0.00015385 | 0.00015385 |   0.0 |  0.00
Modify  | 0.35251    | 0.35251    | 0.35251    |   0.0 |  0.23
Other   |            | 0.059      |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 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:      128418.0 ave      128418 max      128418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128418
Ave neighs/atom = 64.209000
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 = 333.295257052783, Press = 0.600333715192591
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8407.9011   -8407.9011   -8492.2861   -8492.2861    326.57864    326.57864    23369.901    23369.901    2345.6162    2345.6162 
   43000   -8403.4619   -8403.4619   -8489.3924   -8489.3924    332.55988    332.55988    23423.931    23423.931   -946.85625   -946.85625 
Loop time of 152.286 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.302 hours/ns, 6.567 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    | 151.78     | 151.78     | 151.78     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095363   | 0.095363   | 0.095363   |   0.0 |  0.06
Output  | 0.00019245 | 0.00019245 | 0.00019245 |   0.0 |  0.00
Modify  | 0.3528     | 0.3528     | 0.3528     |   0.0 |  0.23
Other   |            | 0.05898    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128362.0 ave      128362 max      128362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128362
Ave neighs/atom = 64.181000
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 = 333.220280458159, Press = -3.65762927816695
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8403.4619   -8403.4619   -8489.3924   -8489.3924    332.55988    332.55988    23423.931    23423.931   -946.85625   -946.85625 
   44000    -8406.224    -8406.224   -8490.6473   -8490.6473    326.72689    326.72689    23407.555    23407.555   -130.16831   -130.16831 
Loop time of 152.492 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.359 hours/ns, 6.558 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    | 151.99     | 151.99     | 151.99     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095506   | 0.095506   | 0.095506   |   0.0 |  0.06
Output  | 0.00015165 | 0.00015165 | 0.00015165 |   0.0 |  0.00
Modify  | 0.35222    | 0.35222    | 0.35222    |   0.0 |  0.23
Other   |            | 0.05837    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128410.0 ave      128410 max      128410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128410
Ave neighs/atom = 64.205000
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
23408.3150913854

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0