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

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

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

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

kim_interactions Pt

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

kim interactions Pt
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtNi__MO_020840179467_002
pair_coeff * * Pt
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 195.078

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_020840179467_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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17658.806     -17658.806     -17800         -17800          273.15         273.15         43665.964      43665.964      3453.6827      3453.6827    
      1000  -17503.656     -17503.656     -17654.442     -17654.442      291.70439      291.70439      44136.493      44136.493      1508.3304      1508.3304    
Loop time of 489.306 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.918 hours/ns, 2.044 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 488.23     | 488.23     | 488.23     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16261    | 0.16261    | 0.16261    |   0.0 |  0.03
Output  | 0.00023858 | 0.00023858 | 0.00023858 |   0.0 |  0.00
Modify  | 0.80927    | 0.80927    | 0.80927    |   0.0 |  0.17
Other   |            | 0.109      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       344000 ave      344000 max      344000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 344000
Ave neighs/atom = 86
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17503.656     -17503.656     -17654.442     -17654.442      291.70439      291.70439      44136.493      44136.493      1508.3304      1508.3304    
      2000  -17513.865     -17513.865     -17659.591     -17659.591      281.91609      281.91609      44157.825      44157.825     -1069.4208     -1069.4208    
Loop time of 454.117 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.144 hours/ns, 2.202 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 453.2      | 453.2      | 453.2      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14264    | 0.14264    | 0.14264    |   0.0 |  0.03
Output  | 0.000271   | 0.000271   | 0.000271   |   0.0 |  0.00
Modify  | 0.67125    | 0.67125    | 0.67125    |   0.0 |  0.15
Other   |            | 0.09864    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361670 ave      361670 max      361670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361670
Ave neighs/atom = 90.4175
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17513.865     -17513.865     -17659.591     -17659.591      281.91609      281.91609      44157.825      44157.825     -1069.4208     -1069.4208    
      3000  -17517.744     -17517.744     -17655.668     -17655.668      266.82468      266.82468      44162.221      44162.221     -774.3976      -774.3976     
Loop time of 460 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.778 hours/ns, 2.174 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 459.08     | 459.08     | 459.08     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14523    | 0.14523    | 0.14523    |   0.0 |  0.03
Output  | 0.00022902 | 0.00022902 | 0.00022902 |   0.0 |  0.00
Modify  | 0.67959    | 0.67959    | 0.67959    |   0.0 |  0.15
Other   |            | 0.09829    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361008 ave      361008 max      361008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361008
Ave neighs/atom = 90.252
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17517.744     -17517.744     -17655.668     -17655.668      266.82468      266.82468      44162.221      44162.221     -774.3976      -774.3976     
      4000  -17513.569     -17513.569     -17657.248     -17657.248      277.95646      277.95646      44172.593      44172.593     -1592.4464     -1592.4464    
Loop time of 460.69 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.970 hours/ns, 2.171 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 459.77     | 459.77     | 459.77     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14624    | 0.14624    | 0.14624    |   0.0 |  0.03
Output  | 0.00030638 | 0.00030638 | 0.00030638 |   0.0 |  0.00
Modify  | 0.67498    | 0.67498    | 0.67498    |   0.0 |  0.15
Other   |            | 0.0969     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361690 ave      361690 max      361690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361690
Ave neighs/atom = 90.4225
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17513.569     -17513.569     -17657.248     -17657.248      277.95646      277.95646      44172.593      44172.593     -1592.4464     -1592.4464    
      5000  -17516.381     -17516.381     -17654.7       -17654.7        267.58591      267.58591      44163.442      44163.442     -672.81686     -672.81686    
Loop time of 491.383 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.176 ns/day, 136.495 hours/ns, 2.035 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 490.36     | 490.36     | 490.36     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15592    | 0.15592    | 0.15592    |   0.0 |  0.03
Output  | 0.00022388 | 0.00022388 | 0.00022388 |   0.0 |  0.00
Modify  | 0.76057    | 0.76057    | 0.76057    |   0.0 |  0.15
Other   |            | 0.104      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361706 ave      361706 max      361706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361706
Ave neighs/atom = 90.4265
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 = 274.492321280036, Press = -229.486364779685
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17516.381     -17516.381     -17654.7       -17654.7        267.58591      267.58591      44163.442      44163.442     -672.81686     -672.81686    
      6000  -17511.731     -17511.731     -17652.279     -17652.279      271.9003       271.9003       44151.922      44151.922      717.56228      717.56228    
Loop time of 478.831 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.009 hours/ns, 2.088 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 477.83     | 477.83     | 477.83     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15013    | 0.15013    | 0.15013    |   0.0 |  0.03
Output  | 0.00024613 | 0.00024613 | 0.00024613 |   0.0 |  0.00
Modify  | 0.74693    | 0.74693    | 0.74693    |   0.0 |  0.16
Other   |            | 0.1006     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361842 ave      361842 max      361842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361842
Ave neighs/atom = 90.4605
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 = 272.95666591648, Press = 36.9329098006552
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17511.731     -17511.731     -17652.279     -17652.279      271.9003       271.9003       44151.922      44151.922      717.56228      717.56228    
      7000  -17517.685     -17517.685     -17656.966     -17656.966      269.44833      269.44833      44189.613      44189.613     -2768.6572     -2768.6572    
Loop time of 467.756 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.932 hours/ns, 2.138 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 466.78     | 466.78     | 466.78     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14952    | 0.14952    | 0.14952    |   0.0 |  0.03
Output  | 0.00019349 | 0.00019349 | 0.00019349 |   0.0 |  0.00
Modify  | 0.72716    | 0.72716    | 0.72716    |   0.0 |  0.16
Other   |            | 0.09907    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       362446 ave      362446 max      362446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362446
Ave neighs/atom = 90.6115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.210775885215, Press = 21.1953904017514
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17517.685     -17517.685     -17656.966     -17656.966      269.44833      269.44833      44189.613      44189.613     -2768.6572     -2768.6572    
      8000  -17509.099     -17509.099     -17652.828     -17652.828      278.05378      278.05378      44153.935      44153.935      631.26753      631.26753    
Loop time of 497.987 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.173 ns/day, 138.330 hours/ns, 2.008 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 496.92     | 496.92     | 496.92     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15824    | 0.15824    | 0.15824    |   0.0 |  0.03
Output  | 0.00019787 | 0.00019787 | 0.00019787 |   0.0 |  0.00
Modify  | 0.80183    | 0.80183    | 0.80183    |   0.0 |  0.16
Other   |            | 0.1054     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       360494 ave      360494 max      360494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 360494
Ave neighs/atom = 90.1235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.229610913808, Press = 5.73587920014109
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17509.099     -17509.099     -17652.828     -17652.828      278.05378      278.05378      44153.935      44153.935      631.26753      631.26753    
      9000  -17517.966     -17517.966     -17656.467     -17656.467      267.93932      267.93932      44155.366      44155.366     -590.72643     -590.72643    
Loop time of 483.698 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.361 hours/ns, 2.067 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 482.68     | 482.68     | 482.68     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15396    | 0.15396    | 0.15396    |   0.0 |  0.03
Output  | 0.00019079 | 0.00019079 | 0.00019079 |   0.0 |  0.00
Modify  | 0.76493    | 0.76493    | 0.76493    |   0.0 |  0.16
Other   |            | 0.1023     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       362286 ave      362286 max      362286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362286
Ave neighs/atom = 90.5715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.090898734777, Press = -7.48187537172525
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17517.966     -17517.966     -17656.467     -17656.467      267.93932      267.93932      44155.366      44155.366     -590.72643     -590.72643    
     10000  -17516.839     -17516.839     -17655.619     -17655.619      268.47896      268.47896      44113.023      44113.023      2714.3998      2714.3998    
Loop time of 446.519 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.033 hours/ns, 2.240 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 445.61     | 445.61     | 445.61     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14349    | 0.14349    | 0.14349    |   0.0 |  0.03
Output  | 0.00019265 | 0.00019265 | 0.00019265 |   0.0 |  0.00
Modify  | 0.67312    | 0.67312    | 0.67312    |   0.0 |  0.15
Other   |            | 0.09587    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       362132 ave      362132 max      362132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362132
Ave neighs/atom = 90.533
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.054430416087, Press = 12.8499393595842
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17516.839     -17516.839     -17655.619     -17655.619      268.47896      268.47896      44113.023      44113.023      2714.3998      2714.3998    
     11000  -17512.695     -17512.695     -17654.277     -17654.277      273.901        273.901        44152.79       44152.79       297.34381      297.34381    
Loop time of 446.316 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.977 hours/ns, 2.241 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 445.4      | 445.4      | 445.4      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1419     | 0.1419     | 0.1419     |   0.0 |  0.03
Output  | 0.0001935  | 0.0001935  | 0.0001935  |   0.0 |  0.00
Modify  | 0.67382    | 0.67382    | 0.67382    |   0.0 |  0.15
Other   |            | 0.09797    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       362596 ave      362596 max      362596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362596
Ave neighs/atom = 90.649
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.208368363208, Press = 7.73849831871887
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17512.695     -17512.695     -17654.277     -17654.277      273.901        273.901        44152.79       44152.79       297.34381      297.34381    
     12000  -17514.656     -17514.656     -17656.503     -17656.503      274.41275      274.41275      44146.341      44146.341      307.7006       307.7006     
Loop time of 447.35 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.264 hours/ns, 2.235 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 446.43     | 446.43     | 446.43     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14355    | 0.14355    | 0.14355    |   0.0 |  0.03
Output  | 0.00019474 | 0.00019474 | 0.00019474 |   0.0 |  0.00
Modify  | 0.6776     | 0.6776     | 0.6776     |   0.0 |  0.15
Other   |            | 0.09706    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       362042 ave      362042 max      362042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362042
Ave neighs/atom = 90.5105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.440841479133, Press = 5.04630366272931
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17514.656     -17514.656     -17656.503     -17656.503      274.41275      274.41275      44146.341      44146.341      307.7006       307.7006     
     13000  -17519.748     -17519.748     -17655.095     -17655.095      261.83736      261.83736      44145.136      44145.136      487.86204      487.86204    
Loop time of 446.512 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.031 hours/ns, 2.240 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 445.6      | 445.6      | 445.6      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14214    | 0.14214    | 0.14214    |   0.0 |  0.03
Output  | 0.00019271 | 0.00019271 | 0.00019271 |   0.0 |  0.00
Modify  | 0.67635    | 0.67635    | 0.67635    |   0.0 |  0.15
Other   |            | 0.09739    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361816 ave      361816 max      361816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361816
Ave neighs/atom = 90.454
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.282104001746, Press = 8.59340426492874
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17519.748     -17519.748     -17655.095     -17655.095      261.83736      261.83736      44145.136      44145.136      487.86204      487.86204    
     14000  -17511.039     -17511.039     -17653.666     -17653.666      275.92232      275.92232      44185.789      44185.789     -1715.1774     -1715.1774    
Loop time of 495.492 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.174 ns/day, 137.637 hours/ns, 2.018 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 494.44     | 494.44     | 494.44     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1559     | 0.1559     | 0.1559     |   0.0 |  0.03
Output  | 0.00019132 | 0.00019132 | 0.00019132 |   0.0 |  0.00
Modify  | 0.7923     | 0.7923     | 0.7923     |   0.0 |  0.16
Other   |            | 0.1052     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361954 ave      361954 max      361954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361954
Ave neighs/atom = 90.4885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.227032718901, Press = 7.35736859790727
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17511.039     -17511.039     -17653.666     -17653.666      275.92232      275.92232      44185.789      44185.789     -1715.1774     -1715.1774    
     15000  -17511.855     -17511.855     -17655.149     -17655.149      277.21312      277.21312      44182.131      44182.131     -1848.918      -1848.918     
Loop time of 508.134 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 141.148 hours/ns, 1.968 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 507.03     | 507.03     | 507.03     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16516    | 0.16516    | 0.16516    |   0.0 |  0.03
Output  | 0.00019356 | 0.00019356 | 0.00019356 |   0.0 |  0.00
Modify  | 0.83444    | 0.83444    | 0.83444    |   0.0 |  0.16
Other   |            | 0.1081     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361394 ave      361394 max      361394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361394
Ave neighs/atom = 90.3485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.243171850693, Press = 9.35370443436374
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17511.855     -17511.855     -17655.149     -17655.149      277.21312      277.21312      44182.131      44182.131     -1848.918      -1848.918     
     16000  -17512.831     -17512.831     -17656.815     -17656.815      278.54767      278.54767      44173.996      44173.996     -1668.1477     -1668.1477    
Loop time of 450.459 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.127 hours/ns, 2.220 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 449.53     | 449.53     | 449.53     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14628    | 0.14628    | 0.14628    |   0.0 |  0.03
Output  | 0.00019458 | 0.00019458 | 0.00019458 |   0.0 |  0.00
Modify  | 0.68928    | 0.68928    | 0.68928    |   0.0 |  0.15
Other   |            | 0.09612    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361464 ave      361464 max      361464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361464
Ave neighs/atom = 90.366
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.374797408322, Press = 2.79479043226877
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17512.831     -17512.831     -17656.815     -17656.815      278.54767      278.54767      44173.996      44173.996     -1668.1477     -1668.1477    
     17000  -17515.556     -17515.556     -17654.332     -17654.332      268.47158      268.47158      44135.763      44135.763      1366.4766      1366.4766    
Loop time of 445.404 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.723 hours/ns, 2.245 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 444.49     | 444.49     | 444.49     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14442    | 0.14442    | 0.14442    |   0.0 |  0.03
Output  | 0.00023368 | 0.00023368 | 0.00023368 |   0.0 |  0.00
Modify  | 0.67373    | 0.67373    | 0.67373    |   0.0 |  0.15
Other   |            | 0.09637    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       360982 ave      360982 max      360982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 360982
Ave neighs/atom = 90.2455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.376790342707, Press = 3.60038908079511
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17515.556     -17515.556     -17654.332     -17654.332      268.47158      268.47158      44135.763      44135.763      1366.4766      1366.4766    
     18000  -17513.246     -17513.246     -17654.114     -17654.114      272.51839      272.51839      44141.182      44141.182      1101.9907      1101.9907    
Loop time of 446.28 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.967 hours/ns, 2.241 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 445.37     | 445.37     | 445.37     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14302    | 0.14302    | 0.14302    |   0.0 |  0.03
Output  | 0.00024171 | 0.00024171 | 0.00024171 |   0.0 |  0.00
Modify  | 0.67224    | 0.67224    | 0.67224    |   0.0 |  0.15
Other   |            | 0.09546    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       362022 ave      362022 max      362022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362022
Ave neighs/atom = 90.5055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.300467673949, Press = 4.55979904160151
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17513.246     -17513.246     -17654.114     -17654.114      272.51839      272.51839      44141.182      44141.182      1101.9907      1101.9907    
     19000  -17513.636     -17513.636     -17656.422     -17656.422      276.2286       276.2286       44126.64       44126.64       1606.0785      1606.0785    
Loop time of 445.264 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.684 hours/ns, 2.246 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 444.35     | 444.35     | 444.35     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14344    | 0.14344    | 0.14344    |   0.0 |  0.03
Output  | 0.00019508 | 0.00019508 | 0.00019508 |   0.0 |  0.00
Modify  | 0.67193    | 0.67193    | 0.67193    |   0.0 |  0.15
Other   |            | 0.09635    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       362222 ave      362222 max      362222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362222
Ave neighs/atom = 90.5555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.228977658848, Press = 6.65115433781244
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17513.636     -17513.636     -17656.422     -17656.422      276.2286       276.2286       44126.64       44126.64       1606.0785      1606.0785    
     20000  -17516.79      -17516.79      -17654.078     -17654.078      265.59292      265.59292      44151.441      44151.441      320.40737      320.40737    
Loop time of 447.281 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.245 hours/ns, 2.236 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 446.36     | 446.36     | 446.36     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14439    | 0.14439    | 0.14439    |   0.0 |  0.03
Output  | 0.00019427 | 0.00019427 | 0.00019427 |   0.0 |  0.00
Modify  | 0.67545    | 0.67545    | 0.67545    |   0.0 |  0.15
Other   |            | 0.09647    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       362466 ave      362466 max      362466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362466
Ave neighs/atom = 90.6165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.231970088158, Press = 5.04292190152658
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17516.79      -17516.79      -17654.078     -17654.078      265.59292      265.59292      44151.441      44151.441      320.40737      320.40737    
     21000  -17513.011     -17513.011     -17655.762     -17655.762      276.16159      276.16159      44142.278      44142.278      673.8231       673.8231     
Loop time of 485.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.762 hours/ns, 2.061 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 484.12     | 484.12     | 484.12     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15477    | 0.15477    | 0.15477    |   0.0 |  0.03
Output  | 0.00025302 | 0.00025302 | 0.00025302 |   0.0 |  0.00
Modify  | 0.77046    | 0.77046    | 0.77046    |   0.0 |  0.16
Other   |            | 0.1029     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361706 ave      361706 max      361706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361706
Ave neighs/atom = 90.4265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.187787660929, Press = 2.32323160706206
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17513.011     -17513.011     -17655.762     -17655.762      276.16159      276.16159      44142.278      44142.278      673.8231       673.8231     
     22000  -17512.631     -17512.631     -17656.453     -17656.453      278.23239      278.23239      44163.001      44163.001     -778.2009      -778.2009     
Loop time of 460.453 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.904 hours/ns, 2.172 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 459.49     | 459.49     | 459.49     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14774    | 0.14774    | 0.14774    |   0.0 |  0.03
Output  | 0.00019614 | 0.00019614 | 0.00019614 |   0.0 |  0.00
Modify  | 0.71169    | 0.71169    | 0.71169    |   0.0 |  0.15
Other   |            | 0.09918    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361778 ave      361778 max      361778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361778
Ave neighs/atom = 90.4445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.296387469024, Press = 2.33359051942997
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17512.631     -17512.631     -17656.453     -17656.453      278.23239      278.23239      44163.001      44163.001     -778.2009      -778.2009     
     23000  -17517.288     -17517.288     -17659.151     -17659.151      274.4442       274.4442       44136.158      44136.158      351.04167      351.04167    
Loop time of 445.798 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.833 hours/ns, 2.243 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 444.88     | 444.88     | 444.88     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14302    | 0.14302    | 0.14302    |   0.0 |  0.03
Output  | 0.00019283 | 0.00019283 | 0.00019283 |   0.0 |  0.00
Modify  | 0.67868    | 0.67868    | 0.67868    |   0.0 |  0.15
Other   |            | 0.09635    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361314 ave      361314 max      361314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361314
Ave neighs/atom = 90.3285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.270435664089, Press = 2.23294753890687
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17517.288     -17517.288     -17659.151     -17659.151      274.4442       274.4442       44136.158      44136.158      351.04167      351.04167    
     24000  -17514.809     -17514.809     -17655.962     -17655.962      273.07126      273.07126      44161.295      44161.295     -697.62305     -697.62305    
Loop time of 461.395 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.165 hours/ns, 2.167 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 460.43     | 460.43     | 460.43     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14602    | 0.14602    | 0.14602    |   0.0 |  0.03
Output  | 0.00024549 | 0.00024549 | 0.00024549 |   0.0 |  0.00
Modify  | 0.7166     | 0.7166     | 0.7166     |   0.0 |  0.16
Other   |            | 0.09988    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361498 ave      361498 max      361498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361498
Ave neighs/atom = 90.3745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.190339903348, Press = 1.87862964156198
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17514.809     -17514.809     -17655.962     -17655.962      273.07126      273.07126      44161.295      44161.295     -697.62305     -697.62305    
     25000  -17517.836     -17517.836     -17657.666     -17657.666      270.5101       270.5101       44156.533      44156.533     -630.03064     -630.03064    
Loop time of 487.458 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.405 hours/ns, 2.051 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 486.42     | 486.42     | 486.42     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15184    | 0.15184    | 0.15184    |   0.0 |  0.03
Output  | 0.00019233 | 0.00019233 | 0.00019233 |   0.0 |  0.00
Modify  | 0.77816    | 0.77816    | 0.77816    |   0.0 |  0.16
Other   |            | 0.1037     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361094 ave      361094 max      361094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361094
Ave neighs/atom = 90.2735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.213464823284, Press = 1.23215383270183
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17517.836     -17517.836     -17657.666     -17657.666      270.5101       270.5101       44156.533      44156.533     -630.03064     -630.03064    
     26000  -17511.424     -17511.424     -17656.58      -17656.58       280.81404      280.81404      44168.291      44168.291     -1186.5319     -1186.5319    
Loop time of 505.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.171 ns/day, 140.347 hours/ns, 1.979 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 504.17     | 504.17     | 504.17     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15829    | 0.15829    | 0.15829    |   0.0 |  0.03
Output  | 0.00019499 | 0.00019499 | 0.00019499 |   0.0 |  0.00
Modify  | 0.81578    | 0.81578    | 0.81578    |   0.0 |  0.16
Other   |            | 0.1066     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361152 ave      361152 max      361152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361152
Ave neighs/atom = 90.288
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.213783031684, Press = 1.19505264438906
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17511.424     -17511.424     -17656.58      -17656.58       280.81404      280.81404      44168.291      44168.291     -1186.5319     -1186.5319    
     27000  -17518.829     -17518.829     -17657.495     -17657.495      268.25857      268.25857      44132.963      44132.963      840.48798      840.48798    
Loop time of 479.085 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.079 hours/ns, 2.087 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 478.08     | 478.08     | 478.08     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15096    | 0.15096    | 0.15096    |   0.0 |  0.03
Output  | 0.00019119 | 0.00019119 | 0.00019119 |   0.0 |  0.00
Modify  | 0.75358    | 0.75358    | 0.75358    |   0.0 |  0.16
Other   |            | 0.1024     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361436 ave      361436 max      361436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361436
Ave neighs/atom = 90.359
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.269080527612, Press = -0.680815345599349
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17518.829     -17518.829     -17657.495     -17657.495      268.25857      268.25857      44132.963      44132.963      840.48798      840.48798    
     28000  -17514.835     -17514.835     -17654.771     -17654.771      270.71651      270.71651      44129.808      44129.808      1745.9217      1745.9217    
Loop time of 496.951 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.174 ns/day, 138.042 hours/ns, 2.012 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 495.89     | 495.89     | 495.89     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15504    | 0.15504    | 0.15504    |   0.0 |  0.03
Output  | 0.00023396 | 0.00023396 | 0.00023396 |   0.0 |  0.00
Modify  | 0.79768    | 0.79768    | 0.79768    |   0.0 |  0.16
Other   |            | 0.1053     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361610 ave      361610 max      361610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361610
Ave neighs/atom = 90.4025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.220937272949, Press = -0.619350989869422
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17514.835     -17514.835     -17654.771     -17654.771      270.71651      270.71651      44129.808      44129.808      1745.9217      1745.9217    
     29000  -17516.084     -17516.084     -17657.762     -17657.762      274.08639      274.08639      44117.688      44117.688      1978.8134      1978.8134    
Loop time of 475.209 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 132.002 hours/ns, 2.104 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 474.21     | 474.21     | 474.21     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14881    | 0.14881    | 0.14881    |   0.0 |  0.03
Output  | 0.0001953  | 0.0001953  | 0.0001953  |   0.0 |  0.00
Modify  | 0.74429    | 0.74429    | 0.74429    |   0.0 |  0.16
Other   |            | 0.1026     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361654 ave      361654 max      361654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361654
Ave neighs/atom = 90.4135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.164866668673, Press = 1.17063409049957
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17516.084     -17516.084     -17657.762     -17657.762      274.08639      274.08639      44117.688      44117.688      1978.8134      1978.8134    
     30000  -17516.938     -17516.938     -17657.372     -17657.372      271.68022      271.68022      44158.9        44158.9       -766.82525     -766.82525    
Loop time of 474.049 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 131.680 hours/ns, 2.109 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 473.05     | 473.05     | 473.05     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15218    | 0.15218    | 0.15218    |   0.0 |  0.03
Output  | 0.00024362 | 0.00024362 | 0.00024362 |   0.0 |  0.00
Modify  | 0.7461     | 0.7461     | 0.7461     |   0.0 |  0.16
Other   |            | 0.1008     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       362012 ave      362012 max      362012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362012
Ave neighs/atom = 90.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.188281928199, Press = 1.33975937063644
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17516.938     -17516.938     -17657.372     -17657.372      271.68022      271.68022      44158.9        44158.9       -766.82525     -766.82525    
     31000  -17516.246     -17516.246     -17657.143     -17657.143      272.57558      272.57558      44148.004      44148.004      58.059711      58.059711    
Loop time of 445.7 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.805 hours/ns, 2.244 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 444.78     | 444.78     | 444.78     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14436    | 0.14436    | 0.14436    |   0.0 |  0.03
Output  | 0.00019335 | 0.00019335 | 0.00019335 |   0.0 |  0.00
Modify  | 0.67753    | 0.67753    | 0.67753    |   0.0 |  0.15
Other   |            | 0.09614    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361064 ave      361064 max      361064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361064
Ave neighs/atom = 90.266
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.153823760992, Press = 1.57654789945457
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17516.246     -17516.246     -17657.143     -17657.143      272.57558      272.57558      44148.004      44148.004      58.059711      58.059711    
     32000  -17513.916     -17513.916     -17655.368     -17655.368      273.64792      273.64792      44166.982      44166.982     -861.35272     -861.35272    
Loop time of 447.551 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.320 hours/ns, 2.234 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 446.63     | 446.63     | 446.63     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14318    | 0.14318    | 0.14318    |   0.0 |  0.03
Output  | 0.00027055 | 0.00027055 | 0.00027055 |   0.0 |  0.00
Modify  | 0.68017    | 0.68017    | 0.68017    |   0.0 |  0.15
Other   |            | 0.0975     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361222 ave      361222 max      361222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361222
Ave neighs/atom = 90.3055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.148633482334, Press = 1.51217571817831
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17513.916     -17513.916     -17655.368     -17655.368      273.64792      273.64792      44166.982      44166.982     -861.35272     -861.35272    
     33000  -17514.712     -17514.712     -17655.703     -17655.703      272.75674      272.75674      44171.255      44171.255     -1190.0572     -1190.0572    
Loop time of 448.905 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.696 hours/ns, 2.228 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 447.98     | 447.98     | 447.98     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14495    | 0.14495    | 0.14495    |   0.0 |  0.03
Output  | 0.00019408 | 0.00019408 | 0.00019408 |   0.0 |  0.00
Modify  | 0.68309    | 0.68309    | 0.68309    |   0.0 |  0.15
Other   |            | 0.09705    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361196 ave      361196 max      361196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361196
Ave neighs/atom = 90.299
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.121996892714, Press = 0.612112798228387
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17514.712     -17514.712     -17655.703     -17655.703      272.75674      272.75674      44171.255      44171.255     -1190.0572     -1190.0572    
     34000  -17516.025     -17516.025     -17655.592     -17655.592      270.00063      270.00063      44177.402      44177.402     -1779.2783     -1779.2783    
Loop time of 449.508 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.863 hours/ns, 2.225 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 448.58     | 448.58     | 448.58     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14449    | 0.14449    | 0.14449    |   0.0 |  0.03
Output  | 0.00021784 | 0.00021784 | 0.00021784 |   0.0 |  0.00
Modify  | 0.68475    | 0.68475    | 0.68475    |   0.0 |  0.15
Other   |            | 0.09715    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361242 ave      361242 max      361242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361242
Ave neighs/atom = 90.3105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.129804283341, Press = -0.785070847815626
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17516.025     -17516.025     -17655.592     -17655.592      270.00063      270.00063      44177.402      44177.402     -1779.2783     -1779.2783    
     35000  -17516.47      -17516.47      -17657.041     -17657.041      271.94294      271.94294      44192.598      44192.598     -2965.2504     -2965.2504    
Loop time of 450.72 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.200 hours/ns, 2.219 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 449.79     | 449.79     | 449.79     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14514    | 0.14514    | 0.14514    |   0.0 |  0.03
Output  | 0.00019435 | 0.00019435 | 0.00019435 |   0.0 |  0.00
Modify  | 0.68712    | 0.68712    | 0.68712    |   0.0 |  0.15
Other   |            | 0.09677    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361256 ave      361256 max      361256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361256
Ave neighs/atom = 90.314
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.077692066278, Press = -1.39737034128213
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17516.47      -17516.47      -17657.041     -17657.041      271.94294      271.94294      44192.598      44192.598     -2965.2504     -2965.2504    
     36000  -17517.094     -17517.094     -17656.761     -17656.761      270.19578      270.19578      44143.803      44143.803      489.36776      489.36776    
Loop time of 450.085 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.024 hours/ns, 2.222 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 449.16     | 449.16     | 449.16     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14451    | 0.14451    | 0.14451    |   0.0 |  0.03
Output  | 0.00019647 | 0.00019647 | 0.00019647 |   0.0 |  0.00
Modify  | 0.68192    | 0.68192    | 0.68192    |   0.0 |  0.15
Other   |            | 0.09752    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       360860 ave      360860 max      360860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 360860
Ave neighs/atom = 90.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 = 273.093287036331, Press = 0.836753836740106
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17517.094     -17517.094     -17656.761     -17656.761      270.19578      270.19578      44143.803      44143.803      489.36776      489.36776    
     37000  -17508.301     -17508.301     -17650.721     -17650.721      275.52026      275.52026      44204.574      44204.574     -2428.74       -2428.74      
Loop time of 449.89 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.970 hours/ns, 2.223 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 448.97     | 448.97     | 448.97     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14382    | 0.14382    | 0.14382    |   0.0 |  0.03
Output  | 0.00019307 | 0.00019307 | 0.00019307 |   0.0 |  0.00
Modify  | 0.68331    | 0.68331    | 0.68331    |   0.0 |  0.15
Other   |            | 0.09771    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361354 ave      361354 max      361354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361354
Ave neighs/atom = 90.3385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.127037720659, Press = -0.37617707116717
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17508.301     -17508.301     -17650.721     -17650.721      275.52026      275.52026      44204.574      44204.574     -2428.74       -2428.74      
     38000  -17517.44      -17517.44      -17658.599     -17658.599      273.08157      273.08157      44157.75       44157.75      -888.90194     -888.90194    
Loop time of 448.318 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.533 hours/ns, 2.231 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 447.4      | 447.4      | 447.4      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14353    | 0.14353    | 0.14353    |   0.0 |  0.03
Output  | 0.00051461 | 0.00051461 | 0.00051461 |   0.0 |  0.00
Modify  | 0.6814     | 0.6814     | 0.6814     |   0.0 |  0.15
Other   |            | 0.09737    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       361160 ave      361160 max      361160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361160
Ave neighs/atom = 90.29
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.145956665969, Press = -0.55248209173304
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17517.44      -17517.44      -17658.599     -17658.599      273.08157      273.08157      44157.75       44157.75      -888.90194     -888.90194    
     39000  -17512.241     -17512.241     -17653.924     -17653.924      274.09498      274.09498      44123.965      44123.965      2215.093       2215.093     
Loop time of 448.246 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.513 hours/ns, 2.231 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 447.32     | 447.32     | 447.32     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14424    | 0.14424    | 0.14424    |   0.0 |  0.03
Output  | 0.000193   | 0.000193   | 0.000193   |   0.0 |  0.00
Modify  | 0.6813     | 0.6813     | 0.6813     |   0.0 |  0.15
Other   |            | 0.09763    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       360924 ave      360924 max      360924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0