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

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

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

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_492310898779_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8493.9163     -8493.9163     -8579.9993     -8579.9993      333.15         333.15         23173.505      23173.505      3967.7675      3967.7675    
      1000  -8403.7286     -8403.7286     -8489.8359     -8489.8359      333.24453      333.24453      23447.443      23447.443     -2746.5663     -2746.5663    
Loop time of 24.7187 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.495 ns/day, 6.866 hours/ns, 40.455 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.637     | 24.637     | 24.637     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015219   | 0.015219   | 0.015219   |   0.0 |  0.06
Output  | 0.00016847 | 0.00016847 | 0.00016847 |   0.0 |  0.00
Modify  | 0.060263   | 0.060263   | 0.060263   |   0.0 |  0.24
Other   |            | 0.005578   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8403.7286     -8403.7286     -8489.8359     -8489.8359      333.24453      333.24453      23447.443      23447.443     -2746.5663     -2746.5663    
      2000  -8403.715      -8403.715      -8487.6913     -8487.6913      324.99667      324.99667      23387.091      23387.091      1591.3564      1591.3564    
Loop time of 27.4954 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.142 ns/day, 7.638 hours/ns, 36.370 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.416     | 27.416     | 27.416     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014817   | 0.014817   | 0.014817   |   0.0 |  0.05
Output  | 6.421e-05  | 6.421e-05  | 6.421e-05  |   0.0 |  0.00
Modify  | 0.059177   | 0.059177   | 0.059177   |   0.0 |  0.22
Other   |            | 0.005286   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128444 ave      128444 max      128444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128444
Ave neighs/atom = 64.222
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8403.715      -8403.715      -8487.6913     -8487.6913      324.99667      324.99667      23387.091      23387.091      1591.3564      1591.3564    
      3000  -8404.8274     -8404.8274     -8491.7737     -8491.7737      336.4914       336.4914       23411.793      23411.793     -405.02792     -405.02792    
Loop time of 27.644 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.125 ns/day, 7.679 hours/ns, 36.174 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.565     | 27.565     | 27.565     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014792   | 0.014792   | 0.014792   |   0.0 |  0.05
Output  | 6.4732e-05 | 6.4732e-05 | 6.4732e-05 |   0.0 |  0.00
Modify  | 0.059204   | 0.059204   | 0.059204   |   0.0 |  0.21
Other   |            | 0.005165   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4113 ave        4113 max        4113 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128480 ave      128480 max      128480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128480
Ave neighs/atom = 64.24
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8404.8274     -8404.8274     -8491.7737     -8491.7737      336.4914       336.4914       23411.793      23411.793     -405.02792     -405.02792    
      4000  -8403.0026     -8403.0026     -8489.3718     -8489.3718      334.25761      334.25761      23421.335      23421.335     -661.63279     -661.63279    
Loop time of 27.6039 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.130 ns/day, 7.668 hours/ns, 36.227 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.525     | 27.525     | 27.525     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014776   | 0.014776   | 0.014776   |   0.0 |  0.05
Output  | 6.5543e-05 | 6.5543e-05 | 6.5543e-05 |   0.0 |  0.00
Modify  | 0.059158   | 0.059158   | 0.059158   |   0.0 |  0.21
Other   |            | 0.005138   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128340 ave      128340 max      128340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128340
Ave neighs/atom = 64.17
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8403.0026     -8403.0026     -8489.3718     -8489.3718      334.25761      334.25761      23421.335      23421.335     -661.63279     -661.63279    
      5000  -8405.7533     -8405.7533     -8490.7394     -8490.7394      328.90509      328.90509      23388.57       23388.57       1313.6973      1313.6973    
Loop time of 27.636 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.126 ns/day, 7.677 hours/ns, 36.185 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.556     | 27.556     | 27.556     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014816   | 0.014816   | 0.014816   |   0.0 |  0.05
Output  | 4.9503e-05 | 4.9503e-05 | 4.9503e-05 |   0.0 |  0.00
Modify  | 0.059595   | 0.059595   | 0.059595   |   0.0 |  0.22
Other   |            | 0.005155   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128412 ave      128412 max      128412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128412
Ave neighs/atom = 64.206
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.028943441429, Press = -621.658143320643
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8405.7533     -8405.7533     -8490.7394     -8490.7394      328.90509      328.90509      23388.57       23388.57       1313.6973      1313.6973    
      6000  -8403.8841     -8403.8841     -8490.3271     -8490.3271      334.54364      334.54364      23428.241      23428.241     -1415.2546     -1415.2546    
Loop time of 27.7027 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.119 ns/day, 7.695 hours/ns, 36.098 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.621     | 27.621     | 27.621     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014848   | 0.014848   | 0.014848   |   0.0 |  0.05
Output  | 5.1917e-05 | 5.1917e-05 | 5.1917e-05 |   0.0 |  0.00
Modify  | 0.061598   | 0.061598   | 0.061598   |   0.0 |  0.22
Other   |            | 0.005175   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128430 ave      128430 max      128430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128430
Ave neighs/atom = 64.215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.11701546795, Press = -41.3605425392415
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8403.8841     -8403.8841     -8490.3271     -8490.3271      334.54364      334.54364      23428.241      23428.241     -1415.2546     -1415.2546    
      7000  -8401.4557     -8401.4557     -8489.3681     -8489.3681      340.23024      340.23024      23395.857      23395.857      1149.9076      1149.9076    
Loop time of 27.6832 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.121 ns/day, 7.690 hours/ns, 36.123 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.602     | 27.602     | 27.602     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014797   | 0.014797   | 0.014797   |   0.0 |  0.05
Output  | 3.4846e-05 | 3.4846e-05 | 3.4846e-05 |   0.0 |  0.00
Modify  | 0.06154    | 0.06154    | 0.06154    |   0.0 |  0.22
Other   |            | 0.005182   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128440 ave      128440 max      128440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128440
Ave neighs/atom = 64.22
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.79597779069, Press = -13.7745837157323
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8401.4557     -8401.4557     -8489.3681     -8489.3681      340.23024      340.23024      23395.857      23395.857      1149.9076      1149.9076    
      8000  -8404.0355     -8404.0355     -8489.7076     -8489.7076      331.55961      331.55961      23423.18       23423.18      -979.16093     -979.16093    
Loop time of 27.7615 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.112 ns/day, 7.712 hours/ns, 36.021 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.68      | 27.68      | 27.68      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014799   | 0.014799   | 0.014799   |   0.0 |  0.05
Output  | 5.4923e-05 | 5.4923e-05 | 5.4923e-05 |   0.0 |  0.00
Modify  | 0.061562   | 0.061562   | 0.061562   |   0.0 |  0.22
Other   |            | 0.005197   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128392 ave      128392 max      128392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128392
Ave neighs/atom = 64.196
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.428637674364, Press = -19.0000741225045
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8404.0355     -8404.0355     -8489.7076     -8489.7076      331.55961      331.55961      23423.18       23423.18      -979.16093     -979.16093    
      9000  -8407.1706     -8407.1706     -8492.8001     -8492.8001      331.39507      331.39507      23383.044      23383.044      1370.758       1370.758     
Loop time of 27.5761 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.133 ns/day, 7.660 hours/ns, 36.263 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.494     | 27.494     | 27.494     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014857   | 0.014857   | 0.014857   |   0.0 |  0.05
Output  | 3.7811e-05 | 3.7811e-05 | 3.7811e-05 |   0.0 |  0.00
Modify  | 0.061555   | 0.061555   | 0.061555   |   0.0 |  0.22
Other   |            | 0.005188   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128400 ave      128400 max      128400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128400
Ave neighs/atom = 64.2
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.804097489096, Press = -1.52018311920995
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8407.1706     -8407.1706     -8492.8001     -8492.8001      331.39507      331.39507      23383.044      23383.044      1370.758       1370.758     
     10000  -8402.4758     -8402.4758     -8488.7506     -8488.7506      333.89206      333.89206      23432.307      23432.307     -1386.2383     -1386.2383    
Loop time of 27.7026 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.119 ns/day, 7.695 hours/ns, 36.098 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.621     | 27.621     | 27.621     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014801   | 0.014801   | 0.014801   |   0.0 |  0.05
Output  | 5.4002e-05 | 5.4002e-05 | 5.4002e-05 |   0.0 |  0.00
Modify  | 0.061607   | 0.061607   | 0.061607   |   0.0 |  0.22
Other   |            | 0.005197   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128444 ave      128444 max      128444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128444
Ave neighs/atom = 64.222
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.072027187899, Press = -30.2200336375677
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8402.4758     -8402.4758     -8488.7506     -8488.7506      333.89206      333.89206      23432.307      23432.307     -1386.2383     -1386.2383    
     11000  -8401.755      -8401.755      -8487.9112     -8487.9112      333.43312      333.43312      23419.447      23419.447     -484.01445     -484.01445    
Loop time of 27.7857 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.110 ns/day, 7.718 hours/ns, 35.990 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.704     | 27.704     | 27.704     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01478    | 0.01478    | 0.01478    |   0.0 |  0.05
Output  | 3.7139e-05 | 3.7139e-05 | 3.7139e-05 |   0.0 |  0.00
Modify  | 0.061644   | 0.061644   | 0.061644   |   0.0 |  0.22
Other   |            | 0.005174   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128382 ave      128382 max      128382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128382
Ave neighs/atom = 64.191
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.17557392118, Press = 9.08525115821914
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8401.755      -8401.755      -8487.9112     -8487.9112      333.43312      333.43312      23419.447      23419.447     -484.01445     -484.01445    
     12000  -8405.9355     -8405.9355     -8490.3944     -8490.3944      326.86469      326.86469      23390.256      23390.256      1079.9318      1079.9318    
Loop time of 27.7565 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.113 ns/day, 7.710 hours/ns, 36.028 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.675     | 27.675     | 27.675     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014839   | 0.014839   | 0.014839   |   0.0 |  0.05
Output  | 5.4572e-05 | 5.4572e-05 | 5.4572e-05 |   0.0 |  0.00
Modify  | 0.061627   | 0.061627   | 0.061627   |   0.0 |  0.22
Other   |            | 0.005175   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128450 ave      128450 max      128450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128450
Ave neighs/atom = 64.225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.216959739966, Press = -11.3496214301327
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8405.9355     -8405.9355     -8490.3944     -8490.3944      326.86469      326.86469      23390.256      23390.256      1079.9318      1079.9318    
     13000  -8402.0809     -8402.0809     -8490.0107     -8490.0107      340.29744      340.29744      23427.522      23427.522     -1189.5032     -1189.5032    
Loop time of 27.7273 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.116 ns/day, 7.702 hours/ns, 36.065 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.646     | 27.646     | 27.646     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014937   | 0.014937   | 0.014937   |   0.0 |  0.05
Output  | 3.754e-05  | 3.754e-05  | 3.754e-05  |   0.0 |  0.00
Modify  | 0.061592   | 0.061592   | 0.061592   |   0.0 |  0.22
Other   |            | 0.005199   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128432 ave      128432 max      128432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128432
Ave neighs/atom = 64.216
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.578036253688, Press = -3.85789983757859
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8402.0809     -8402.0809     -8490.0107     -8490.0107      340.29744      340.29744      23427.522      23427.522     -1189.5032     -1189.5032    
     14000  -8404.1172     -8404.1172     -8490.4577     -8490.4577      334.14646      334.14646      23382.926      23382.926      1684.8466      1684.8466    
Loop time of 27.675 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.122 ns/day, 7.688 hours/ns, 36.134 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.593     | 27.593     | 27.593     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014905   | 0.014905   | 0.014905   |   0.0 |  0.05
Output  | 8.8957e-05 | 8.8957e-05 | 8.8957e-05 |   0.0 |  0.00
Modify  | 0.061609   | 0.061609   | 0.061609   |   0.0 |  0.22
Other   |            | 0.005202   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128380 ave      128380 max      128380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128380
Ave neighs/atom = 64.19
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.655907635846, Press = -3.65342135459393
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8404.1172     -8404.1172     -8490.4577     -8490.4577      334.14646      334.14646      23382.926      23382.926      1684.8466      1684.8466    
     15000  -8405.4384     -8405.4384     -8490.4804     -8490.4804      329.12159      329.12159      23433.833      23433.833     -1979.6339     -1979.6339    
Loop time of 27.6054 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.130 ns/day, 7.668 hours/ns, 36.225 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.524     | 27.524     | 27.524     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014928   | 0.014928   | 0.014928   |   0.0 |  0.05
Output  | 3.6178e-05 | 3.6178e-05 | 3.6178e-05 |   0.0 |  0.00
Modify  | 0.061634   | 0.061634   | 0.061634   |   0.0 |  0.22
Other   |            | 0.005197   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128432 ave      128432 max      128432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128432
Ave neighs/atom = 64.216
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.90575750918, Press = -6.85938008793946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8405.4384     -8405.4384     -8490.4804     -8490.4804      329.12159      329.12159      23433.833      23433.833     -1979.6339     -1979.6339    
     16000  -8401.7733     -8401.7733     -8488.1417     -8488.1417      334.2546       334.2546       23377.576      23377.576      2392.8264      2392.8264    
Loop time of 27.6668 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.123 ns/day, 7.685 hours/ns, 36.144 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.585     | 27.585     | 27.585     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014961   | 0.014961   | 0.014961   |   0.0 |  0.05
Output  | 4.9473e-05 | 4.9473e-05 | 4.9473e-05 |   0.0 |  0.00
Modify  | 0.061672   | 0.061672   | 0.061672   |   0.0 |  0.22
Other   |            | 0.005181   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128388 ave      128388 max      128388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128388
Ave neighs/atom = 64.194
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.870136437793, Press = 2.73768716898039
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8401.7733     -8401.7733     -8488.1417     -8488.1417      334.2546       334.2546       23377.576      23377.576      2392.8264      2392.8264    
     17000  -8405.3861     -8405.3861     -8492.6272     -8492.6272      337.63206      337.63206      23426.353      23426.353     -1543.0111     -1543.0111    
Loop time of 27.8536 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.102 ns/day, 7.737 hours/ns, 35.902 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.772     | 27.772     | 27.772     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014839   | 0.014839   | 0.014839   |   0.0 |  0.05
Output  | 3.737e-05  | 3.737e-05  | 3.737e-05  |   0.0 |  0.00
Modify  | 0.061791   | 0.061791   | 0.061791   |   0.0 |  0.22
Other   |            | 0.005183   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128456 ave      128456 max      128456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128456
Ave neighs/atom = 64.228
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.001887266015, Press = -12.0014876876975
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8405.3861     -8405.3861     -8492.6272     -8492.6272      337.63206      337.63206      23426.353      23426.353     -1543.0111     -1543.0111    
     18000  -8401.9313     -8401.9313     -8492.4223     -8492.4223      350.20932      350.20932      23415.125      23415.125     -641.71814     -641.71814    
Loop time of 27.7651 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.112 ns/day, 7.713 hours/ns, 36.016 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.683     | 27.683     | 27.683     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014918   | 0.014918   | 0.014918   |   0.0 |  0.05
Output  | 3.8202e-05 | 3.8202e-05 | 3.8202e-05 |   0.0 |  0.00
Modify  | 0.061812   | 0.061812   | 0.061812   |   0.0 |  0.22
Other   |            | 0.0052     |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128364 ave      128364 max      128364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128364
Ave neighs/atom = 64.182
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.829231477811, Press = 2.28023425036644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8401.9313     -8401.9313     -8492.4223     -8492.4223      350.20932      350.20932      23415.125      23415.125     -641.71814     -641.71814    
     19000  -8407.0811     -8407.0811     -8492.585      -8492.585       330.90902      330.90902      23404.173      23404.173     -131.0639      -131.0639     
Loop time of 27.7008 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.119 ns/day, 7.695 hours/ns, 36.100 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.619     | 27.619     | 27.619     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014864   | 0.014864   | 0.014864   |   0.0 |  0.05
Output  | 6.0142e-05 | 6.0142e-05 | 6.0142e-05 |   0.0 |  0.00
Modify  | 0.061716   | 0.061716   | 0.061716   |   0.0 |  0.22
Other   |            | 0.005174   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128350 ave      128350 max      128350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128350
Ave neighs/atom = 64.175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.698207891805, Press = -3.58787903077267
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8407.0811     -8407.0811     -8492.585      -8492.585       330.90902      330.90902      23404.173      23404.173     -131.0639      -131.0639     
     20000  -8405.4333     -8405.4333     -8490.6787     -8490.6787      329.90843      329.90843      23405.255      23405.255      110.43222      110.43222    
Loop time of 27.7893 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.109 ns/day, 7.719 hours/ns, 35.985 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.708     | 27.708     | 27.708     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014783   | 0.014783   | 0.014783   |   0.0 |  0.05
Output  | 3.8262e-05 | 3.8262e-05 | 3.8262e-05 |   0.0 |  0.00
Modify  | 0.061577   | 0.061577   | 0.061577   |   0.0 |  0.22
Other   |            | 0.00517    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128384 ave      128384 max      128384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128384
Ave neighs/atom = 64.192
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.776829845533, Press = -0.639206459229498
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8405.4333     -8405.4333     -8490.6787     -8490.6787      329.90843      329.90843      23405.255      23405.255      110.43222      110.43222    
     21000  -8403.8213     -8403.8213     -8488.8374     -8488.8374      329.02141      329.02141      23393.239      23393.239      1166.0464      1166.0464    
Loop time of 27.6792 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.121 ns/day, 7.689 hours/ns, 36.128 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.597     | 27.597     | 27.597     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014864   | 0.014864   | 0.014864   |   0.0 |  0.05
Output  | 5.5393e-05 | 5.5393e-05 | 5.5393e-05 |   0.0 |  0.00
Modify  | 0.061652   | 0.061652   | 0.061652   |   0.0 |  0.22
Other   |            | 0.005174   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128434 ave      128434 max      128434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128434
Ave neighs/atom = 64.217
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.850675486908, Press = -5.65984350589613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8403.8213     -8403.8213     -8488.8374     -8488.8374      329.02141      329.02141      23393.239      23393.239      1166.0464      1166.0464    
     22000  -8410.7092     -8410.7092     -8493.3408     -8493.3408      319.7925       319.7925       23432.968      23432.968     -2263.4792     -2263.4792    
Loop time of 27.6792 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.121 ns/day, 7.689 hours/ns, 36.128 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.598     | 27.598     | 27.598     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0148     | 0.0148     | 0.0148     |   0.0 |  0.05
Output  | 3.725e-05  | 3.725e-05  | 3.725e-05  |   0.0 |  0.00
Modify  | 0.061641   | 0.061641   | 0.061641   |   0.0 |  0.22
Other   |            | 0.005173   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128464 ave      128464 max      128464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128464
Ave neighs/atom = 64.232
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.792218530876, Press = 0.0613731351536963
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8410.7092     -8410.7092     -8493.3408     -8493.3408      319.7925       319.7925       23432.968      23432.968     -2263.4792     -2263.4792    
     23000  -8403.4683     -8403.4683     -8489.7914     -8489.7914      334.07922      334.07922      23354.429      23354.429      3818.5869      3818.5869    
Loop time of 27.762 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.112 ns/day, 7.712 hours/ns, 36.020 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.68      | 27.68      | 27.68      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014894   | 0.014894   | 0.014894   |   0.0 |  0.05
Output  | 5.2929e-05 | 5.2929e-05 | 5.2929e-05 |   0.0 |  0.00
Modify  | 0.061783   | 0.061783   | 0.061783   |   0.0 |  0.22
Other   |            | 0.005198   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128322 ave      128322 max      128322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128322
Ave neighs/atom = 64.161
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.623103916872, Press = -2.17921136102398
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8403.4683     -8403.4683     -8489.7914     -8489.7914      334.07922      334.07922      23354.429      23354.429      3818.5869      3818.5869    
     24000  -8409.4102     -8409.4102     -8492.1894     -8492.1894      320.36394      320.36394      23428.154      23428.154     -1877.2701     -1877.2701    
Loop time of 27.7373 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.115 ns/day, 7.705 hours/ns, 36.053 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.655     | 27.655     | 27.655     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015008   | 0.015008   | 0.015008   |   0.0 |  0.05
Output  | 3.739e-05  | 3.739e-05  | 3.739e-05  |   0.0 |  0.00
Modify  | 0.061714   | 0.061714   | 0.061714   |   0.0 |  0.22
Other   |            | 0.005199   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128458 ave      128458 max      128458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128458
Ave neighs/atom = 64.229
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.482248779002, Press = -3.79151078576102
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8409.4102     -8409.4102     -8492.1894     -8492.1894      320.36394      320.36394      23428.154      23428.154     -1877.2701     -1877.2701    
     25000  -8402.2782     -8402.2782     -8490.7209     -8490.7209      342.28228      342.28228      23399.035      23399.035      554.07496      554.07496    
Loop time of 27.8037 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.108 ns/day, 7.723 hours/ns, 35.966 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.722     | 27.722     | 27.722     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014901   | 0.014901   | 0.014901   |   0.0 |  0.05
Output  | 5.6235e-05 | 5.6235e-05 | 5.6235e-05 |   0.0 |  0.00
Modify  | 0.061644   | 0.061644   | 0.061644   |   0.0 |  0.22
Other   |            | 0.00519    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128360 ave      128360 max      128360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128360
Ave neighs/atom = 64.18
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.377981505846, Press = -1.45802045764905
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8402.2782     -8402.2782     -8490.7209     -8490.7209      342.28228      342.28228      23399.035      23399.035      554.07496      554.07496    
     26000  -8405.4534     -8405.4534     -8490.4303     -8490.4303      328.86949      328.86949      23420.257      23420.257     -934.57567     -934.57567    
Loop time of 27.7812 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.110 ns/day, 7.717 hours/ns, 35.996 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.699     | 27.699     | 27.699     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014876   | 0.014876   | 0.014876   |   0.0 |  0.05
Output  | 4.3241e-05 | 4.3241e-05 | 4.3241e-05 |   0.0 |  0.00
Modify  | 0.061697   | 0.061697   | 0.061697   |   0.0 |  0.22
Other   |            | 0.00516    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128384 ave      128384 max      128384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128384
Ave neighs/atom = 64.192
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.357421072846, Press = -2.94503151290118
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8405.4534     -8405.4534     -8490.4303     -8490.4303      328.86949      328.86949      23420.257      23420.257     -934.57567     -934.57567    
     27000  -8403.6977     -8403.6977     -8489.6777     -8489.6777      332.75128      332.75128      23398.042      23398.042      900.82998      900.82998    
Loop time of 27.7596 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.112 ns/day, 7.711 hours/ns, 36.024 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.678     | 27.678     | 27.678     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014858   | 0.014858   | 0.014858   |   0.0 |  0.05
Output  | 5.5023e-05 | 5.5023e-05 | 5.5023e-05 |   0.0 |  0.00
Modify  | 0.061644   | 0.061644   | 0.061644   |   0.0 |  0.22
Other   |            | 0.005181   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128402 ave      128402 max      128402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128402
Ave neighs/atom = 64.201
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.332088404463, Press = -0.677878654997162
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8403.6977     -8403.6977     -8489.6777     -8489.6777      332.75128      332.75128      23398.042      23398.042      900.82998      900.82998    
     28000  -8404.765      -8404.765      -8489.9103     -8489.9103      329.52099      329.52099      23413.636      23413.636     -479.39723     -479.39723    
Loop time of 27.7314 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.116 ns/day, 7.703 hours/ns, 36.060 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.65      | 27.65      | 27.65      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014865   | 0.014865   | 0.014865   |   0.0 |  0.05
Output  | 3.6378e-05 | 3.6378e-05 | 3.6378e-05 |   0.0 |  0.00
Modify  | 0.061667   | 0.061667   | 0.061667   |   0.0 |  0.22
Other   |            | 0.005198   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128448 ave      128448 max      128448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128448
Ave neighs/atom = 64.224
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.318977551018, Press = -5.22793846200233
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8404.765      -8404.765      -8489.9103     -8489.9103      329.52099      329.52099      23413.636      23413.636     -479.39723     -479.39723    
     29000  -8406.0437     -8406.0437     -8492.4028     -8492.4028      334.21836      334.21836      23412.81       23412.81      -741.48887     -741.48887    
Loop time of 27.7872 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.109 ns/day, 7.719 hours/ns, 35.988 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.705     | 27.705     | 27.705     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015095   | 0.015095   | 0.015095   |   0.0 |  0.05
Output  | 4.3842e-05 | 4.3842e-05 | 4.3842e-05 |   0.0 |  0.00
Modify  | 0.061895   | 0.061895   | 0.061895   |   0.0 |  0.22
Other   |            | 0.005325   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128418 ave      128418 max      128418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128418
Ave neighs/atom = 64.209
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.350952009141, Press = 1.91257083263507
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8406.0437     -8406.0437     -8492.4028     -8492.4028      334.21836      334.21836      23412.81       23412.81      -741.48887     -741.48887    
     30000  -8407.804      -8407.804      -8492.8723     -8492.8723      329.22294      329.22294      23380.1        23380.1        1636.5288      1636.5288    
Loop time of 27.8232 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.105 ns/day, 7.729 hours/ns, 35.941 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.74      | 27.74      | 27.74      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015221   | 0.015221   | 0.015221   |   0.0 |  0.05
Output  | 0.00023767 | 0.00023767 | 0.00023767 |   0.0 |  0.00
Modify  | 0.062166   | 0.062166   | 0.062166   |   0.0 |  0.22
Other   |            | 0.005472   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128352 ave      128352 max      128352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128352
Ave neighs/atom = 64.176
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.291336958038, Press = -4.62007686051259
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8407.804      -8407.804      -8492.8723     -8492.8723      329.22294      329.22294      23380.1        23380.1        1636.5288      1636.5288    
     31000  -8402.9416     -8402.9416     -8489.0561     -8489.0561      333.27216      333.27216      23435.752      23435.752     -1714.898      -1714.898     
Loop time of 27.8849 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.098 ns/day, 7.746 hours/ns, 35.862 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.8       | 27.8       | 27.8       |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015788   | 0.015788   | 0.015788   |   0.0 |  0.06
Output  | 6.1846e-05 | 6.1846e-05 | 6.1846e-05 |   0.0 |  0.00
Modify  | 0.063036   | 0.063036   | 0.063036   |   0.0 |  0.23
Other   |            | 0.005582   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128392 ave      128392 max      128392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128392
Ave neighs/atom = 64.196
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.201697273864, Press = -0.520924197410696
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8402.9416     -8402.9416     -8489.0561     -8489.0561      333.27216      333.27216      23435.752      23435.752     -1714.898      -1714.898     
     32000  -8404.3593     -8404.3593     -8491.7279     -8491.7279      338.1256       338.1256       23388.077      23388.077      1125.7066      1125.7066    
Loop time of 27.8881 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.098 ns/day, 7.747 hours/ns, 35.858 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.804     | 27.804     | 27.804     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015503   | 0.015503   | 0.015503   |   0.0 |  0.06
Output  | 9.7163e-05 | 9.7163e-05 | 9.7163e-05 |   0.0 |  0.00
Modify  | 0.062558   | 0.062558   | 0.062558   |   0.0 |  0.22
Other   |            | 0.005556   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128404 ave      128404 max      128404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128404
Ave neighs/atom = 64.202
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.192181342454, Press = -1.25934591121926
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8404.3593     -8404.3593     -8491.7279     -8491.7279      338.1256       338.1256       23388.077      23388.077      1125.7066      1125.7066    
     33000  -8402.212      -8402.212      -8490.168      -8490.168       340.39905      340.39905      23418.387      23418.387     -583.96523     -583.96523    
Loop time of 27.7419 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.114 ns/day, 7.706 hours/ns, 36.047 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.659     | 27.659     | 27.659     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015263   | 0.015263   | 0.015263   |   0.0 |  0.06
Output  | 5.0134e-05 | 5.0134e-05 | 5.0134e-05 |   0.0 |  0.00
Modify  | 0.062172   | 0.062172   | 0.062172   |   0.0 |  0.22
Other   |            | 0.005516   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128404 ave      128404 max      128404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128404
Ave neighs/atom = 64.202
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.297117840606, Press = -2.37252603125615
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8402.212      -8402.212      -8490.168      -8490.168       340.39905      340.39905      23418.387      23418.387     -583.96523     -583.96523    
     34000  -8402.7198     -8402.7198     -8491.8207     -8491.8207      344.82982      344.82982      23413.703      23413.703     -364.11717     -364.11717    
Loop time of 27.7405 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.115 ns/day, 7.706 hours/ns, 36.048 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.658     | 27.658     | 27.658     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014966   | 0.014966   | 0.014966   |   0.0 |  0.05
Output  | 5.6706e-05 | 5.6706e-05 | 5.6706e-05 |   0.0 |  0.00
Modify  | 0.06195    | 0.06195    | 0.06195    |   0.0 |  0.22
Other   |            | 0.005431   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128426 ave      128426 max      128426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128426
Ave neighs/atom = 64.213
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.270558835348, Press = -1.6583966694599
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8402.7198     -8402.7198     -8491.8207     -8491.8207      344.82982      344.82982      23413.703      23413.703     -364.11717     -364.11717    
     35000  -8406.5149     -8406.5149     -8489.4315     -8489.4315      320.89557      320.89557      23399.954      23399.954      621.56391      621.56391    
Loop time of 27.8147 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.106 ns/day, 7.726 hours/ns, 35.952 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.732     | 27.732     | 27.732     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014992   | 0.014992   | 0.014992   |   0.0 |  0.05
Output  | 5.9863e-05 | 5.9863e-05 | 5.9863e-05 |   0.0 |  0.00
Modify  | 0.061903   | 0.061903   | 0.061903   |   0.0 |  0.22
Other   |            | 0.005454   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128468 ave      128468 max      128468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128468
Ave neighs/atom = 64.234
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.294507437153, Press = -1.36650369849239
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8406.5149     -8406.5149     -8489.4315     -8489.4315      320.89557      320.89557      23399.954      23399.954      621.56391      621.56391    
     36000  -8401.2374     -8401.2374     -8487.0101     -8487.0101      331.94917      331.94917      23414.1        23414.1        176.10624      176.10624    
Loop time of 27.8392 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.104 ns/day, 7.733 hours/ns, 35.921 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.757     | 27.757     | 27.757     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014998   | 0.014998   | 0.014998   |   0.0 |  0.05
Output  | 3.9975e-05 | 3.9975e-05 | 3.9975e-05 |   0.0 |  0.00
Modify  | 0.061778   | 0.061778   | 0.061778   |   0.0 |  0.22
Other   |            | 0.005412   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128430 ave      128430 max      128430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128430
Ave neighs/atom = 64.215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.375798700916, Press = -2.70868452826809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8401.2374     -8401.2374     -8487.0101     -8487.0101      331.94917      331.94917      23414.1        23414.1        176.10624      176.10624    
     37000  -8404.448      -8404.448      -8489.4376     -8489.4376      328.91817      328.91817      23416.585      23416.585     -509.36847     -509.36847    
Loop time of 27.7535 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.113 ns/day, 7.709 hours/ns, 36.031 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.671     | 27.671     | 27.671     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01504    | 0.01504    | 0.01504    |   0.0 |  0.05
Output  | 6.7627e-05 | 6.7627e-05 | 6.7627e-05 |   0.0 |  0.00
Modify  | 0.061864   | 0.061864   | 0.061864   |   0.0 |  0.22
Other   |            | 0.005444   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128422 ave      128422 max      128422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128422
Ave neighs/atom = 64.211
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.3912315021, Press = 0.257845676184695
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8404.448      -8404.448      -8489.4376     -8489.4376      328.91817      328.91817      23416.585      23416.585     -509.36847     -509.36847    
     38000  -8400.7624     -8400.7624     -8490.4165     -8490.4165      346.97055      346.97055      23389.298      23389.298      1473.3053      1473.3053    
Loop time of 27.8183 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.106 ns/day, 7.727 hours/ns, 35.948 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.736     | 27.736     | 27.736     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015009   | 0.015009   | 0.015009   |   0.0 |  0.05
Output  | 3.8352e-05 | 3.8352e-05 | 3.8352e-05 |   0.0 |  0.00
Modify  | 0.061861   | 0.061861   | 0.061861   |   0.0 |  0.22
Other   |            | 0.005454   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128438 ave      128438 max      128438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128438
Ave neighs/atom = 64.219
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.488946942078, Press = -3.47432501894141
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8400.7624     -8400.7624     -8490.4165     -8490.4165      346.97055      346.97055      23389.298      23389.298      1473.3053      1473.3053    
     39000  -8403.0927     -8403.0927     -8490.02       -8490.02        336.41783      336.41783      23447.621      23447.621     -2571.2077     -2571.2077    
Loop time of 27.7604 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.112 ns/day, 7.711 hours/ns, 36.023 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.678     | 27.678     | 27.678     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015001   | 0.015001   | 0.015001   |   0.0 |  0.05
Output  | 5.873e-05  | 5.873e-05  | 5.873e-05  |   0.0 |  0.00
Modify  | 0.061881   | 0.061881   | 0.061881   |   0.0 |  0.22
Other   |            | 0.005442   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128440 ave      128440 max      128440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128440
Ave neighs/atom = 64.22
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.45419128979, Press = -1.19764715422058
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8403.0927     -8403.0927     -8490.02       -8490.02        336.41783      336.41783      23447.621      23447.621     -2571.2077     -2571.2077    
     40000  -8405.0858     -8405.0858     -8493.9914     -8493.9914      344.07356      344.07356      23377.503      23377.503      1726.1478      1726.1478    
Loop time of 27.7381 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.115 ns/day, 7.705 hours/ns, 36.051 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.656     | 27.656     | 27.656     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015002   | 0.015002   | 0.015002   |   0.0 |  0.05
Output  | 3.704e-05  | 3.704e-05  | 3.704e-05  |   0.0 |  0.00
Modify  | 0.061827   | 0.061827   | 0.061827   |   0.0 |  0.22
Other   |            | 0.005423   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128360 ave      128360 max      128360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128360
Ave neighs/atom = 64.18
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.390053791144, Press = -1.30096658394586
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8405.0858     -8405.0858     -8493.9914     -8493.9914      344.07356      344.07356      23377.503      23377.503      1726.1478      1726.1478    
     41000  -8402.1316     -8402.1316     -8488.3488     -8488.3488      333.66951      333.66951      23439.759      23439.759     -1881.916      -1881.916     
Loop time of 27.8818 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.099 ns/day, 7.745 hours/ns, 35.866 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.799     | 27.799     | 27.799     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015179   | 0.015179   | 0.015179   |   0.0 |  0.05
Output  | 4.8902e-05 | 4.8902e-05 | 4.8902e-05 |   0.0 |  0.00
Modify  | 0.062125   | 0.062125   | 0.062125   |   0.0 |  0.22
Other   |            | 0.005485   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128392 ave      128392 max      128392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128392
Ave neighs/atom = 64.196
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.321479961377, Press = -2.17348781386812
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8402.1316     -8402.1316     -8488.3488     -8488.3488      333.66951      333.66951      23439.759      23439.759     -1881.916      -1881.916     
     42000  -8407.9011     -8407.9011     -8492.2861     -8492.2861      326.57864      326.57864      23369.901      23369.901      2345.6162      2345.6162    
Loop time of 27.8496 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.102 ns/day, 7.736 hours/ns, 35.907 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.766     | 27.766     | 27.766     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015493   | 0.015493   | 0.015493   |   0.0 |  0.06
Output  | 5.6125e-05 | 5.6125e-05 | 5.6125e-05 |   0.0 |  0.00
Modify  | 0.062502   | 0.062502   | 0.062502   |   0.0 |  0.22
Other   |            | 0.005552   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128418 ave      128418 max      128418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128418
Ave neighs/atom = 64.209
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.295257052783, Press = 0.600333715192591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8407.9011     -8407.9011     -8492.2861     -8492.2861      326.57864      326.57864      23369.901      23369.901      2345.6162      2345.6162    
     43000  -8403.4619     -8403.4619     -8489.3924     -8489.3924      332.55988      332.55988      23423.931      23423.931     -946.85625     -946.85625    
Loop time of 27.6952 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.120 ns/day, 7.693 hours/ns, 36.107 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.612     | 27.612     | 27.612     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01553    | 0.01553    | 0.01553    |   0.0 |  0.06
Output  | 8.9799e-05 | 8.9799e-05 | 8.9799e-05 |   0.0 |  0.00
Modify  | 0.062464   | 0.062464   | 0.062464   |   0.0 |  0.23
Other   |            | 0.005516   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128362 ave      128362 max      128362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128362
Ave neighs/atom = 64.181
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.220280458159, Press = -3.65762927816695
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8403.4619     -8403.4619     -8489.3924     -8489.3924      332.55988      332.55988      23423.931      23423.931     -946.85625     -946.85625    
     44000  -8406.224      -8406.224      -8490.6473     -8490.6473      326.72689      326.72689      23407.555      23407.555     -130.16831     -130.16831    
Loop time of 27.7549 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.113 ns/day, 7.710 hours/ns, 36.030 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 27.671     | 27.671     | 27.671     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015699   | 0.015699   | 0.015699   |   0.0 |  0.06
Output  | 0.00015594 | 0.00015594 | 0.00015594 |   0.0 |  0.00
Modify  | 0.062491   | 0.062491   | 0.062491   |   0.0 |  0.23
Other   |            | 0.005569   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128410 ave      128410 max      128410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0