# 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.521391771733761*${_u_distance}
variable latticeconst_converted equal 3.521391771733761*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139177173376
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.001 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_ChoiKimSeol_2017_NiMn__MO_348689608050_002
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9622831874 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_348689608050_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 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.962      43665.962      3453.7481      3453.7481    
      1000  -17508.577     -17508.577     -17657.58      -17657.58       288.25501      288.25501      44142.338      44142.338     -1595.3465     -1595.3465    
Loop time of 50.1668 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.722 ns/day, 13.935 hours/ns, 19.934 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.015     | 50.015     | 50.015     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021763   | 0.021763   | 0.021763   |   0.0 |  0.04
Output  | 0.00011248 | 0.00011248 | 0.00011248 |   0.0 |  0.00
Modify  | 0.1194     | 0.1194     | 0.1194     |   0.0 |  0.24
Other   |            | 0.01089    |            |       |  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:       312000 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17508.577     -17508.577     -17657.58      -17657.58       288.25501      288.25501      44142.338      44142.338     -1595.3465     -1595.3465    
      2000  -17517.097     -17517.097     -17655.248     -17655.248      267.26217      267.26217      44092.267      44092.267      513.4542       513.4542     
Loop time of 57.3024 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.508 ns/day, 15.917 hours/ns, 17.451 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.153     | 57.153     | 57.153     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021544   | 0.021544   | 0.021544   |   0.0 |  0.04
Output  | 4.757e-05  | 4.757e-05  | 4.757e-05  |   0.0 |  0.00
Modify  | 0.11744    | 0.11744    | 0.11744    |   0.0 |  0.20
Other   |            | 0.01048    |            |       |  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:       313692 ave      313692 max      313692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313692
Ave neighs/atom = 78.423
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17517.097     -17517.097     -17655.248     -17655.248      267.26217      267.26217      44092.267      44092.267      513.4542       513.4542     
      3000  -17516.726     -17516.726     -17657.17      -17657.17       271.6995       271.6995       44091.073      44091.073      359.78776      359.78776    
Loop time of 57.625 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.499 ns/day, 16.007 hours/ns, 17.354 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.475     | 57.475     | 57.475     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021612   | 0.021612   | 0.021612   |   0.0 |  0.04
Output  | 4.5706e-05 | 4.5706e-05 | 4.5706e-05 |   0.0 |  0.00
Modify  | 0.11746    | 0.11746    | 0.11746    |   0.0 |  0.20
Other   |            | 0.01046    |            |       |  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:       313914 ave      313914 max      313914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313914
Ave neighs/atom = 78.4785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17516.726     -17516.726     -17657.17      -17657.17       271.6995       271.6995       44091.073      44091.073      359.78776      359.78776    
      4000  -17513.956     -17513.956     -17654.336     -17654.336      271.57441      271.57441      44109.023      44109.023     -41.666718     -41.666718    
Loop time of 57.706 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.497 ns/day, 16.029 hours/ns, 17.329 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.556     | 57.556     | 57.556     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021508   | 0.021508   | 0.021508   |   0.0 |  0.04
Output  | 4.5706e-05 | 4.5706e-05 | 4.5706e-05 |   0.0 |  0.00
Modify  | 0.11756    | 0.11756    | 0.11756    |   0.0 |  0.20
Other   |            | 0.01043    |            |       |  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:       313942 ave      313942 max      313942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313942
Ave neighs/atom = 78.4855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17513.956     -17513.956     -17654.336     -17654.336      271.57441      271.57441      44109.023      44109.023     -41.666718     -41.666718    
      5000  -17518.161     -17518.161     -17659.478     -17659.478      273.38583      273.38583      44103.642      44103.642     -295.97794     -295.97794    
Loop time of 57.5779 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.501 ns/day, 15.994 hours/ns, 17.368 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.428     | 57.428     | 57.428     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021592   | 0.021592   | 0.021592   |   0.0 |  0.04
Output  | 3.718e-05  | 3.718e-05  | 3.718e-05  |   0.0 |  0.00
Modify  | 0.11776    | 0.11776    | 0.11776    |   0.0 |  0.20
Other   |            | 0.01041    |            |       |  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:       313854 ave      313854 max      313854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313854
Ave neighs/atom = 78.4635
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 = 270.611134911609, Press = -333.670505993803
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17518.161     -17518.161     -17659.478     -17659.478      273.38583      273.38583      44103.642      44103.642     -295.97794     -295.97794    
      6000  -17512.851     -17512.851     -17654.119     -17654.119      273.29247      273.29247      44060.629      44060.629      2027.4827      2027.4827    
Loop time of 57.5908 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.500 ns/day, 15.997 hours/ns, 17.364 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.438     | 57.438     | 57.438     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021522   | 0.021522   | 0.021522   |   0.0 |  0.04
Output  | 3.8874e-05 | 3.8874e-05 | 3.8874e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.21
Other   |            | 0.01045    |            |       |  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:       313804 ave      313804 max      313804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313804
Ave neighs/atom = 78.451
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.788199705705, Press = 6.19623282414796
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17512.851     -17512.851     -17654.119     -17654.119      273.29247      273.29247      44060.629      44060.629      2027.4827      2027.4827    
      7000  -17518.113     -17518.113     -17657.601     -17657.601      269.84982      269.84982      44152.994      44152.994     -2174.9743     -2174.9743    
Loop time of 57.77 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.496 ns/day, 16.047 hours/ns, 17.310 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.617     | 57.617     | 57.617     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021664   | 0.021664   | 0.021664   |   0.0 |  0.04
Output  | 3.9254e-05 | 3.9254e-05 | 3.9254e-05 |   0.0 |  0.00
Modify  | 0.12134    | 0.12134    | 0.12134    |   0.0 |  0.21
Other   |            | 0.01043    |            |       |  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:       314060 ave      314060 max      314060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314060
Ave neighs/atom = 78.515
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.017667384593, Press = 7.42241090186166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17518.113     -17518.113     -17657.601     -17657.601      269.84982      269.84982      44152.994      44152.994     -2174.9743     -2174.9743    
      8000  -17515.198     -17515.198     -17660.324     -17660.324      280.75567      280.75567      44097.634      44097.634     -104.30283     -104.30283    
Loop time of 57.6611 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.498 ns/day, 16.017 hours/ns, 17.343 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.508     | 57.508     | 57.508     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021535   | 0.021535   | 0.021535   |   0.0 |  0.04
Output  | 4.1369e-05 | 4.1369e-05 | 4.1369e-05 |   0.0 |  0.00
Modify  | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.21
Other   |            | 0.01046    |            |       |  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:       313778 ave      313778 max      313778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313778
Ave neighs/atom = 78.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 = 272.964957701281, Press = -22.1650600016101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17515.198     -17515.198     -17660.324     -17660.324      280.75567      280.75567      44097.634      44097.634     -104.30283     -104.30283    
      9000  -17519.002     -17519.002     -17659.503     -17659.503      271.80965      271.80965      44081.577      44081.577      584.34846      584.34846    
Loop time of 57.6639 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.498 ns/day, 16.018 hours/ns, 17.342 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.511     | 57.511     | 57.511     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021533   | 0.021533   | 0.021533   |   0.0 |  0.04
Output  | 4.764e-05  | 4.764e-05  | 4.764e-05  |   0.0 |  0.00
Modify  | 0.12133    | 0.12133    | 0.12133    |   0.0 |  0.21
Other   |            | 0.01047    |            |       |  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:       313732 ave      313732 max      313732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313732
Ave neighs/atom = 78.433
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.60252484145, Press = 1.6950393509231
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17519.002     -17519.002     -17659.503     -17659.503      271.80965      271.80965      44081.577      44081.577      584.34846      584.34846    
     10000  -17509.556     -17509.556     -17653.353     -17653.353      278.18346      278.18346      44139.015      44139.015     -1088.1274     -1088.1274    
Loop time of 57.769 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.496 ns/day, 16.047 hours/ns, 17.310 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.616     | 57.616     | 57.616     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021537   | 0.021537   | 0.021537   |   0.0 |  0.04
Output  | 3.8282e-05 | 3.8282e-05 | 3.8282e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.21
Other   |            | 0.01047    |            |       |  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:       313794 ave      313794 max      313794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313794
Ave neighs/atom = 78.4485
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.920791485065, Press = -2.82758283104243
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17509.556     -17509.556     -17653.353     -17653.353      278.18346      278.18346      44139.015      44139.015     -1088.1274     -1088.1274    
     11000  -17517.61      -17517.61      -17654.684     -17654.684      265.17788      265.17788      44083.794      44083.794      857.99571      857.99571    
Loop time of 57.8405 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.494 ns/day, 16.067 hours/ns, 17.289 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.687     | 57.687     | 57.687     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021647   | 0.021647   | 0.021647   |   0.0 |  0.04
Output  | 3.675e-05  | 3.675e-05  | 3.675e-05  |   0.0 |  0.00
Modify  | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.21
Other   |            | 0.01043    |            |       |  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:       313740 ave      313740 max      313740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313740
Ave neighs/atom = 78.435
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.111359634252, Press = -5.06887725519628
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17517.61      -17517.61      -17654.684     -17654.684      265.17788      265.17788      44083.794      44083.794      857.99571      857.99571    
     12000  -17519.845     -17519.845     -17660.93      -17660.93       272.93846      272.93846      44077.693      44077.693      626.49229      626.49229    
Loop time of 57.7604 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.496 ns/day, 16.045 hours/ns, 17.313 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.607     | 57.607     | 57.607     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021599   | 0.021599   | 0.021599   |   0.0 |  0.04
Output  | 3.0517e-05 | 3.0517e-05 | 3.0517e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.21
Other   |            | 0.01042    |            |       |  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:       313876 ave      313876 max      313876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313876
Ave neighs/atom = 78.469
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.170098747019, Press = 6.06909955875496
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17519.845     -17519.845     -17660.93      -17660.93       272.93846      272.93846      44077.693      44077.693      626.49229      626.49229    
     13000  -17515.301     -17515.301     -17658.844     -17658.844      277.69308      277.69308      44168.988      44168.988     -2879.6615     -2879.6615    
Loop time of 57.711 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.497 ns/day, 16.031 hours/ns, 17.328 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.558     | 57.558     | 57.558     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021514   | 0.021514   | 0.021514   |   0.0 |  0.04
Output  | 3.8433e-05 | 3.8433e-05 | 3.8433e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.21
Other   |            | 0.01047    |            |       |  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:       313796 ave      313796 max      313796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313796
Ave neighs/atom = 78.449
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.041610150626, Press = -4.17411468862117
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17515.301     -17515.301     -17658.844     -17658.844      277.69308      277.69308      44168.988      44168.988     -2879.6615     -2879.6615    
     14000  -17520.904     -17520.904     -17661.442     -17661.442      271.88057      271.88057      44067.123      44067.123      971.6082       971.6082     
Loop time of 57.6923 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.498 ns/day, 16.026 hours/ns, 17.333 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.539     | 57.539     | 57.539     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021608   | 0.021608   | 0.021608   |   0.0 |  0.04
Output  | 6.9221e-05 | 6.9221e-05 | 6.9221e-05 |   0.0 |  0.00
Modify  | 0.12123    | 0.12123    | 0.12123    |   0.0 |  0.21
Other   |            | 0.01046    |            |       |  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:       313650 ave      313650 max      313650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313650
Ave neighs/atom = 78.4125
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.838291265238, Press = -4.43002956510274
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17520.904     -17520.904     -17661.442     -17661.442      271.88057      271.88057      44067.123      44067.123      971.6082       971.6082     
     15000  -17517.759     -17517.759     -17657.375     -17657.375      270.09652      270.09652      44096.818      44096.818      152.22541      152.22541    
Loop time of 57.7809 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.495 ns/day, 16.050 hours/ns, 17.307 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.627     | 57.627     | 57.627     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022207   | 0.022207   | 0.022207   |   0.0 |  0.04
Output  | 3.7661e-05 | 3.7661e-05 | 3.7661e-05 |   0.0 |  0.00
Modify  | 0.12131    | 0.12131    | 0.12131    |   0.0 |  0.21
Other   |            | 0.01048    |            |       |  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:       313742 ave      313742 max      313742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313742
Ave neighs/atom = 78.4355
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.824892997851, Press = 1.52579094178157
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17517.759     -17517.759     -17657.375     -17657.375      270.09652      270.09652      44096.818      44096.818      152.22541      152.22541    
     16000  -17513.576     -17513.576     -17658.037     -17658.037      279.46965      279.46965      44126.701      44126.701     -1048.8642     -1048.8642    
Loop time of 57.8141 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.494 ns/day, 16.059 hours/ns, 17.297 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.661     | 57.661     | 57.661     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021679   | 0.021679   | 0.021679   |   0.0 |  0.04
Output  | 4.4614e-05 | 4.4614e-05 | 4.4614e-05 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  0.21
Other   |            | 0.0105     |            |       |  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:       313812 ave      313812 max      313812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313812
Ave neighs/atom = 78.453
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.766925441487, Press = -2.13097545558416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17513.576     -17513.576     -17658.037     -17658.037      279.46965      279.46965      44126.701      44126.701     -1048.8642     -1048.8642    
     17000  -17520.542     -17520.542     -17660.34      -17660.34       270.44874      270.44874      44076.785      44076.785      635.25039      635.25039    
Loop time of 57.7822 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.495 ns/day, 16.051 hours/ns, 17.306 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.629     | 57.629     | 57.629     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021584   | 0.021584   | 0.021584   |   0.0 |  0.04
Output  | 5.1377e-05 | 5.1377e-05 | 5.1377e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.21
Other   |            | 0.01044    |            |       |  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:       313638 ave      313638 max      313638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313638
Ave neighs/atom = 78.4095
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.733234043714, Press = -2.64177257803412
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17520.542     -17520.542     -17660.34      -17660.34       270.44874      270.44874      44076.785      44076.785      635.25039      635.25039    
     18000  -17514.995     -17514.995     -17657.592     -17657.592      275.8631       275.8631       44069.63       44069.63       1218.033       1218.033     
Loop time of 57.7711 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.496 ns/day, 16.048 hours/ns, 17.310 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.618     | 57.618     | 57.618     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021565   | 0.021565   | 0.021565   |   0.0 |  0.04
Output  | 3.8583e-05 | 3.8583e-05 | 3.8583e-05 |   0.0 |  0.00
Modify  | 0.12123    | 0.12123    | 0.12123    |   0.0 |  0.21
Other   |            | 0.01045    |            |       |  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:       313840 ave      313840 max      313840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313840
Ave neighs/atom = 78.46
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.664389211289, Press = 3.63875057542859
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17514.995     -17514.995     -17657.592     -17657.592      275.8631       275.8631       44069.63       44069.63       1218.033       1218.033     
     19000  -17518.055     -17518.055     -17658.675     -17658.675      272.04014      272.04014      44151.678      44151.678     -2268.4002     -2268.4002    
Loop time of 57.8537 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.493 ns/day, 16.070 hours/ns, 17.285 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.7       | 57.7       | 57.7       |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021526   | 0.021526   | 0.021526   |   0.0 |  0.04
Output  | 4.3251e-05 | 4.3251e-05 | 4.3251e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.21
Other   |            | 0.01042    |            |       |  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:       313900 ave      313900 max      313900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313900
Ave neighs/atom = 78.475
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.636684323932, Press = -2.12401562849198
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17518.055     -17518.055     -17658.675     -17658.675      272.04014      272.04014      44151.678      44151.678     -2268.4002     -2268.4002    
     20000  -17515.754     -17515.754     -17656.165     -17656.165      271.6346       271.6346       44070.105      44070.105      1390.0305      1390.0305    
Loop time of 57.6468 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.499 ns/day, 16.013 hours/ns, 17.347 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.494     | 57.494     | 57.494     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021395   | 0.021395   | 0.021395   |   0.0 |  0.04
Output  | 3.9815e-05 | 3.9815e-05 | 3.9815e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.21
Other   |            | 0.0103     |            |       |  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:       313618 ave      313618 max      313618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313618
Ave neighs/atom = 78.4045
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.621130078335, Press = -1.87807798565834
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17515.754     -17515.754     -17656.165     -17656.165      271.6346       271.6346       44070.105      44070.105      1390.0305      1390.0305    
     21000  -17518.295     -17518.295     -17661.179     -17661.179      276.41768      276.41768      44102.12       44102.12      -419.43473     -419.43473    
Loop time of 57.8301 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.494 ns/day, 16.064 hours/ns, 17.292 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.677     | 57.677     | 57.677     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021523   | 0.021523   | 0.021523   |   0.0 |  0.04
Output  | 3.8032e-05 | 3.8032e-05 | 3.8032e-05 |   0.0 |  0.00
Modify  | 0.12106    | 0.12106    | 0.12106    |   0.0 |  0.21
Other   |            | 0.01022    |            |       |  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:       313934 ave      313934 max      313934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313934
Ave neighs/atom = 78.4835
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.550437580543, Press = 1.53913316209002
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17518.295     -17518.295     -17661.179     -17661.179      276.41768      276.41768      44102.12       44102.12      -419.43473     -419.43473    
     22000  -17514.59      -17514.59      -17657.135     -17657.135      275.76457      275.76457      44124.444      44124.444     -934.2251      -934.2251     
Loop time of 57.853 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.493 ns/day, 16.070 hours/ns, 17.285 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.7       | 57.7       | 57.7       |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021566   | 0.021566   | 0.021566   |   0.0 |  0.04
Output  | 3.6018e-05 | 3.6018e-05 | 3.6018e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.21
Other   |            | 0.01016    |            |       |  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:       313706 ave      313706 max      313706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313706
Ave neighs/atom = 78.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 = 272.515258545815, Press = -1.80416044666904
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17514.59      -17514.59      -17657.135     -17657.135      275.76457      275.76457      44124.444      44124.444     -934.2251      -934.2251     
     23000  -17520.429     -17520.429     -17660.068     -17660.068      270.14218      270.14218      44079.05       44079.05       563.6219       563.6219     
Loop time of 57.8021 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.495 ns/day, 16.056 hours/ns, 17.300 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.649     | 57.649     | 57.649     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021487   | 0.021487   | 0.021487   |   0.0 |  0.04
Output  | 3.5156e-05 | 3.5156e-05 | 3.5156e-05 |   0.0 |  0.00
Modify  | 0.12116    | 0.12116    | 0.12116    |   0.0 |  0.21
Other   |            | 0.0102     |            |       |  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:       313758 ave      313758 max      313758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313758
Ave neighs/atom = 78.4395
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.472930960562, Press = -0.421520703017907
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17520.429     -17520.429     -17660.068     -17660.068      270.14218      270.14218      44079.05       44079.05       563.6219       563.6219     
     24000  -17518.529     -17518.529     -17659.125     -17659.125      271.99085      271.99085      44103.813      44103.813     -367.93047     -367.93047    
Loop time of 57.8342 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.494 ns/day, 16.065 hours/ns, 17.291 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.681     | 57.681     | 57.681     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021515   | 0.021515   | 0.021515   |   0.0 |  0.04
Output  | 3.8532e-05 | 3.8532e-05 | 3.8532e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.21
Other   |            | 0.0102     |            |       |  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:       313818 ave      313818 max      313818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313818
Ave neighs/atom = 78.4545
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.495197578155, Press = -0.104348760249544
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17518.529     -17518.529     -17659.125     -17659.125      271.99085      271.99085      44103.813      44103.813     -367.93047     -367.93047    
     25000  -17513.99      -17513.99      -17655.329     -17655.329      273.43068      273.43068      44114.951      44114.951     -411.98556     -411.98556    
Loop time of 57.9057 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.492 ns/day, 16.085 hours/ns, 17.269 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.753     | 57.753     | 57.753     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021636   | 0.021636   | 0.021636   |   0.0 |  0.04
Output  | 3.5757e-05 | 3.5757e-05 | 3.5757e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.21
Other   |            | 0.0102     |            |       |  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:       313794 ave      313794 max      313794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313794
Ave neighs/atom = 78.4485
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.583472839443, Press = -0.813216526087913
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17513.99      -17513.99      -17655.329     -17655.329      273.43068      273.43068      44114.951      44114.951     -411.98556     -411.98556    
     26000  -17516.183     -17516.183     -17654.974     -17654.974      268.50024      268.50024      44085.566      44085.566      820.85892      820.85892    
Loop time of 57.8555 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.493 ns/day, 16.071 hours/ns, 17.284 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.703     | 57.703     | 57.703     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02146    | 0.02146    | 0.02146    |   0.0 |  0.04
Output  | 3.6669e-05 | 3.6669e-05 | 3.6669e-05 |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.21
Other   |            | 0.01017    |            |       |  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:       313810 ave      313810 max      313810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313810
Ave neighs/atom = 78.4525
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.645346597289, Press = -1.42048948233076
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17516.183     -17516.183     -17654.974     -17654.974      268.50024      268.50024      44085.566      44085.566      820.85892      820.85892    
     27000  -17517.616     -17517.616     -17659.393     -17659.393      274.27658      274.27658      44090.495      44090.495      160.53184      160.53184    
Loop time of 57.8731 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.493 ns/day, 16.076 hours/ns, 17.279 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.72      | 57.72      | 57.72      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021548   | 0.021548   | 0.021548   |   0.0 |  0.04
Output  | 3.5076e-05 | 3.5076e-05 | 3.5076e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.21
Other   |            | 0.01019    |            |       |  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:       313918 ave      313918 max      313918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313918
Ave neighs/atom = 78.4795
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.751537653588, Press = 1.03121231982482
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17517.616     -17517.616     -17659.393     -17659.393      274.27658      274.27658      44090.495      44090.495      160.53184      160.53184    
     28000  -17516.513     -17516.513     -17657.064     -17657.064      271.90467      271.90467      44140.902      44140.902     -1695.4676     -1695.4676    
Loop time of 57.9404 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.491 ns/day, 16.095 hours/ns, 17.259 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.787     | 57.787     | 57.787     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021517   | 0.021517   | 0.021517   |   0.0 |  0.04
Output  | 3.5337e-05 | 3.5337e-05 | 3.5337e-05 |   0.0 |  0.00
Modify  | 0.12116    | 0.12116    | 0.12116    |   0.0 |  0.21
Other   |            | 0.01018    |            |       |  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:       313894 ave      313894 max      313894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313894
Ave neighs/atom = 78.4735
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.820633538635, Press = -1.80535605356387
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17516.513     -17516.513     -17657.064     -17657.064      271.90467      271.90467      44140.902      44140.902     -1695.4676     -1695.4676    
     29000  -17519.329     -17519.329     -17657.605     -17657.605      267.50325      267.50325      44046.272      44046.272      2172.9986      2172.9986    
Loop time of 57.9972 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.490 ns/day, 16.110 hours/ns, 17.242 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.844     | 57.844     | 57.844     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021625   | 0.021625   | 0.021625   |   0.0 |  0.04
Output  | 3.6869e-05 | 3.6869e-05 | 3.6869e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.21
Other   |            | 0.01023    |            |       |  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:       313754 ave      313754 max      313754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313754
Ave neighs/atom = 78.4385
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.860044819131, Press = -1.44168049625464
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17519.329     -17519.329     -17657.605     -17657.605      267.50325      267.50325      44046.272      44046.272      2172.9986      2172.9986    
     30000  -17515.553     -17515.553     -17656.556     -17656.556      272.78106      272.78106      44106.69       44106.69      -231.77097     -231.77097    
Loop time of 57.9085 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.492 ns/day, 16.086 hours/ns, 17.269 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.756     | 57.756     | 57.756     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021648   | 0.021648   | 0.021648   |   0.0 |  0.04
Output  | 3.8422e-05 | 3.8422e-05 | 3.8422e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.21
Other   |            | 0.01017    |            |       |  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:       313916 ave      313916 max      313916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313916
Ave neighs/atom = 78.479
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.82710182844, Press = 0.69726894129641
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17515.553     -17515.553     -17656.556     -17656.556      272.78106      272.78106      44106.69       44106.69      -231.77097     -231.77097    
     31000  -17519.565     -17519.565     -17658.393     -17658.393      268.57101      268.57101      44097.84       44097.84      -75.520478     -75.520478    
Loop time of 57.9653 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.491 ns/day, 16.101 hours/ns, 17.252 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.812     | 57.812     | 57.812     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021558   | 0.021558   | 0.021558   |   0.0 |  0.04
Output  | 5.1006e-05 | 5.1006e-05 | 5.1006e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.21
Other   |            | 0.01022    |            |       |  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:       313790 ave      313790 max      313790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313790
Ave neighs/atom = 78.4475
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.80522310272, Press = -0.927833522952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17519.565     -17519.565     -17658.393     -17658.393      268.57101      268.57101      44097.84       44097.84      -75.520478     -75.520478    
     32000  -17516.368     -17516.368     -17657.575     -17657.575      273.17436      273.17436      44089.708      44089.708      335.13083      335.13083    
Loop time of 58.0983 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.487 ns/day, 16.138 hours/ns, 17.212 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.945     | 57.945     | 57.945     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021576   | 0.021576   | 0.021576   |   0.0 |  0.04
Output  | 4.777e-05  | 4.777e-05  | 4.777e-05  |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.21
Other   |            | 0.01018    |            |       |  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:       313894 ave      313894 max      313894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313894
Ave neighs/atom = 78.4735
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.853662400586, Press = -0.690758787787562
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17516.368     -17516.368     -17657.575     -17657.575      273.17436      273.17436      44089.708      44089.708      335.13083      335.13083    
     33000  -17511.397     -17511.397     -17654.727     -17654.727      277.28049      277.28049      44121.07       44121.07      -589.15116     -589.15116    
Loop time of 57.9705 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.490 ns/day, 16.103 hours/ns, 17.250 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.818     | 57.818     | 57.818     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021534   | 0.021534   | 0.021534   |   0.0 |  0.04
Output  | 4.7049e-05 | 4.7049e-05 | 4.7049e-05 |   0.0 |  0.00
Modify  | 0.12102    | 0.12102    | 0.12102    |   0.0 |  0.21
Other   |            | 0.01019    |            |       |  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:       313816 ave      313816 max      313816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313816
Ave neighs/atom = 78.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 = 272.887091781433, Press = -0.225556573753849
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17511.397     -17511.397     -17654.727     -17654.727      277.28049      277.28049      44121.07       44121.07      -589.15116     -589.15116    
     34000  -17517.231     -17517.231     -17656.967     -17656.967      270.32885      270.32885      44102.091      44102.091     -42.915708     -42.915708    
Loop time of 57.9528 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.491 ns/day, 16.098 hours/ns, 17.255 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.8       | 57.8       | 57.8       |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021532   | 0.021532   | 0.021532   |   0.0 |  0.04
Output  | 4.5536e-05 | 4.5536e-05 | 4.5536e-05 |   0.0 |  0.00
Modify  | 0.12103    | 0.12103    | 0.12103    |   0.0 |  0.21
Other   |            | 0.01017    |            |       |  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:       313834 ave      313834 max      313834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313834
Ave neighs/atom = 78.4585
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.946868849891, Press = -1.43714295805695
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17517.231     -17517.231     -17656.967     -17656.967      270.32885      270.32885      44102.091      44102.091     -42.915708     -42.915708    
     35000  -17514.938     -17514.938     -17656.11      -17656.11       273.10688      273.10688      44076.637      44076.637      1092.7605      1092.7605    
Loop time of 58.0664 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.488 ns/day, 16.130 hours/ns, 17.222 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.914     | 57.914     | 57.914     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021522   | 0.021522   | 0.021522   |   0.0 |  0.04
Output  | 4.5737e-05 | 4.5737e-05 | 4.5737e-05 |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.21
Other   |            | 0.01017    |            |       |  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:       313836 ave      313836 max      313836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313836
Ave neighs/atom = 78.459
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.973681818733, Press = 0.217045265221068
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17514.938     -17514.938     -17656.11      -17656.11       273.10688      273.10688      44076.637      44076.637      1092.7605      1092.7605    
     36000  -17517.582     -17517.582     -17658.287     -17658.287      272.2016       272.2016       44139.497      44139.497     -1692.6479     -1692.6479    
Loop time of 57.8977 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.492 ns/day, 16.083 hours/ns, 17.272 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.745     | 57.745     | 57.745     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021482   | 0.021482   | 0.021482   |   0.0 |  0.04
Output  | 4.3662e-05 | 4.3662e-05 | 4.3662e-05 |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  0.21
Other   |            | 0.01017    |            |       |  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:       313888 ave      313888 max      313888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313888
Ave neighs/atom = 78.472
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.930610032914, Press = -0.292166604303813
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17517.582     -17517.582     -17658.287     -17658.287      272.2016       272.2016       44139.497      44139.497     -1692.6479     -1692.6479    
     37000  -17516.772     -17516.772     -17657.637     -17657.637      272.51361      272.51361      44074.709      44074.709      1072.385       1072.385     
Loop time of 57.9049 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.492 ns/day, 16.085 hours/ns, 17.270 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.752     | 57.752     | 57.752     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021636   | 0.021636   | 0.021636   |   0.0 |  0.04
Output  | 4.3442e-05 | 4.3442e-05 | 4.3442e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.21
Other   |            | 0.01019    |            |       |  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:       313780 ave      313780 max      313780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313780
Ave neighs/atom = 78.445
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.966964490919, Press = -2.24430044582211
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17516.772     -17516.772     -17657.637     -17657.637      272.51361      272.51361      44074.709      44074.709      1072.385       1072.385     
     38000  -17515.572     -17515.572     -17657.399     -17657.399      274.37277      274.37277      44072.262      44072.262      1156.6573      1156.6573    
Loop time of 58.0268 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.489 ns/day, 16.119 hours/ns, 17.233 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.874     | 57.874     | 57.874     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021519   | 0.021519   | 0.021519   |   0.0 |  0.04
Output  | 3.3804e-05 | 3.3804e-05 | 3.3804e-05 |   0.0 |  0.00
Modify  | 0.12104    | 0.12104    | 0.12104    |   0.0 |  0.21
Other   |            | 0.01018    |            |       |  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:       313854 ave      313854 max      313854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313854
Ave neighs/atom = 78.4635
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.964662953738, Press = 1.42529849946139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17515.572     -17515.572     -17657.399     -17657.399      274.37277      274.37277      44072.262      44072.262      1156.6573      1156.6573    
     39000  -17521.318     -17521.318     -17659.195     -17659.195      266.73275      266.73275      44114.923      44114.923     -829.74206     -829.74206    
Loop time of 58.02 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.489 ns/day, 16.117 hours/ns, 17.235 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.867     | 57.867     | 57.867     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021563   | 0.021563   | 0.021563   |   0.0 |  0.04
Output  | 2.9005e-05 | 2.9005e-05 | 2.9005e-05 |   0.0 |  0.00
Modify  | 0.12116    | 0.12116    | 0.12116    |   0.0 |  0.21
Other   |            | 0.01018    |            |       |  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:       313920 ave      313920 max      313920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313920
Ave neighs/atom = 78.48
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.931194947084, Press = -0.642721141488228
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17521.318     -17521.318     -17659.195     -17659.195      266.73275      266.73275      44114.923      44114.923     -829.74206     -829.74206    
     40000  -17516.548     -17516.548     -17657.602     -17657.602      272.87893      272.87893      44085.203      44085.203      570.259        570.259      
Loop time of 58.0375 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.489 ns/day, 16.122 hours/ns, 17.230 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.884     | 57.884     | 57.884     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021729   | 0.021729   | 0.021729   |   0.0 |  0.04
Output  | 4.787e-05  | 4.787e-05  | 4.787e-05  |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.21
Other   |            | 0.01019    |            |       |  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:       313692 ave      313692 max      313692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313692
Ave neighs/atom = 78.423
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.931363639169, Press = -1.0132199688743
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17516.548     -17516.548     -17657.602     -17657.602      272.87893      272.87893      44085.203      44085.203      570.259        570.259      
     41000  -17509.47      -17509.47      -17652.06      -17652.06       275.85126      275.85126      44098.12       44098.12       686.88041      686.88041    
Loop time of 58.0688 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.488 ns/day, 16.130 hours/ns, 17.221 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.916     | 57.916     | 57.916     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021502   | 0.021502   | 0.021502   |   0.0 |  0.04
Output  | 4.7129e-05 | 4.7129e-05 | 4.7129e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.21
Other   |            | 0.0102     |            |       |  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:       313788 ave      313788 max      313788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313788
Ave neighs/atom = 78.447
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.948763871846, Press = 0.54148429572649
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17509.47      -17509.47      -17652.06      -17652.06       275.85126      275.85126      44098.12       44098.12       686.88041      686.88041    
     42000  -17517.238     -17517.238     -17655.792     -17655.792      268.04112      268.04112      44147.856      44147.856     -1944.2739     -1944.2739    
Loop time of 57.9553 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.491 ns/day, 16.099 hours/ns, 17.255 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.802     | 57.802     | 57.802     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021631   | 0.021631   | 0.021631   |   0.0 |  0.04
Output  | 4.6808e-05 | 4.6808e-05 | 4.6808e-05 |   0.0 |  0.00
Modify  | 0.12111    | 0.12111    | 0.12111    |   0.0 |  0.21
Other   |            | 0.01019    |            |       |  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:       313924 ave      313924 max      313924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313924
Ave neighs/atom = 78.481
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.001277343753, Press = -0.905297388868548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17517.238     -17517.238     -17655.792     -17655.792      268.04112      268.04112      44147.856      44147.856     -1944.2739     -1944.2739    
     43000  -17512.693     -17512.693     -17654.087     -17654.087      273.53603      273.53603      44046.791      44046.791      2519.4222      2519.4222    
Loop time of 58.0327 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.489 ns/day, 16.120 hours/ns, 17.232 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.88      | 57.88      | 57.88      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021546   | 0.021546   | 0.021546   |   0.0 |  0.04
Output  | 4.5596e-05 | 4.5596e-05 | 4.5596e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.21
Other   |            | 0.01017    |            |       |  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:       313804 ave      313804 max      313804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313804
Ave neighs/atom = 78.451
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.024548858898, Press = -1.86487081638422
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17512.693     -17512.693     -17654.087     -17654.087      273.53603      273.53603      44046.791      44046.791      2519.4222      2519.4222    
     44000  -17521.674     -17521.674     -17659.433     -17659.433      266.50411      266.50411      44086.368      44086.368      246.20136      246.20136    
Loop time of 58.0766 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.488 ns/day, 16.132 hours/ns, 17.219 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.924     | 57.924     | 57.924     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021545   | 0.021545   | 0.021545   |   0.0 |  0.04
Output  | 4.775e-05  | 4.775e-05  | 4.775e-05  |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.21
Other   |            | 0.01017    |            |       |  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:       314020 ave      314020 max      314020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314020
Ave neighs/atom = 78.505
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.98951615866, Press = 0.981157779049438
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17521.674     -17521.674     -17659.433     -17659.433      266.50411      266.50411      44086.368      44086.368      246.20136      246.20136    
     45000  -17515.246     -17515.246     -17655.874     -17655.874      272.05463      272.05463      44123.34       44123.34      -778.57459     -778.57459    
Loop time of 58.1619 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.486 ns/day, 16.156 hours/ns, 17.193 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.009     | 58.009     | 58.009     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021505   | 0.021505   | 0.021505   |   0.0 |  0.04
Output  | 4.6829e-05 | 4.6829e-05 | 4.6829e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.21
Other   |            | 0.01019    |            |       |  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:       313942 ave      313942 max      313942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313942
Ave neighs/atom = 78.4855
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.975576400113, Press = -1.11763838601679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17515.246     -17515.246     -17655.874     -17655.874      272.05463      272.05463      44123.34       44123.34      -778.57459     -778.57459    
     46000  -17518.989     -17518.989     -17656.916     -17656.916      266.8305       266.8305       44059.549      44059.549      1639.0422      1639.0422    
Loop time of 57.8837 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.493 ns/day, 16.079 hours/ns, 17.276 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.731     | 57.731     | 57.731     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021498   | 0.021498   | 0.021498   |   0.0 |  0.04
Output  | 4.5125e-05 | 4.5125e-05 | 4.5125e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.21
Other   |            | 0.01021    |            |       |  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:       313744 ave      313744 max      313744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313744
Ave neighs/atom = 78.436
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.956049609159, Press = -0.417279822635789
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17518.989     -17518.989     -17656.916     -17656.916      266.8305       266.8305       44059.549      44059.549      1639.0422      1639.0422    
     47000  -17514.874     -17514.874     -17655.041     -17655.041      271.16295      271.16295      44121.113      44121.113     -704.73749     -704.73749    
Loop time of 58.0564 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.488 ns/day, 16.127 hours/ns, 17.225 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.904     | 57.904     | 57.904     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021463   | 0.021463   | 0.021463   |   0.0 |  0.04
Output  | 4.5476e-05 | 4.5476e-05 | 4.5476e-05 |   0.0 |  0.00
Modify  | 0.12099    | 0.12099    | 0.12099    |   0.0 |  0.21
Other   |            | 0.01018    |            |       |  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:       313944 ave      313944 max      313944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313944
Ave neighs/atom = 78.486
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.974240415116, Press = 0.586867432536524
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17514.874     -17514.874     -17655.041     -17655.041      271.16295      271.16295      44121.113      44121.113     -704.73749     -704.73749    
     48000  -17514.842     -17514.842     -17658.151     -17658.151      277.24056      277.24056      44135.074      44135.074     -1553.7219     -1553.7219    
Loop time of 57.9565 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.491 ns/day, 16.099 hours/ns, 17.254 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.804     | 57.804     | 57.804     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021519   | 0.021519   | 0.021519   |   0.0 |  0.04
Output  | 4.6507e-05 | 4.6507e-05 | 4.6507e-05 |   0.0 |  0.00
Modify  | 0.12095    | 0.12095    | 0.12095    |   0.0 |  0.21
Other   |            | 0.0102     |            |       |  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:       313856 ave      313856 max      313856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313856
Ave neighs/atom = 78.464
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.996588391823, Press = -2.27391872320219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -17514.842     -17514.842     -17658.151     -17658.151      277.24056      277.24056      44135.074      44135.074     -1553.7219     -1553.7219    
     49000  -17514.319     -17514.319     -17656.559     -17656.559      275.17284      275.17284      44035.237      44035.237      2810.6517      2810.6517    
Loop time of 57.9545 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.491 ns/day, 16.098 hours/ns, 17.255 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.802     | 57.802     | 57.802     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02163    | 0.02163    | 0.02163    |   0.0 |  0.04
Output  | 4.5846e-05 | 4.5846e-05 | 4.5846e-05 |   0.0 |  0.00
Modify  | 0.12111    | 0.12111    | 0.12111    |   0.0 |  0.21
Other   |            | 0.0102     |            |       |  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:       313750 ave      313750 max      313750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313750
Ave neighs/atom = 78.4375
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
44100.8583039416

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0