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

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WuLeeSu_2017_NiCrFe__MO_912636107108_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 23483.5171943885    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23483.5171943885/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23483.5171943885/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23483.5171943885/(1*1*${_u_distance})
variable      V0_metal equal 23483.5171943885/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23483.5171943885*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23483.5171943885 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_912636107108_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.9171   -8493.9171        -8580        -8580       333.15       333.15    23483.517    23483.517     3915.363     3915.363 
    1000   -8403.1264   -8403.1264   -8485.9288   -8485.9288    320.45388    320.45388    23773.247    23773.247   -763.85448   -763.85448 
Loop time of 139.467 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.741 hours/ns, 7.170 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    | 138.95     | 138.95     | 138.95     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098622   | 0.098622   | 0.098622   |   0.0 |  0.07
Output  | 0.0001997  | 0.0001997  | 0.0001997  |   0.0 |  0.00
Modify  | 0.3525     | 0.3525     | 0.3525     |   0.0 |  0.25
Other   |            | 0.06157    |            |       |  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.1264   -8403.1264   -8485.9288   -8485.9288    320.45388    320.45388    23773.247    23773.247   -763.85448   -763.85448 
    2000   -8404.0143   -8404.0143   -8489.8707   -8489.8707    332.27342    332.27342    23787.658    23787.658   -2195.6534   -2195.6534 
Loop time of 144.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.598 ns/day, 40.140 hours/ns, 6.920 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    | 143.99     | 143.99     | 143.99     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097589   | 0.097589   | 0.097589   |   0.0 |  0.07
Output  | 0.00022625 | 0.00022625 | 0.00022625 |   0.0 |  0.00
Modify  | 0.3522     | 0.3522     | 0.3522     |   0.0 |  0.24
Other   |            | 0.06181    |            |       |  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:      128066.0 ave      128066 max      128066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128066
Ave neighs/atom = 64.033000
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   -8404.0143   -8404.0143   -8489.8707   -8489.8707    332.27342    332.27342    23787.658    23787.658   -2195.6534   -2195.6534 
    3000   -8404.9819   -8404.9819   -8485.3213   -8485.3213     310.9218     310.9218    23731.645    23731.645    2250.2649    2250.2649 
Loop time of 148.509 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.253 hours/ns, 6.734 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    | 147.98     | 147.98     | 147.98     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099927   | 0.099927   | 0.099927   |   0.0 |  0.07
Output  | 0.00019235 | 0.00019235 | 0.00019235 |   0.0 |  0.00
Modify  | 0.36456    | 0.36456    | 0.36456    |   0.0 |  0.25
Other   |            | 0.06344    |            |       |  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:      128084.0 ave      128084 max      128084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128084
Ave neighs/atom = 64.042000
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.9819   -8404.9819   -8485.3213   -8485.3213     310.9218     310.9218    23731.645    23731.645    2250.2649    2250.2649 
    4000    -8403.135    -8403.135   -8489.6566   -8489.6566    334.84782    334.84782     23733.79     23733.79    1535.4212    1535.4212 
Loop time of 148.211 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.170 hours/ns, 6.747 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    | 147.69     | 147.69     | 147.69     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099851   | 0.099851   | 0.099851   |   0.0 |  0.07
Output  | 0.00018903 | 0.00018903 | 0.00018903 |   0.0 |  0.00
Modify  | 0.3598     | 0.3598     | 0.3598     |   0.0 |  0.24
Other   |            | 0.06212    |            |       |  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:      128122.0 ave      128122 max      128122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128122
Ave neighs/atom = 64.061000
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.135    -8403.135   -8489.6566   -8489.6566    334.84782    334.84782     23733.79     23733.79    1535.4212    1535.4212 
    5000    -8405.012    -8405.012   -8492.2545   -8492.2545     337.6375     337.6375     23774.85     23774.85   -1540.6609   -1540.6609 
Loop time of 148.296 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.193 hours/ns, 6.743 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    | 147.77     | 147.77     | 147.77     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09924    | 0.09924    | 0.09924    |   0.0 |  0.07
Output  | 0.00015563 | 0.00015563 | 0.00015563 |   0.0 |  0.00
Modify  | 0.3617     | 0.3617     | 0.3617     |   0.0 |  0.24
Other   |            | 0.0624     |            |       |  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:      128104.0 ave      128104 max      128104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128104
Ave neighs/atom = 64.052000
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.519343304406, Press = -163.30910107338
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.012    -8405.012   -8492.2545   -8492.2545     337.6375     337.6375     23774.85     23774.85   -1540.6609   -1540.6609 
    6000    -8402.599    -8402.599   -8492.8722   -8492.8722    349.36679    349.36679    23765.778    23765.778     -949.151     -949.151 
Loop time of 147.055 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.588 ns/day, 40.849 hours/ns, 6.800 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    | 146.51     | 146.51     | 146.51     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10069    | 0.10069    | 0.10069    |   0.0 |  0.07
Output  | 0.00015642 | 0.00015642 | 0.00015642 |   0.0 |  0.00
Modify  | 0.38211    | 0.38211    | 0.38211    |   0.0 |  0.26
Other   |            | 0.06223    |            |       |  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:      128050.0 ave      128050 max      128050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128050
Ave neighs/atom = 64.025000
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.816616769413, Press = 17.2456376914134
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    -8402.599    -8402.599   -8492.8722   -8492.8722    349.36679    349.36679    23765.778    23765.778     -949.151     -949.151 
    7000   -8407.1418   -8407.1418   -8491.9162   -8491.9162    328.08587    328.08587    23743.693    23743.693    566.29487    566.29487 
Loop time of 146.329 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.590 ns/day, 40.647 hours/ns, 6.834 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    | 145.8      | 145.8      | 145.8      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097502   | 0.097502   | 0.097502   |   0.0 |  0.07
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.37195    | 0.37195    | 0.37195    |   0.0 |  0.25
Other   |            | 0.06137    |            |       |  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:      128064.0 ave      128064 max      128064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128064
Ave neighs/atom = 64.032000
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.353624633672, Press = 21.1891568047268
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   -8407.1418   -8407.1418   -8491.9162   -8491.9162    328.08587    328.08587    23743.693    23743.693    566.29487    566.29487 
    8000   -8402.6261   -8402.6261    -8490.486    -8490.486    340.02678    340.02678    23723.972    23723.972    2283.5946    2283.5946 
Loop time of 146.763 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.589 ns/day, 40.767 hours/ns, 6.814 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    | 146.22     | 146.22     | 146.22     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099362   | 0.099362   | 0.099362   |   0.0 |  0.07
Output  | 0.00015068 | 0.00015068 | 0.00015068 |   0.0 |  0.00
Modify  | 0.37729    | 0.37729    | 0.37729    |   0.0 |  0.26
Other   |            | 0.06241    |            |       |  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:      128082.0 ave      128082 max      128082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128082
Ave neighs/atom = 64.041000
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.332856434708, Press = -19.8604287089257
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   -8402.6261   -8402.6261    -8490.486    -8490.486    340.02678    340.02678    23723.972    23723.972    2283.5946    2283.5946 
    9000    -8405.959    -8405.959   -8488.7145   -8488.7145     320.2726     320.2726    23786.944    23786.944   -1999.6278   -1999.6278 
Loop time of 146.669 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.589 ns/day, 40.741 hours/ns, 6.818 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    | 146.13     | 146.13     | 146.13     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099144   | 0.099144   | 0.099144   |   0.0 |  0.07
Output  | 0.00015645 | 0.00015645 | 0.00015645 |   0.0 |  0.00
Modify  | 0.37607    | 0.37607    | 0.37607    |   0.0 |  0.26
Other   |            | 0.0625     |            |       |  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:      128086.0 ave      128086 max      128086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128086
Ave neighs/atom = 64.043000
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.016619063499, Press = -14.6797325497748
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    -8405.959    -8405.959   -8488.7145   -8488.7145     320.2726     320.2726    23786.944    23786.944   -1999.6278   -1999.6278 
   10000   -8402.0885   -8402.0885   -8488.3249   -8488.3249    333.74396    333.74396     23778.78     23778.78   -1274.6736   -1274.6736 
Loop time of 146.333 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.590 ns/day, 40.648 hours/ns, 6.834 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    | 145.8      | 145.8      | 145.8      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099002   | 0.099002   | 0.099002   |   0.0 |  0.07
Output  | 0.00015137 | 0.00015137 | 0.00015137 |   0.0 |  0.00
Modify  | 0.37248    | 0.37248    | 0.37248    |   0.0 |  0.25
Other   |            | 0.06143    |            |       |  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:      128002.0 ave      128002 max      128002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128002
Ave neighs/atom = 64.001000
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.654269004303, Press = 9.76701005528376
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.0885   -8402.0885   -8488.3249   -8488.3249    333.74396    333.74396     23778.78     23778.78   -1274.6736   -1274.6736 
   11000   -8405.6067   -8405.6067   -8491.8434   -8491.8434    333.74468    333.74468    23739.512    23739.512    852.41654    852.41654 
Loop time of 146.842 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.588 ns/day, 40.789 hours/ns, 6.810 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    | 146.31     | 146.31     | 146.31     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099008   | 0.099008   | 0.099008   |   0.0 |  0.07
Output  | 0.00019383 | 0.00019383 | 0.00019383 |   0.0 |  0.00
Modify  | 0.37499    | 0.37499    | 0.37499    |   0.0 |  0.26
Other   |            | 0.06164    |            |       |  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:      128026.0 ave      128026 max      128026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128026
Ave neighs/atom = 64.013000
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.306428870802, Press = 3.16272366534148
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   -8405.6067   -8405.6067   -8491.8434   -8491.8434    333.74468    333.74468    23739.512    23739.512    852.41654    852.41654 
   12000   -8401.4165   -8401.4165   -8487.3957   -8487.3957    332.74835    332.74835    23758.134    23758.134    365.58098    365.58098 
Loop time of 146.829 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.588 ns/day, 40.786 hours/ns, 6.811 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    | 146.29     | 146.29     | 146.29     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099826   | 0.099826   | 0.099826   |   0.0 |  0.07
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.37934    | 0.37934    | 0.37934    |   0.0 |  0.26
Other   |            | 0.06249    |            |       |  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:      128056.0 ave      128056 max      128056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128056
Ave neighs/atom = 64.028000
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.292364577319, Press = -1.20824167957048
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   -8401.4165   -8401.4165   -8487.3957   -8487.3957    332.74835    332.74835    23758.134    23758.134    365.58098    365.58098 
   13000   -8403.1862   -8403.1862   -8489.0787   -8489.0787    332.41299    332.41299    23757.946    23757.946    150.31161    150.31161 
Loop time of 145.766 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.593 ns/day, 40.491 hours/ns, 6.860 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    | 145.23     | 145.23     | 145.23     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098524   | 0.098524   | 0.098524   |   0.0 |  0.07
Output  | 0.0003125  | 0.0003125  | 0.0003125  |   0.0 |  0.00
Modify  | 0.37197    | 0.37197    | 0.37197    |   0.0 |  0.26
Other   |            | 0.06275    |            |       |  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:      128052.0 ave      128052 max      128052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128052
Ave neighs/atom = 64.026000
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.705926553401, Press = -0.202154483292392
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   -8403.1862   -8403.1862   -8489.0787   -8489.0787    332.41299    332.41299    23757.946    23757.946    150.31161    150.31161 
   14000   -8401.3145   -8401.3145   -8487.3242   -8487.3242     332.8665     332.8665    23768.337    23768.337   -408.65752   -408.65752 
Loop time of 146.24 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.591 ns/day, 40.622 hours/ns, 6.838 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    | 145.71     | 145.71     | 145.71     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098715   | 0.098715   | 0.098715   |   0.0 |  0.07
Output  | 0.00015259 | 0.00015259 | 0.00015259 |   0.0 |  0.00
Modify  | 0.37345    | 0.37345    | 0.37345    |   0.0 |  0.26
Other   |            | 0.06211    |            |       |  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:      128046.0 ave      128046 max      128046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128046
Ave neighs/atom = 64.023000
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.71689782766, Press = -2.13607593440808
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   -8401.3145   -8401.3145   -8487.3242   -8487.3242     332.8665     332.8665    23768.337    23768.337   -408.65752   -408.65752 
   15000   -8405.1461   -8405.1461   -8491.4518   -8491.4518    334.01192    334.01192    23757.946    23757.946   -249.04318   -249.04318 
Loop time of 146.658 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.589 ns/day, 40.738 hours/ns, 6.819 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    | 146.12     | 146.12     | 146.12     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098983   | 0.098983   | 0.098983   |   0.0 |  0.07
Output  | 0.00015607 | 0.00015607 | 0.00015607 |   0.0 |  0.00
Modify  | 0.37329    | 0.37329    | 0.37329    |   0.0 |  0.25
Other   |            | 0.0617     |            |       |  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:      128068.0 ave      128068 max      128068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128068
Ave neighs/atom = 64.034000
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.967822900402, Press = 2.6203067793989
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.1461   -8405.1461   -8491.4518   -8491.4518    334.01192    334.01192    23757.946    23757.946   -249.04318   -249.04318 
   16000   -8401.6504   -8401.6504   -8487.7091   -8487.7091    333.05616    333.05616    23741.718    23741.718    1457.9351    1457.9351 
Loop time of 146.427 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.590 ns/day, 40.674 hours/ns, 6.829 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    | 145.89     | 145.89     | 145.89     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09796    | 0.09796    | 0.09796    |   0.0 |  0.07
Output  | 0.00016313 | 0.00016313 | 0.00016313 |   0.0 |  0.00
Modify  | 0.37258    | 0.37258    | 0.37258    |   0.0 |  0.25
Other   |            | 0.0615     |            |       |  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:      128054.0 ave      128054 max      128054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128054
Ave neighs/atom = 64.027000
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.939855617918, Press = 0.815322800354333
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.6504   -8401.6504   -8487.7091   -8487.7091    333.05616    333.05616    23741.718    23741.718    1457.9351    1457.9351 
   17000   -8403.8614   -8403.8614   -8490.0612   -8490.0612    333.60214    333.60214    23758.565    23758.565   -207.92046   -207.92046 
Loop time of 146.338 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.590 ns/day, 40.650 hours/ns, 6.833 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    | 145.81     | 145.81     | 145.81     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097797   | 0.097797   | 0.097797   |   0.0 |  0.07
Output  | 0.00021743 | 0.00021743 | 0.00021743 |   0.0 |  0.00
Modify  | 0.37293    | 0.37293    | 0.37293    |   0.0 |  0.25
Other   |            | 0.06195    |            |       |  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:      128090.0 ave      128090 max      128090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128090
Ave neighs/atom = 64.045000
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.804897640197, Press = -5.35978951304132
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   -8403.8614   -8403.8614   -8490.0612   -8490.0612    333.60214    333.60214    23758.565    23758.565   -207.92046   -207.92046 
   18000   -8402.9659   -8402.9659   -8489.4195   -8489.4195    334.58454    334.58454    23795.525    23795.525   -2532.7402   -2532.7402 
Loop time of 146.35 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.590 ns/day, 40.653 hours/ns, 6.833 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    | 145.82     | 145.82     | 145.82     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098315   | 0.098315   | 0.098315   |   0.0 |  0.07
Output  | 0.00015579 | 0.00015579 | 0.00015579 |   0.0 |  0.00
Modify  | 0.37225    | 0.37225    | 0.37225    |   0.0 |  0.25
Other   |            | 0.06216    |            |       |  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:      128094.0 ave      128094 max      128094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128094
Ave neighs/atom = 64.047000
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.821741263988, Press = -2.3903492180659
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   -8402.9659   -8402.9659   -8489.4195   -8489.4195    334.58454    334.58454    23795.525    23795.525   -2532.7402   -2532.7402 
   19000   -8403.8715   -8403.8715   -8491.5795   -8491.5795    339.43933    339.43933    23752.761    23752.761    94.661343    94.661343 
Loop time of 144.41 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.598 ns/day, 40.114 hours/ns, 6.925 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.89     | 143.89     | 143.89     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097373   | 0.097373   | 0.097373   |   0.0 |  0.07
Output  | 0.00015225 | 0.00015225 | 0.00015225 |   0.0 |  0.00
Modify  | 0.36607    | 0.36607    | 0.36607    |   0.0 |  0.25
Other   |            | 0.06093    |            |       |  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:      128028.0 ave      128028 max      128028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128028
Ave neighs/atom = 64.014000
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.756894740708, Press = 5.61891095082379
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   -8403.8715   -8403.8715   -8491.5795   -8491.5795    339.43933    339.43933    23752.761    23752.761    94.661343    94.661343 
   20000   -8402.0601   -8402.0601   -8489.4669   -8489.4669    338.27325    338.27325    23729.722    23729.722    2047.6192    2047.6192 
Loop time of 146.451 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.590 ns/day, 40.681 hours/ns, 6.828 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    | 145.92     | 145.92     | 145.92     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098794   | 0.098794   | 0.098794   |   0.0 |  0.07
Output  | 0.00015902 | 0.00015902 | 0.00015902 |   0.0 |  0.00
Modify  | 0.37505    | 0.37505    | 0.37505    |   0.0 |  0.26
Other   |            | 0.0618     |            |       |  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:      128054.0 ave      128054 max      128054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128054
Ave neighs/atom = 64.027000
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.776201098312, Press = -1.77327056434088
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   -8402.0601   -8402.0601   -8489.4669   -8489.4669    338.27325    338.27325    23729.722    23729.722    2047.6192    2047.6192 
   21000   -8402.9253   -8402.9253    -8490.129    -8490.129    337.48742    337.48742    23771.448    23771.448   -1042.8016   -1042.8016 
Loop time of 147.093 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.587 ns/day, 40.859 hours/ns, 6.798 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    | 146.56     | 146.56     | 146.56     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098219   | 0.098219   | 0.098219   |   0.0 |  0.07
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.37644    | 0.37644    | 0.37644    |   0.0 |  0.26
Other   |            | 0.06222    |            |       |  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:      128086.0 ave      128086 max      128086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128086
Ave neighs/atom = 64.043000
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.778585860037, Press = -1.29994833348565
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   -8402.9253   -8402.9253    -8490.129    -8490.129    337.48742    337.48742    23771.448    23771.448   -1042.8016   -1042.8016 
   22000   -8404.8485   -8404.8485   -8491.6766   -8491.6766    336.03353    336.03353    23763.177    23763.177   -681.04182   -681.04182 
Loop time of 146.611 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.589 ns/day, 40.725 hours/ns, 6.821 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    | 146.07     | 146.07     | 146.07     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099138   | 0.099138   | 0.099138   |   0.0 |  0.07
Output  | 0.0001977  | 0.0001977  | 0.0001977  |   0.0 |  0.00
Modify  | 0.37608    | 0.37608    | 0.37608    |   0.0 |  0.26
Other   |            | 0.0623     |            |       |  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:      128048.0 ave      128048 max      128048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128048
Ave neighs/atom = 64.024000
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.937587937151, Press = 0.58286774722191
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   -8404.8485   -8404.8485   -8491.6766   -8491.6766    336.03353    336.03353    23763.177    23763.177   -681.04182   -681.04182 
   23000   -8400.5808   -8400.5808   -8488.5192   -8488.5192    340.33047    340.33047    23753.185    23753.185    539.42767    539.42767 
Loop time of 145.822 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.593 ns/day, 40.506 hours/ns, 6.858 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    | 145.29     | 145.29     | 145.29     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098182   | 0.098182   | 0.098182   |   0.0 |  0.07
Output  | 0.00015754 | 0.00015754 | 0.00015754 |   0.0 |  0.00
Modify  | 0.37188    | 0.37188    | 0.37188    |   0.0 |  0.26
Other   |            | 0.06144    |            |       |  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:      128034.0 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017000
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.940712773572, Press = 0.764992462307459
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   -8400.5808   -8400.5808   -8488.5192   -8488.5192    340.33047    340.33047    23753.185    23753.185    539.42767    539.42767 
   24000   -8406.7643   -8406.7643   -8492.2371   -8492.2371    330.78862    330.78862    23735.286    23735.286     1095.506     1095.506 
Loop time of 144.54 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.598 ns/day, 40.150 hours/ns, 6.918 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.01     | 144.01     | 144.01     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097421   | 0.097421   | 0.097421   |   0.0 |  0.07
Output  | 0.00015249 | 0.00015249 | 0.00015249 |   0.0 |  0.00
Modify  | 0.36908    | 0.36908    | 0.36908    |   0.0 |  0.26
Other   |            | 0.06138    |            |       |  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:      128084.0 ave      128084 max      128084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128084
Ave neighs/atom = 64.042000
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.924047037863, Press = -5.130903921136
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   -8406.7643   -8406.7643   -8492.2371   -8492.2371    330.78862    330.78862    23735.286    23735.286     1095.506     1095.506 
   25000   -8401.9169   -8401.9169   -8488.8355   -8488.8355    336.38406    336.38406    23810.858    23810.858   -3633.2069   -3633.2069 
Loop time of 146.307 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.591 ns/day, 40.641 hours/ns, 6.835 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    | 145.77     | 145.77     | 145.77     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098328   | 0.098328   | 0.098328   |   0.0 |  0.07
Output  | 0.00015391 | 0.00015391 | 0.00015391 |   0.0 |  0.00
Modify  | 0.37483    | 0.37483    | 0.37483    |   0.0 |  0.26
Other   |            | 0.06182    |            |       |  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:      128094.0 ave      128094 max      128094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128094
Ave neighs/atom = 64.047000
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.884654614423, Press = -1.12157408771868
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   -8401.9169   -8401.9169   -8488.8355   -8488.8355    336.38406    336.38406    23810.858    23810.858   -3633.2069   -3633.2069 
   26000   -8409.2433   -8409.2433   -8491.9105   -8491.9105    319.93041    319.93041    23741.895    23741.895     560.4695     560.4695 
Loop time of 145.179 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.595 ns/day, 40.327 hours/ns, 6.888 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    | 144.65     | 144.65     | 144.65     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098486   | 0.098486   | 0.098486   |   0.0 |  0.07
Output  | 0.00015441 | 0.00015441 | 0.00015441 |   0.0 |  0.00
Modify  | 0.36762    | 0.36762    | 0.36762    |   0.0 |  0.25
Other   |            | 0.06115    |            |       |  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:      128014.0 ave      128014 max      128014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128014
Ave neighs/atom = 64.007000
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.770205084721, Press = 3.17965015255712
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   -8409.2433   -8409.2433   -8491.9105   -8491.9105    319.93041    319.93041    23741.895    23741.895     560.4695     560.4695 
   27000   -8403.8001   -8403.8001   -8490.0673   -8490.0673      333.863      333.863    23729.205    23729.205    2055.4426    2055.4426 
Loop time of 144.691 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.597 ns/day, 40.192 hours/ns, 6.911 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    | 144.16     | 144.16     | 144.16     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098039   | 0.098039   | 0.098039   |   0.0 |  0.07
Output  | 0.00015195 | 0.00015195 | 0.00015195 |   0.0 |  0.00
Modify  | 0.37058    | 0.37058    | 0.37058    |   0.0 |  0.26
Other   |            | 0.06157    |            |       |  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:      128086.0 ave      128086 max      128086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128086
Ave neighs/atom = 64.043000
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.636958385698, Press = -0.731153025542627
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.8001   -8403.8001   -8490.0673   -8490.0673      333.863      333.863    23729.205    23729.205    2055.4426    2055.4426 
   28000   -8404.0998   -8404.0998   -8488.7143   -8488.7143     327.4669     327.4669    23767.206    23767.206   -540.94621   -540.94621 
Loop time of 146.884 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.588 ns/day, 40.801 hours/ns, 6.808 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    | 146.35     | 146.35     | 146.35     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099376   | 0.099376   | 0.099376   |   0.0 |  0.07
Output  | 0.00015432 | 0.00015432 | 0.00015432 |   0.0 |  0.00
Modify  | 0.37603    | 0.37603    | 0.37603    |   0.0 |  0.26
Other   |            | 0.0625     |            |       |  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:      128082.0 ave      128082 max      128082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128082
Ave neighs/atom = 64.041000
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.630697453059, Press = -1.63319400653288
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.0998   -8404.0998   -8488.7143   -8488.7143     327.4669     327.4669    23767.206    23767.206   -540.94621   -540.94621 
   29000   -8404.7921   -8404.7921   -8491.2046   -8491.2046    334.42521    334.42521    23758.427    23758.427   -286.07665   -286.07665 
Loop time of 146.257 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.591 ns/day, 40.627 hours/ns, 6.837 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    | 145.72     | 145.72     | 145.72     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098516   | 0.098516   | 0.098516   |   0.0 |  0.07
Output  | 0.00015124 | 0.00015124 | 0.00015124 |   0.0 |  0.00
Modify  | 0.37296    | 0.37296    | 0.37296    |   0.0 |  0.26
Other   |            | 0.06163    |            |       |  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:      128034.0 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017000
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.66632144633, Press = 0.115069243778446
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   -8404.7921   -8404.7921   -8491.2046   -8491.2046    334.42521    334.42521    23758.427    23758.427   -286.07665   -286.07665 
   30000    -8408.439    -8408.439    -8492.068    -8492.068    323.65273    323.65273     23746.84     23746.84     308.1285     308.1285 
Loop time of 144.788 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.597 ns/day, 40.219 hours/ns, 6.907 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    | 144.26     | 144.26     | 144.26     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097641   | 0.097641   | 0.097641   |   0.0 |  0.07
Output  | 0.00054962 | 0.00054962 | 0.00054962 |   0.0 |  0.00
Modify  | 0.36858    | 0.36858    | 0.36858    |   0.0 |  0.25
Other   |            | 0.06151    |            |       |  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:      128082.0 ave      128082 max      128082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128082
Ave neighs/atom = 64.041000
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.658936959355, Press = -0.588599895637731
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    -8408.439    -8408.439    -8492.068    -8492.068    323.65273    323.65273     23746.84     23746.84     308.1285     308.1285 
   31000   -8403.3693   -8403.3693   -8490.4485   -8490.4485    337.00559    337.00559    23755.072    23755.072   -19.056636   -19.056636 
Loop time of 145.271 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.595 ns/day, 40.353 hours/ns, 6.884 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    | 144.74     | 144.74     | 144.74     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098251   | 0.098251   | 0.098251   |   0.0 |  0.07
Output  | 0.00015802 | 0.00015802 | 0.00015802 |   0.0 |  0.00
Modify  | 0.37479    | 0.37479    | 0.37479    |   0.0 |  0.26
Other   |            | 0.06171    |            |       |  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:      128032.0 ave      128032 max      128032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128032
Ave neighs/atom = 64.016000
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.51324343318, Press = -0.534006472105595
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   -8403.3693   -8403.3693   -8490.4485   -8490.4485    337.00559    337.00559    23755.072    23755.072   -19.056636   -19.056636 
   32000   -8403.5421   -8403.5421   -8489.5568   -8489.5568    332.88546    332.88546    23754.418    23754.418    122.55357    122.55357 
Loop time of 145.942 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.592 ns/day, 40.539 hours/ns, 6.852 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    | 145.4      | 145.4      | 145.4      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099011   | 0.099011   | 0.099011   |   0.0 |  0.07
Output  | 0.00015396 | 0.00015396 | 0.00015396 |   0.0 |  0.00
Modify  | 0.37583    | 0.37583    | 0.37583    |   0.0 |  0.26
Other   |            | 0.06187    |            |       |  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:      128060.0 ave      128060 max      128060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128060
Ave neighs/atom = 64.030000
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.551306950233, Press = -0.881687603649235
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   -8403.5421   -8403.5421   -8489.5568   -8489.5568    332.88546    332.88546    23754.418    23754.418    122.55357    122.55357 
   33000   -8404.3565   -8404.3565   -8489.6716   -8489.6716    330.17822    330.17822    23765.622    23765.622   -530.73037   -530.73037 
Loop time of 145.183 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.595 ns/day, 40.329 hours/ns, 6.888 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    | 144.65     | 144.65     | 144.65     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09774    | 0.09774    | 0.09774    |   0.0 |  0.07
Output  | 0.00015692 | 0.00015692 | 0.00015692 |   0.0 |  0.00
Modify  | 0.37058    | 0.37058    | 0.37058    |   0.0 |  0.26
Other   |            | 0.06196    |            |       |  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:      128078.0 ave      128078 max      128078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128078
Ave neighs/atom = 64.039000
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.486560387971, Press = -0.61702021900363
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   -8404.3565   -8404.3565   -8489.6716   -8489.6716    330.17822    330.17822    23765.622    23765.622   -530.73037   -530.73037 
   34000   -8407.0579   -8407.0579   -8491.5459   -8491.5459    326.97747    326.97747    23746.722    23746.722    479.61551    479.61551 
Loop time of 146.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.589 ns/day, 40.737 hours/ns, 6.819 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    | 146.11     | 146.11     | 146.11     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099524   | 0.099524   | 0.099524   |   0.0 |  0.07
Output  | 0.00015412 | 0.00015412 | 0.00015412 |   0.0 |  0.00
Modify  | 0.38147    | 0.38147    | 0.38147    |   0.0 |  0.26
Other   |            | 0.06276    |            |       |  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:      128054.0 ave      128054 max      128054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128054
Ave neighs/atom = 64.027000
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.43274491659, Press = 0.0823007431245347
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   -8407.0579   -8407.0579   -8491.5459   -8491.5459    326.97747    326.97747    23746.722    23746.722    479.61551    479.61551 
   35000   -8406.0705   -8406.0705    -8490.519    -8490.519    326.82438    326.82438    23731.637    23731.637    1712.5849    1712.5849 
Loop time of 145.533 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.594 ns/day, 40.426 hours/ns, 6.871 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    | 145        | 145        | 145        |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097129   | 0.097129   | 0.097129   |   0.0 |  0.07
Output  | 0.00016128 | 0.00016128 | 0.00016128 |   0.0 |  0.00
Modify  | 0.37138    | 0.37138    | 0.37138    |   0.0 |  0.26
Other   |            | 0.06199    |            |       |  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:      128038.0 ave      128038 max      128038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128038
Ave neighs/atom = 64.019000
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.351925375607, Press = -1.37631945617199
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.0705   -8406.0705    -8490.519    -8490.519    326.82438    326.82438    23731.637    23731.637    1712.5849    1712.5849 
   36000   -8406.0021   -8406.0021   -8490.2824   -8490.2824     326.1733     326.1733     23789.49     23789.49   -2363.4893   -2363.4893 
Loop time of 146.177 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.591 ns/day, 40.605 hours/ns, 6.841 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    | 145.64     | 145.64     | 145.64     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099407   | 0.099407   | 0.099407   |   0.0 |  0.07
Output  | 0.00024253 | 0.00024253 | 0.00024253 |   0.0 |  0.00
Modify  | 0.37703    | 0.37703    | 0.37703    |   0.0 |  0.26
Other   |            | 0.0618     |            |       |  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:      128048.0 ave      128048 max      128048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128048
Ave neighs/atom = 64.024000
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.36148843031, Press = -2.00291014013276
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   -8406.0021   -8406.0021   -8490.2824   -8490.2824     326.1733     326.1733     23789.49     23789.49   -2363.4893   -2363.4893 
   37000   -8401.6834   -8401.6834   -8487.0307   -8487.0307    330.30309    330.30309    23762.056    23762.056    181.61322    181.61322 
Loop time of 145.108 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.595 ns/day, 40.308 hours/ns, 6.891 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    | 144.58     | 144.58     | 144.58     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09755    | 0.09755    | 0.09755    |   0.0 |  0.07
Output  | 0.00015331 | 0.00015331 | 0.00015331 |   0.0 |  0.00
Modify  | 0.36987    | 0.36987    | 0.36987    |   0.0 |  0.25
Other   |            | 0.06157    |            |       |  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:      128028.0 ave      128028 max      128028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128028
Ave neighs/atom = 64.014000
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.394108951056, Press = 2.45274826301756
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   -8401.6834   -8401.6834   -8487.0307   -8487.0307    330.30309    330.30309    23762.056    23762.056    181.61322    181.61322 
   38000   -8406.1785   -8406.1785   -8490.9463   -8490.9463    328.06029    328.06029    23714.297    23714.297    2792.8437    2792.8437 
Loop time of 146.283 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.591 ns/day, 40.634 hours/ns, 6.836 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    | 145.75     | 145.75     | 145.75     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098342   | 0.098342   | 0.098342   |   0.0 |  0.07
Output  | 0.00015575 | 0.00015575 | 0.00015575 |   0.0 |  0.00
Modify  | 0.37016    | 0.37016    | 0.37016    |   0.0 |  0.25
Other   |            | 0.06132    |            |       |  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:      128058.0 ave      128058 max      128058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128058
Ave neighs/atom = 64.029000
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.357911190084, Press = -0.575316884373505
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   -8406.1785   -8406.1785   -8490.9463   -8490.9463    328.06029    328.06029    23714.297    23714.297    2792.8437    2792.8437 
   39000   -8402.0775   -8402.0775   -8487.2568   -8487.2568    329.65262    329.65262    23768.365    23768.365   -420.51606   -420.51606 
Loop time of 144.241 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.599 ns/day, 40.067 hours/ns, 6.933 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.71     | 143.71     | 143.71     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097817   | 0.097817   | 0.097817   |   0.0 |  0.07
Output  | 0.00015258 | 0.00015258 | 0.00015258 |   0.0 |  0.00
Modify  | 0.3685     | 0.3685     | 0.3685     |   0.0 |  0.26
Other   |            | 0.06076    |            |       |  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:      128098.0 ave      128098 max      128098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128098
Ave neighs/atom = 64.049000
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.37795089598, Press = -1.37853104202353
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   -8402.0775   -8402.0775   -8487.2568   -8487.2568    329.65262    329.65262    23768.365    23768.365   -420.51606   -420.51606 
   40000   -8407.6821   -8407.6821   -8491.5776   -8491.5776    324.68422    324.68422    23761.989    23761.989   -817.11627   -817.11627 
Loop time of 144.305 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.599 ns/day, 40.085 hours/ns, 6.930 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.78     | 143.78     | 143.78     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097279   | 0.097279   | 0.097279   |   0.0 |  0.07
Output  | 0.00015406 | 0.00015406 | 0.00015406 |   0.0 |  0.00
Modify  | 0.3663     | 0.3663     | 0.3663     |   0.0 |  0.25
Other   |            | 0.06141    |            |       |  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:      128060.0 ave      128060 max      128060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128060
Ave neighs/atom = 64.030000
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
23757.4451421341

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0