# 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.5213917419314393*${_u_distance}
variable latticeconst_converted equal 3.5213917419314393*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174193144
Lattice spacing in x,y,z = 3.5213917 3.5213917 3.5213917
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.213917 35.213917 35.213917)
  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.213917 35.213917 35.213917)
  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_MaiselKoZhang_2017_VNiTi__MO_744610363128_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.9611745232    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*1*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 43665.9611745232*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_744610363128_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17627.791     -17627.791     -17800         -17800          333.15         333.15         43665.961      43665.961      4212.4217      4212.4217    
      1000  -17443.958     -17443.958     -17617.631     -17617.631      335.98316      335.98316      44231.265      44231.265     -1099.1386     -1099.1386    
Loop time of 58.1532 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.486 ns/day, 16.154 hours/ns, 17.196 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    | 58         | 58         | 58         |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022756   | 0.022756   | 0.022756   |   0.0 |  0.04
Output  | 0.00017015 | 0.00017015 | 0.00017015 |   0.0 |  0.00
Modify  | 0.11931    | 0.11931    | 0.11931    |   0.0 |  0.21
Other   |            | 0.0113     |            |       |  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:       536000 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17443.958     -17443.958     -17617.631     -17617.631      335.98316      335.98316      44231.265      44231.265     -1099.1386     -1099.1386    
      2000  -17454.558     -17454.558     -17627.461     -17627.461      334.49271      334.49271      44205.753      44205.753     -961.71047     -961.71047    
Loop time of 74.5445 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.707 hours/ns, 13.415 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    | 74.392     | 74.392     | 74.392     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022917   | 0.022917   | 0.022917   |   0.0 |  0.03
Output  | 6.894e-05  | 6.894e-05  | 6.894e-05  |   0.0 |  0.00
Modify  | 0.11915    | 0.11915    | 0.11915    |   0.0 |  0.16
Other   |            | 0.01081    |            |       |  0.01

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

Total # of neighbors = 541066
Ave neighs/atom = 135.2665
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17454.558     -17454.558     -17627.461     -17627.461      334.49271      334.49271      44205.753      44205.753     -961.71047     -961.71047    
      3000  -17453.399     -17453.399     -17622.943     -17622.943      327.99346      327.99346      44171.573      44171.573      747.4996       747.4996     
Loop time of 74.4893 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.691 hours/ns, 13.425 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    | 74.336     | 74.336     | 74.336     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02294    | 0.02294    | 0.02294    |   0.0 |  0.03
Output  | 7.2827e-05 | 7.2827e-05 | 7.2827e-05 |   0.0 |  0.00
Modify  | 0.11913    | 0.11913    | 0.11913    |   0.0 |  0.16
Other   |            | 0.01075    |            |       |  0.01

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

Total # of neighbors = 540904
Ave neighs/atom = 135.226
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17453.399     -17453.399     -17622.943     -17622.943      327.99346      327.99346      44171.573      44171.573      747.4996       747.4996     
      4000  -17451.167     -17451.167     -17625.231     -17625.231      336.73855      336.73855      44179.489      44179.489      391.43306      391.43306    
Loop time of 74.5309 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.703 hours/ns, 13.417 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    | 74.378     | 74.378     | 74.378     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022862   | 0.022862   | 0.022862   |   0.0 |  0.03
Output  | 7.2526e-05 | 7.2526e-05 | 7.2526e-05 |   0.0 |  0.00
Modify  | 0.11907    | 0.11907    | 0.11907    |   0.0 |  0.16
Other   |            | 0.01075    |            |       |  0.01

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

Total # of neighbors = 541244
Ave neighs/atom = 135.311
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17451.167     -17451.167     -17625.231     -17625.231      336.73855      336.73855      44179.489      44179.489      391.43306      391.43306    
      5000  -17456.257     -17456.257     -17628.396     -17628.396      333.0137       333.0137       44193.812      44193.812     -605.82939     -605.82939    
Loop time of 74.2522 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.164 ns/day, 20.626 hours/ns, 13.468 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    | 74.099     | 74.099     | 74.099     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022887   | 0.022887   | 0.022887   |   0.0 |  0.03
Output  | 5.1206e-05 | 5.1206e-05 | 5.1206e-05 |   0.0 |  0.00
Modify  | 0.11947    | 0.11947    | 0.11947    |   0.0 |  0.16
Other   |            | 0.01072    |            |       |  0.01

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

Total # of neighbors = 541244
Ave neighs/atom = 135.311
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.166240342122, Press = -562.092774520631
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17456.257     -17456.257     -17628.396     -17628.396      333.0137       333.0137       44193.812      44193.812     -605.82939     -605.82939    
      6000  -17450.116     -17450.116     -17623.948     -17623.948      336.2898       336.2898       44234.89       44234.89      -1858.4326     -1858.4326    
Loop time of 74.3414 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.650 hours/ns, 13.451 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    | 74.184     | 74.184     | 74.184     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022827   | 0.022827   | 0.022827   |   0.0 |  0.03
Output  | 4.8552e-05 | 4.8552e-05 | 4.8552e-05 |   0.0 |  0.00
Modify  | 0.12331    | 0.12331    | 0.12331    |   0.0 |  0.17
Other   |            | 0.01076    |            |       |  0.01

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

Total # of neighbors = 541070
Ave neighs/atom = 135.2675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.563823146692, Press = 24.0125029961999
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17450.116     -17450.116     -17623.948     -17623.948      336.2898       336.2898       44234.89       44234.89      -1858.4326     -1858.4326    
      7000  -17456.609     -17456.609     -17632.12      -17632.12       339.53748      339.53748      44120.874      44120.874      2212.4729      2212.4729    
Loop time of 74.2324 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.164 ns/day, 20.620 hours/ns, 13.471 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    | 74.075     | 74.075     | 74.075     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022876   | 0.022876   | 0.022876   |   0.0 |  0.03
Output  | 5.4723e-05 | 5.4723e-05 | 5.4723e-05 |   0.0 |  0.00
Modify  | 0.12323    | 0.12323    | 0.12323    |   0.0 |  0.17
Other   |            | 0.01081    |            |       |  0.01

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

Total # of neighbors = 540944
Ave neighs/atom = 135.236
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.921266065485, Press = 16.8435122455666
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17456.609     -17456.609     -17632.12      -17632.12       339.53748      339.53748      44120.874      44120.874      2212.4729      2212.4729    
      8000  -17451.369     -17451.369     -17626.328     -17626.328      338.46897      338.46897      44173.102      44173.102      492.69197      492.69197    
Loop time of 74.145 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.596 hours/ns, 13.487 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    | 73.988     | 73.988     | 73.988     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022716   | 0.022716   | 0.022716   |   0.0 |  0.03
Output  | 5.5144e-05 | 5.5144e-05 | 5.5144e-05 |   0.0 |  0.00
Modify  | 0.12337    | 0.12337    | 0.12337    |   0.0 |  0.17
Other   |            | 0.01073    |            |       |  0.01

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

Total # of neighbors = 541368
Ave neighs/atom = 135.342
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.945669837172, Press = -19.6739040666617
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17451.369     -17451.369     -17626.328     -17626.328      338.46897      338.46897      44173.102      44173.102      492.69197      492.69197    
      9000  -17453.692     -17453.692     -17627.651     -17627.651      336.53704      336.53704      44216.726      44216.726     -1386.2904     -1386.2904    
Loop time of 74.3052 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.640 hours/ns, 13.458 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    | 74.148     | 74.148     | 74.148     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023083   | 0.023083   | 0.023083   |   0.0 |  0.03
Output  | 5.9992e-05 | 5.9992e-05 | 5.9992e-05 |   0.0 |  0.00
Modify  | 0.12337    | 0.12337    | 0.12337    |   0.0 |  0.17
Other   |            | 0.01082    |            |       |  0.01

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

Total # of neighbors = 541140
Ave neighs/atom = 135.285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.891820274513, Press = -7.44306691472469
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17453.692     -17453.692     -17627.651     -17627.651      336.53704      336.53704      44216.726      44216.726     -1386.2904     -1386.2904    
     10000  -17454.572     -17454.572     -17626.207     -17626.207      332.038        332.038        44187.125      44187.125     -115.63905     -115.63905    
Loop time of 74.3058 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.640 hours/ns, 13.458 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    | 74.149     | 74.149     | 74.149     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022577   | 0.022577   | 0.022577   |   0.0 |  0.03
Output  | 5.7468e-05 | 5.7468e-05 | 5.7468e-05 |   0.0 |  0.00
Modify  | 0.12322    | 0.12322    | 0.12322    |   0.0 |  0.17
Other   |            | 0.01069    |            |       |  0.01

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

Total # of neighbors = 541010
Ave neighs/atom = 135.2525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.001292700371, Press = 1.01199840068877
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17454.572     -17454.572     -17626.207     -17626.207      332.038        332.038        44187.125      44187.125     -115.63905     -115.63905    
     11000  -17449.6       -17449.6       -17621.647     -17621.647      332.83651      332.83651      44160.105      44160.105      1446.34        1446.34      
Loop time of 74.3216 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.645 hours/ns, 13.455 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    | 74.165     | 74.165     | 74.165     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022964   | 0.022964   | 0.022964   |   0.0 |  0.03
Output  | 5.3861e-05 | 5.3861e-05 | 5.3861e-05 |   0.0 |  0.00
Modify  | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.17
Other   |            | 0.0108     |            |       |  0.01

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

Total # of neighbors = 541112
Ave neighs/atom = 135.278
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.286904746392, Press = -5.10651323757001
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17449.6       -17449.6       -17621.647     -17621.647      332.83651      332.83651      44160.105      44160.105      1446.34        1446.34      
     12000  -17451.263     -17451.263     -17623.94      -17623.94       334.05585      334.05585      44227.469      44227.469     -1561.6068     -1561.6068    
Loop time of 74.4511 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.681 hours/ns, 13.432 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    | 74.294     | 74.294     | 74.294     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022843   | 0.022843   | 0.022843   |   0.0 |  0.03
Output  | 5.4182e-05 | 5.4182e-05 | 5.4182e-05 |   0.0 |  0.00
Modify  | 0.12323    | 0.12323    | 0.12323    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541242
Ave neighs/atom = 135.3105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.192104861549, Press = -14.9935980010384
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17451.263     -17451.263     -17623.94      -17623.94       334.05585      334.05585      44227.469      44227.469     -1561.6068     -1561.6068    
     13000  -17454.402     -17454.402     -17628.014     -17628.014      335.86344      335.86344      44233.895      44233.895     -2153.1501     -2153.1501    
Loop time of 74.3533 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.654 hours/ns, 13.449 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    | 74.197     | 74.197     | 74.197     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022848   | 0.022848   | 0.022848   |   0.0 |  0.03
Output  | 5.6927e-05 | 5.6927e-05 | 5.6927e-05 |   0.0 |  0.00
Modify  | 0.12313    | 0.12313    | 0.12313    |   0.0 |  0.17
Other   |            | 0.01076    |            |       |  0.01

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

Total # of neighbors = 541048
Ave neighs/atom = 135.262
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.286403638519, Press = 2.18591844884241
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17454.402     -17454.402     -17628.014     -17628.014      335.86344      335.86344      44233.895      44233.895     -2153.1501     -2153.1501    
     14000  -17449.296     -17449.296     -17623.095     -17623.095      336.2269       336.2269       44169.541      44169.541      1000.5028      1000.5028    
Loop time of 74.0464 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.167 ns/day, 20.568 hours/ns, 13.505 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    | 73.889     | 73.889     | 73.889     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022903   | 0.022903   | 0.022903   |   0.0 |  0.03
Output  | 0.00010788 | 0.00010788 | 0.00010788 |   0.0 |  0.00
Modify  | 0.12328    | 0.12328    | 0.12328    |   0.0 |  0.17
Other   |            | 0.01075    |            |       |  0.01

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

Total # of neighbors = 540868
Ave neighs/atom = 135.217
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.292180664204, Press = 1.67712762558354
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17449.296     -17449.296     -17623.095     -17623.095      336.2269       336.2269       44169.541      44169.541      1000.5028      1000.5028    
     15000  -17453.243     -17453.243     -17625.877     -17625.877      333.97167      333.97167      44172.384      44172.384      577.48504      577.48504    
Loop time of 74.1612 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.600 hours/ns, 13.484 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    | 74.004     | 74.004     | 74.004     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023101   | 0.023101   | 0.023101   |   0.0 |  0.03
Output  | 5.2359e-05 | 5.2359e-05 | 5.2359e-05 |   0.0 |  0.00
Modify  | 0.12331    | 0.12331    | 0.12331    |   0.0 |  0.17
Other   |            | 0.0108     |            |       |  0.01

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

Total # of neighbors = 541262
Ave neighs/atom = 135.3155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.476999219494, Press = -4.62311232673771
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17453.243     -17453.243     -17625.877     -17625.877      333.97167      333.97167      44172.384      44172.384      577.48504      577.48504    
     16000  -17446.643     -17446.643     -17623.539     -17623.539      342.21676      342.21676      44229.502      44229.502     -1476.782      -1476.782     
Loop time of 74.1713 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.603 hours/ns, 13.482 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    | 74.014     | 74.014     | 74.014     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022927   | 0.022927   | 0.022927   |   0.0 |  0.03
Output  | 5.36e-05   | 5.36e-05   | 5.36e-05   |   0.0 |  0.00
Modify  | 0.12322    | 0.12322    | 0.12322    |   0.0 |  0.17
Other   |            | 0.01076    |            |       |  0.01

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

Total # of neighbors = 541260
Ave neighs/atom = 135.315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.534302656894, Press = -2.24764506373338
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17446.643     -17446.643     -17623.539     -17623.539      342.21676      342.21676      44229.502      44229.502     -1476.782      -1476.782     
     17000  -17451.773     -17451.773     -17624.988     -17624.988      335.09642      335.09642      44187.341      44187.341      99.559769      99.559769    
Loop time of 74.3069 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.641 hours/ns, 13.458 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    | 74.15      | 74.15      | 74.15      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022923   | 0.022923   | 0.022923   |   0.0 |  0.03
Output  | 5.7679e-05 | 5.7679e-05 | 5.7679e-05 |   0.0 |  0.00
Modify  | 0.12324    | 0.12324    | 0.12324    |   0.0 |  0.17
Other   |            | 0.01077    |            |       |  0.01

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

Total # of neighbors = 541112
Ave neighs/atom = 135.278
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.63141836913, Press = 4.78617199620462
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17451.773     -17451.773     -17624.988     -17624.988      335.09642      335.09642      44187.341      44187.341      99.559769      99.559769    
     18000  -17452.998     -17452.998     -17627.084     -17627.084      336.78047      336.78047      44108.267      44108.267      3147.7922      3147.7922    
Loop time of 74.2606 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.628 hours/ns, 13.466 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    | 74.104     | 74.104     | 74.104     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022941   | 0.022941   | 0.022941   |   0.0 |  0.03
Output  | 5.9352e-05 | 5.9352e-05 | 5.9352e-05 |   0.0 |  0.00
Modify  | 0.12318    | 0.12318    | 0.12318    |   0.0 |  0.17
Other   |            | 0.01074    |            |       |  0.01

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

Total # of neighbors = 541234
Ave neighs/atom = 135.3085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.556806888277, Press = -3.27677336748607
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17452.998     -17452.998     -17627.084     -17627.084      336.78047      336.78047      44108.267      44108.267      3147.7922      3147.7922    
     19000  -17452.82      -17452.82      -17625.422     -17625.422      333.91179      333.91179      44211.564      44211.564     -946.14768     -946.14768    
Loop time of 74.1209 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.166 ns/day, 20.589 hours/ns, 13.491 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    | 73.964     | 73.964     | 73.964     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022795   | 0.022795   | 0.022795   |   0.0 |  0.03
Output  | 5.1156e-05 | 5.1156e-05 | 5.1156e-05 |   0.0 |  0.00
Modify  | 0.12315    | 0.12315    | 0.12315    |   0.0 |  0.17
Other   |            | 0.0108     |            |       |  0.01

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

Total # of neighbors = 541460
Ave neighs/atom = 135.365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.546105916872, Press = -3.81663826281443
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17452.82      -17452.82      -17625.422     -17625.422      333.91179      333.91179      44211.564      44211.564     -946.14768     -946.14768    
     20000  -17451.84      -17451.84      -17622.939     -17622.939      331.00336      331.00336      44194.107      44194.107     -48.883692     -48.883692    
Loop time of 74.1702 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.603 hours/ns, 13.483 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    | 74.013     | 74.013     | 74.013     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022758   | 0.022758   | 0.022758   |   0.0 |  0.03
Output  | 5.5465e-05 | 5.5465e-05 | 5.5465e-05 |   0.0 |  0.00
Modify  | 0.12322    | 0.12322    | 0.12322    |   0.0 |  0.17
Other   |            | 0.01076    |            |       |  0.01

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

Total # of neighbors = 541114
Ave neighs/atom = 135.2785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.481668349023, Press = 0.891259691911114
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17451.84      -17451.84      -17622.939     -17622.939      331.00336      331.00336      44194.107      44194.107     -48.883692     -48.883692    
     21000  -17453.274     -17453.274     -17626.125     -17626.125      334.39025      334.39025      44151.873      44151.873      1418.7264      1418.7264    
Loop time of 74.1218 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.166 ns/day, 20.589 hours/ns, 13.491 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    | 73.965     | 73.965     | 73.965     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022829   | 0.022829   | 0.022829   |   0.0 |  0.03
Output  | 5.6866e-05 | 5.6866e-05 | 5.6866e-05 |   0.0 |  0.00
Modify  | 0.12333    | 0.12333    | 0.12333    |   0.0 |  0.17
Other   |            | 0.01074    |            |       |  0.01

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

Total # of neighbors = 541154
Ave neighs/atom = 135.2885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.38597981949, Press = -0.613332028288173
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17453.274     -17453.274     -17626.125     -17626.125      334.39025      334.39025      44151.873      44151.873      1418.7264      1418.7264    
     22000  -17448.203     -17448.203     -17620.45      -17620.45       333.22506      333.22506      44193.521      44193.521      267.15076      267.15076    
Loop time of 74.5168 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.699 hours/ns, 13.420 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    | 74.36      | 74.36      | 74.36      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022711   | 0.022711   | 0.022711   |   0.0 |  0.03
Output  | 5.839e-05  | 5.839e-05  | 5.839e-05  |   0.0 |  0.00
Modify  | 0.1235     | 0.1235     | 0.1235     |   0.0 |  0.17
Other   |            | 0.01077    |            |       |  0.01

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

Total # of neighbors = 541192
Ave neighs/atom = 135.298
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.359724030402, Press = -4.66809613224002
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17448.203     -17448.203     -17620.45      -17620.45       333.22506      333.22506      44193.521      44193.521      267.15076      267.15076    
     23000  -17455.301     -17455.301     -17625.357     -17625.357      328.98348      328.98348      44286.02       44286.02      -4071.3287     -4071.3287    
Loop time of 74.1924 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.609 hours/ns, 13.478 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    | 74.035     | 74.035     | 74.035     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02285    | 0.02285    | 0.02285    |   0.0 |  0.03
Output  | 4.6197e-05 | 4.6197e-05 | 4.6197e-05 |   0.0 |  0.00
Modify  | 0.12346    | 0.12346    | 0.12346    |   0.0 |  0.17
Other   |            | 0.01078    |            |       |  0.01

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

Total # of neighbors = 541182
Ave neighs/atom = 135.2955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.459480531541, Press = 0.437340669680519
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17455.301     -17455.301     -17625.357     -17625.357      328.98348      328.98348      44286.02       44286.02      -4071.3287     -4071.3287    
     24000  -17445.73      -17445.73      -17623.776     -17623.776      344.44321      344.44321      44178.838      44178.838      651.31613      651.31613    
Loop time of 74.0037 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.168 ns/day, 20.557 hours/ns, 13.513 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    | 73.847     | 73.847     | 73.847     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022865   | 0.022865   | 0.022865   |   0.0 |  0.03
Output  | 5.2909e-05 | 5.2909e-05 | 5.2909e-05 |   0.0 |  0.00
Modify  | 0.12341    | 0.12341    | 0.12341    |   0.0 |  0.17
Other   |            | 0.01084    |            |       |  0.01

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

Total # of neighbors = 540814
Ave neighs/atom = 135.2035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.521668361802, Press = 2.58028953541028
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17445.73      -17445.73      -17623.776     -17623.776      344.44321      344.44321      44178.838      44178.838      651.31613      651.31613    
     25000  -17453.467     -17453.467     -17627.693     -17627.693      337.05191      337.05191      44153.914      44153.914      1101.9667      1101.9667    
Loop time of 74.2354 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.164 ns/day, 20.621 hours/ns, 13.471 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.078     | 74.078     | 74.078     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0228     | 0.0228     | 0.0228     |   0.0 |  0.03
Output  | 5.5515e-05 | 5.5515e-05 | 5.5515e-05 |   0.0 |  0.00
Modify  | 0.12352    | 0.12352    | 0.12352    |   0.0 |  0.17
Other   |            | 0.01072    |            |       |  0.01

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

Total # of neighbors = 541282
Ave neighs/atom = 135.3205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.533538141871, Press = -1.57946648033327
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17453.467     -17453.467     -17627.693     -17627.693      337.05191      337.05191      44153.914      44153.914      1101.9667      1101.9667    
     26000  -17454.471     -17454.471     -17628.34      -17628.34       336.36056      336.36056      44206.855      44206.855     -1128.4886     -1128.4886    
Loop time of 74.2607 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.628 hours/ns, 13.466 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.104     | 74.104     | 74.104     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022879   | 0.022879   | 0.022879   |   0.0 |  0.03
Output  | 5.8039e-05 | 5.8039e-05 | 5.8039e-05 |   0.0 |  0.00
Modify  | 0.12338    | 0.12338    | 0.12338    |   0.0 |  0.17
Other   |            | 0.01078    |            |       |  0.01

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

Total # of neighbors = 541348
Ave neighs/atom = 135.337
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.590721846731, Press = -2.3702723641471
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17454.471     -17454.471     -17628.34      -17628.34       336.36056      336.36056      44206.855      44206.855     -1128.4886     -1128.4886    
     27000  -17454.485     -17454.485     -17629.078     -17629.078      337.7629       337.7629       44206.26       44206.26      -1139.5019     -1139.5019    
Loop time of 74.1779 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.605 hours/ns, 13.481 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.021     | 74.021     | 74.021     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022792   | 0.022792   | 0.022792   |   0.0 |  0.03
Output  | 6.0374e-05 | 6.0374e-05 | 6.0374e-05 |   0.0 |  0.00
Modify  | 0.12344    | 0.12344    | 0.12344    |   0.0 |  0.17
Other   |            | 0.01074    |            |       |  0.01

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

Total # of neighbors = 541110
Ave neighs/atom = 135.2775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.636173644156, Press = 0.142991594638718
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17454.485     -17454.485     -17629.078     -17629.078      337.7629       337.7629       44206.26       44206.26      -1139.5019     -1139.5019    
     28000  -17458.44      -17458.44      -17630.205     -17630.205      332.28973      332.28973      44147.181      44147.181      1162.3485      1162.3485    
Loop time of 74.2495 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.164 ns/day, 20.625 hours/ns, 13.468 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    | 74.093     | 74.093     | 74.093     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022757   | 0.022757   | 0.022757   |   0.0 |  0.03
Output  | 4.7319e-05 | 4.7319e-05 | 4.7319e-05 |   0.0 |  0.00
Modify  | 0.12329    | 0.12329    | 0.12329    |   0.0 |  0.17
Other   |            | 0.0108     |            |       |  0.01

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

Total # of neighbors = 541008
Ave neighs/atom = 135.252
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.636966956426, Press = 0.759020914799169
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17458.44      -17458.44      -17630.205     -17630.205      332.28973      332.28973      44147.181      44147.181      1162.3485      1162.3485    
     29000  -17453.109     -17453.109     -17623.472     -17623.472      329.5791       329.5791       44160.6        44160.6        1214.0586      1214.0586    
Loop time of 74.3399 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.650 hours/ns, 13.452 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    | 74.183     | 74.183     | 74.183     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022804   | 0.022804   | 0.022804   |   0.0 |  0.03
Output  | 4.9513e-05 | 4.9513e-05 | 4.9513e-05 |   0.0 |  0.00
Modify  | 0.12307    | 0.12307    | 0.12307    |   0.0 |  0.17
Other   |            | 0.01084    |            |       |  0.01

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

Total # of neighbors = 541400
Ave neighs/atom = 135.35
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.569690008989, Press = -4.22429681512948
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17453.109     -17453.109     -17623.472     -17623.472      329.5791       329.5791       44160.6        44160.6        1214.0586      1214.0586    
     30000  -17453.014     -17453.014     -17625.465     -17625.465      333.61663      333.61663      44247.346      44247.346     -2569.7987     -2569.7987    
Loop time of 74.5173 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.699 hours/ns, 13.420 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    | 74.36      | 74.36      | 74.36      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022886   | 0.022886   | 0.022886   |   0.0 |  0.03
Output  | 5.1417e-05 | 5.1417e-05 | 5.1417e-05 |   0.0 |  0.00
Modify  | 0.12324    | 0.12324    | 0.12324    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541310
Ave neighs/atom = 135.3275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.46089643051, Press = -0.810587277662832
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17453.014     -17453.014     -17625.465     -17625.465      333.61663      333.61663      44247.346      44247.346     -2569.7987     -2569.7987    
     31000  -17455.856     -17455.856     -17628.087     -17628.087      333.19385      333.19385      44174.457      44174.457      218.34909      218.34909    
Loop time of 74.3904 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.664 hours/ns, 13.443 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    | 74.234     | 74.234     | 74.234     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022751   | 0.022751   | 0.022751   |   0.0 |  0.03
Output  | 5.0315e-05 | 5.0315e-05 | 5.0315e-05 |   0.0 |  0.00
Modify  | 0.12302    | 0.12302    | 0.12302    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541132
Ave neighs/atom = 135.283
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.446844138113, Press = 1.10014542494109
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17455.856     -17455.856     -17628.087     -17628.087      333.19385      333.19385      44174.457      44174.457      218.34909      218.34909    
     32000  -17451.806     -17451.806     -17623.359     -17623.359      331.88082      331.88082      44159.907      44159.907      1229.1597      1229.1597    
Loop time of 74.277 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.633 hours/ns, 13.463 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    | 74.12      | 74.12      | 74.12      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022869   | 0.022869   | 0.022869   |   0.0 |  0.03
Output  | 4.9213e-05 | 4.9213e-05 | 4.9213e-05 |   0.0 |  0.00
Modify  | 0.12313    | 0.12313    | 0.12313    |   0.0 |  0.17
Other   |            | 0.01083    |            |       |  0.01

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

Total # of neighbors = 541262
Ave neighs/atom = 135.3155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.519333191432, Press = -1.09996120365862
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17451.806     -17451.806     -17623.359     -17623.359      331.88082      331.88082      44159.907      44159.907      1229.1597      1229.1597    
     33000  -17450.911     -17450.911     -17623.831     -17623.831      334.52633      334.52633      44208.21       44208.21      -728.21565     -728.21565    
Loop time of 74.2981 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.638 hours/ns, 13.459 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    | 74.141     | 74.141     | 74.141     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022794   | 0.022794   | 0.022794   |   0.0 |  0.03
Output  | 4.9473e-05 | 4.9473e-05 | 4.9473e-05 |   0.0 |  0.00
Modify  | 0.1231     | 0.1231     | 0.1231     |   0.0 |  0.17
Other   |            | 0.01077    |            |       |  0.01

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

Total # of neighbors = 541414
Ave neighs/atom = 135.3535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.544874226266, Press = -1.84472411939061
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17450.911     -17450.911     -17623.831     -17623.831      334.52633      334.52633      44208.21       44208.21      -728.21565     -728.21565    
     34000  -17455.897     -17455.897     -17627.978     -17627.978      332.9022       332.9022       44214.793      44214.793     -1527.6096     -1527.6096    
Loop time of 74.3626 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.656 hours/ns, 13.448 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    | 74.206     | 74.206     | 74.206     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022638   | 0.022638   | 0.022638   |   0.0 |  0.03
Output  | 5.2359e-05 | 5.2359e-05 | 5.2359e-05 |   0.0 |  0.00
Modify  | 0.12296    | 0.12296    | 0.12296    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541282
Ave neighs/atom = 135.3205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.55003781722, Press = 0.346605095483641
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17455.897     -17455.897     -17627.978     -17627.978      332.9022       332.9022       44214.793      44214.793     -1527.6096     -1527.6096    
     35000  -17454.595     -17454.595     -17628.362     -17628.362      336.16443      336.16443      44123.112      44123.112      2342.8961      2342.8961    
Loop time of 74.3525 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.653 hours/ns, 13.449 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    | 74.196     | 74.196     | 74.196     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022712   | 0.022712   | 0.022712   |   0.0 |  0.03
Output  | 5.6917e-05 | 5.6917e-05 | 5.6917e-05 |   0.0 |  0.00
Modify  | 0.12306    | 0.12306    | 0.12306    |   0.0 |  0.17
Other   |            | 0.01075    |            |       |  0.01

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

Total # of neighbors = 541124
Ave neighs/atom = 135.281
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.517753713933, Press = 2.68742206674527
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17454.595     -17454.595     -17628.362     -17628.362      336.16443      336.16443      44123.112      44123.112      2342.8961      2342.8961    
     36000  -17452.017     -17452.017     -17623.619     -17623.619      331.97678      331.97678      44138.583      44138.583      2123.604       2123.604     
Loop time of 74.4432 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.679 hours/ns, 13.433 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    | 74.286     | 74.286     | 74.286     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023066   | 0.023066   | 0.023066   |   0.0 |  0.03
Output  | 4.8921e-05 | 4.8921e-05 | 4.8921e-05 |   0.0 |  0.00
Modify  | 0.12322    | 0.12322    | 0.12322    |   0.0 |  0.17
Other   |            | 0.0108     |            |       |  0.01

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

Total # of neighbors = 541526
Ave neighs/atom = 135.3815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.422311379483, Press = -2.29511233015962
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17452.017     -17452.017     -17623.619     -17623.619      331.97678      331.97678      44138.583      44138.583      2123.604       2123.604     
     37000  -17455.831     -17455.831     -17626.579     -17626.579      330.32422      330.32422      44210.083      44210.083     -1084.419      -1084.419     
Loop time of 74.3499 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.653 hours/ns, 13.450 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    | 74.193     | 74.193     | 74.193     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022946   | 0.022946   | 0.022946   |   0.0 |  0.03
Output  | 4.805e-05  | 4.805e-05  | 4.805e-05  |   0.0 |  0.00
Modify  | 0.12301    | 0.12301    | 0.12301    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541462
Ave neighs/atom = 135.3655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.406257915056, Press = -0.671958196426169
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17455.831     -17455.831     -17626.579     -17626.579      330.32422      330.32422      44210.083      44210.083     -1084.419      -1084.419     
     38000  -17453.141     -17453.141     -17626.535     -17626.535      335.4434       335.4434       44182.149      44182.149      55.815481      55.815481    
Loop time of 74.3556 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.654 hours/ns, 13.449 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    | 74.199     | 74.199     | 74.199     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02267    | 0.02267    | 0.02267    |   0.0 |  0.03
Output  | 5.0244e-05 | 5.0244e-05 | 5.0244e-05 |   0.0 |  0.00
Modify  | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.17
Other   |            | 0.01074    |            |       |  0.01

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

Total # of neighbors = 541140
Ave neighs/atom = 135.285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.463843526614, Press = 0.950685183917189
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17453.141     -17453.141     -17626.535     -17626.535      335.4434       335.4434       44182.149      44182.149      55.815481      55.815481    
     39000  -17447.673     -17447.673     -17622.691     -17622.691      338.58404      338.58404      44143.666      44143.666      2110.2677      2110.2677    
Loop time of 74.3848 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.662 hours/ns, 13.444 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    | 74.228     | 74.228     | 74.228     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023004   | 0.023004   | 0.023004   |   0.0 |  0.03
Output  | 5.1116e-05 | 5.1116e-05 | 5.1116e-05 |   0.0 |  0.00
Modify  | 0.12313    | 0.12313    | 0.12313    |   0.0 |  0.17
Other   |            | 0.01078    |            |       |  0.01

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

Total # of neighbors = 541138
Ave neighs/atom = 135.2845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.493024968051, Press = -0.542683796336504
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17447.673     -17447.673     -17622.691     -17622.691      338.58404      338.58404      44143.666      44143.666      2110.2677      2110.2677    
     40000  -17452.943     -17452.943     -17625.005     -17625.005      332.86608      332.86608      44227.182      44227.182     -1660.4424     -1660.4424    
Loop time of 74.2398 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.164 ns/day, 20.622 hours/ns, 13.470 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    | 74.083     | 74.083     | 74.083     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022975   | 0.022975   | 0.022975   |   0.0 |  0.03
Output  | 4.6698e-05 | 4.6698e-05 | 4.6698e-05 |   0.0 |  0.00
Modify  | 0.12308    | 0.12308    | 0.12308    |   0.0 |  0.17
Other   |            | 0.01081    |            |       |  0.01

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

Total # of neighbors = 541406
Ave neighs/atom = 135.3515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.484115313989, Press = -1.90960421326685
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17452.943     -17452.943     -17625.005     -17625.005      332.86608      332.86608      44227.182      44227.182     -1660.4424     -1660.4424    
     41000  -17451.269     -17451.269     -17625.079     -17625.079      336.24691      336.24691      44231.639      44231.639     -1846.0743     -1846.0743    
Loop time of 74.3938 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.665 hours/ns, 13.442 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    | 74.237     | 74.237     | 74.237     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023091   | 0.023091   | 0.023091   |   0.0 |  0.03
Output  | 4.795e-05  | 4.795e-05  | 4.795e-05  |   0.0 |  0.00
Modify  | 0.12301    | 0.12301    | 0.12301    |   0.0 |  0.17
Other   |            | 0.01081    |            |       |  0.01

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

Total # of neighbors = 540970
Ave neighs/atom = 135.2425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.435583797467, Press = 1.12391676625544
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17451.269     -17451.269     -17625.079     -17625.079      336.24691      336.24691      44231.639      44231.639     -1846.0743     -1846.0743    
     42000  -17457.726     -17457.726     -17629.358     -17629.358      332.03317      332.03317      44146.563      44146.563      1295.0652      1295.0652    
Loop time of 74.2816 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.634 hours/ns, 13.462 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    | 74.125     | 74.125     | 74.125     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022689   | 0.022689   | 0.022689   |   0.0 |  0.03
Output  | 4.9312e-05 | 4.9312e-05 | 4.9312e-05 |   0.0 |  0.00
Modify  | 0.12332    | 0.12332    | 0.12332    |   0.0 |  0.17
Other   |            | 0.01076    |            |       |  0.01

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

Total # of neighbors = 541080
Ave neighs/atom = 135.27
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.380605687442, Press = 0.501312604195715
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17457.726     -17457.726     -17629.358     -17629.358      332.03317      332.03317      44146.563      44146.563      1295.0652      1295.0652    
     43000  -17452.993     -17452.993     -17626.344     -17626.344      335.36053      335.36053      44177.971      44177.971      277.01233      277.01233    
Loop time of 74.2797 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.633 hours/ns, 13.463 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    | 74.122     | 74.122     | 74.122     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023195   | 0.023195   | 0.023195   |   0.0 |  0.03
Output  | 5.1056e-05 | 5.1056e-05 | 5.1056e-05 |   0.0 |  0.00
Modify  | 0.12318    | 0.12318    | 0.12318    |   0.0 |  0.17
Other   |            | 0.01086    |            |       |  0.01

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

Total # of neighbors = 541246
Ave neighs/atom = 135.3115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.349658780746, Press = -0.985334192289171
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17452.993     -17452.993     -17626.344     -17626.344      335.36053      335.36053      44177.971      44177.971      277.01233      277.01233    
     44000  -17447.592     -17447.592     -17625.053     -17625.053      343.31076      343.31076      44211.035      44211.035     -782.7032      -782.7032     
Loop time of 74.4242 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.673 hours/ns, 13.436 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    | 74.267     | 74.267     | 74.267     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022746   | 0.022746   | 0.022746   |   0.0 |  0.03
Output  | 5.1236e-05 | 5.1236e-05 | 5.1236e-05 |   0.0 |  0.00
Modify  | 0.12323    | 0.12323    | 0.12323    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541278
Ave neighs/atom = 135.3195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.355609376196, Press = -0.564594818055167
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17447.592     -17447.592     -17625.053     -17625.053      343.31076      343.31076      44211.035      44211.035     -782.7032      -782.7032     
     45000  -17454.349     -17454.349     -17624.372     -17624.372      328.92109      328.92109      44191.889      44191.889     -185.15695     -185.15695    
Loop time of 74.4585 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.683 hours/ns, 13.430 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    | 74.302     | 74.302     | 74.302     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022766   | 0.022766   | 0.022766   |   0.0 |  0.03
Output  | 8.479e-05  | 8.479e-05  | 8.479e-05  |   0.0 |  0.00
Modify  | 0.12307    | 0.12307    | 0.12307    |   0.0 |  0.17
Other   |            | 0.01083    |            |       |  0.01

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

Total # of neighbors = 541108
Ave neighs/atom = 135.277
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.378403591097, Press = 0.220615459238653
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17454.349     -17454.349     -17624.372     -17624.372      328.92109      328.92109      44191.889      44191.889     -185.15695     -185.15695    
     46000  -17448.743     -17448.743     -17623.388     -17623.388      337.86354      337.86354      44169.6        44169.6        1013.9843      1013.9843    
Loop time of 74.4212 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.673 hours/ns, 13.437 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    | 74.264     | 74.264     | 74.264     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023049   | 0.023049   | 0.023049   |   0.0 |  0.03
Output  | 4.9944e-05 | 4.9944e-05 | 4.9944e-05 |   0.0 |  0.00
Modify  | 0.12328    | 0.12328    | 0.12328    |   0.0 |  0.17
Other   |            | 0.01077    |            |       |  0.01

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

Total # of neighbors = 541128
Ave neighs/atom = 135.282
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.41544782448, Press = 0.0934308039470631
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17448.743     -17448.743     -17623.388     -17623.388      337.86354      337.86354      44169.6        44169.6        1013.9843      1013.9843    
     47000  -17456.885     -17456.885     -17626.465     -17626.465      328.06395      328.06395      44178.808      44178.808      105.37223      105.37223    
Loop time of 74.3903 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.664 hours/ns, 13.443 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    | 74.233     | 74.233     | 74.233     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023006   | 0.023006   | 0.023006   |   0.0 |  0.03
Output  | 4.9834e-05 | 4.9834e-05 | 4.9834e-05 |   0.0 |  0.00
Modify  | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.17
Other   |            | 0.01076    |            |       |  0.01

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

Total # of neighbors = 541250
Ave neighs/atom = 135.3125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.415636640664, Press = -1.89678526354445
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17456.885     -17456.885     -17626.465     -17626.465      328.06395      328.06395      44178.808      44178.808      105.37223      105.37223    
     48000  -17452.919     -17452.919     -17625.623     -17625.623      334.10771      334.10771      44262.885      44262.885     -3119.3902     -3119.3902    
Loop time of 74.3956 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.665 hours/ns, 13.442 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    | 74.239     | 74.239     | 74.239     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022812   | 0.022812   | 0.022812   |   0.0 |  0.03
Output  | 4.9643e-05 | 4.9643e-05 | 4.9643e-05 |   0.0 |  0.00
Modify  | 0.12325    | 0.12325    | 0.12325    |   0.0 |  0.17
Other   |            | 0.01074    |            |       |  0.01

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

Total # of neighbors = 541236
Ave neighs/atom = 135.309
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.413026071565, Press = -0.0447206768129596
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -17452.919     -17452.919     -17625.623     -17625.623      334.10771      334.10771      44262.885      44262.885     -3119.3902     -3119.3902    
     49000  -17455.611     -17455.611     -17625.712     -17625.712      329.0713       329.0713       44166.675      44166.675      746.29077      746.29077    
Loop time of 74.3408 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.650 hours/ns, 13.452 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    | 74.184     | 74.184     | 74.184     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022749   | 0.022749   | 0.022749   |   0.0 |  0.03
Output  | 5.6206e-05 | 5.6206e-05 | 5.6206e-05 |   0.0 |  0.00
Modify  | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.17
Other   |            | 0.01078    |            |       |  0.01

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

Total # of neighbors = 540938
Ave neighs/atom = 135.2345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.414330681668, Press = 0.979646180772655
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -17455.611     -17455.611     -17625.712     -17625.712      329.0713       329.0713       44166.675      44166.675      746.29077      746.29077    
     50000  -17453.04      -17453.04      -17625.8       -17625.8        334.21678      334.21678      44169.906      44169.906      562.70732      562.70732    
Loop time of 74.3676 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.658 hours/ns, 13.447 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    | 74.211     | 74.211     | 74.211     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023021   | 0.023021   | 0.023021   |   0.0 |  0.03
Output  | 5.0465e-05 | 5.0465e-05 | 5.0465e-05 |   0.0 |  0.00
Modify  | 0.12321    | 0.12321    | 0.12321    |   0.0 |  0.17
Other   |            | 0.0108     |            |       |  0.01

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

Total # of neighbors = 541304
Ave neighs/atom = 135.326
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.403495640337, Press = -0.434785682407177
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -17453.04      -17453.04      -17625.8       -17625.8        334.21678      334.21678      44169.906      44169.906      562.70732      562.70732    
     51000  -17454.051     -17454.051     -17625.713     -17625.713      332.09192      332.09192      44208.256      44208.256     -871.1221      -871.1221     
Loop time of 74.5111 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.698 hours/ns, 13.421 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    | 74.354     | 74.354     | 74.354     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023143   | 0.023143   | 0.023143   |   0.0 |  0.03
Output  | 5.0786e-05 | 5.0786e-05 | 5.0786e-05 |   0.0 |  0.00
Modify  | 0.12318    | 0.12318    | 0.12318    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541286
Ave neighs/atom = 135.3215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.396119266602, Press = -0.498064083742765
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -17454.051     -17454.051     -17625.713     -17625.713      332.09192      332.09192      44208.256      44208.256     -871.1221      -871.1221     
     52000  -17447.795     -17447.795     -17623.398     -17623.398      339.71574      339.71574      44198.775      44198.775     -212.10799     -212.10799    
Loop time of 74.3628 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.656 hours/ns, 13.448 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    | 74.206     | 74.206     | 74.206     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022864   | 0.022864   | 0.022864   |   0.0 |  0.03
Output  | 5.0434e-05 | 5.0434e-05 | 5.0434e-05 |   0.0 |  0.00
Modify  | 0.12328    | 0.12328    | 0.12328    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541028
Ave neighs/atom = 135.257
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.416490317434, Press = 0.606801063667548
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -17447.795     -17447.795     -17623.398     -17623.398      339.71574      339.71574      44198.775      44198.775     -212.10799     -212.10799    
     53000  -17454.102     -17454.102     -17626.287     -17626.287      333.10421      333.10421      44142.749      44142.749      1676.8413      1676.8413    
Loop time of 74.3386 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.650 hours/ns, 13.452 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    | 74.182     | 74.182     | 74.182     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022867   | 0.022867   | 0.022867   |   0.0 |  0.03
Output  | 4.9052e-05 | 4.9052e-05 | 4.9052e-05 |   0.0 |  0.00
Modify  | 0.1234     | 0.1234     | 0.1234     |   0.0 |  0.17
Other   |            | 0.01078    |            |       |  0.01

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

Total # of neighbors = 541160
Ave neighs/atom = 135.29
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.414804470099, Press = -0.189021394071916
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -17454.102     -17454.102     -17626.287     -17626.287      333.10421      333.10421      44142.749      44142.749      1676.8413      1676.8413    
     54000  -17451.489     -17451.489     -17622.204     -17622.204      330.25947      330.25947      44209.93       44209.93      -751.87516     -751.87516    
Loop time of 74.4444 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.679 hours/ns, 13.433 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    | 74.287     | 74.287     | 74.287     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023051   | 0.023051   | 0.023051   |   0.0 |  0.03
Output  | 4.9763e-05 | 4.9763e-05 | 4.9763e-05 |   0.0 |  0.00
Modify  | 0.12333    | 0.12333    | 0.12333    |   0.0 |  0.17
Other   |            | 0.0108     |            |       |  0.01

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

Total # of neighbors = 541346
Ave neighs/atom = 135.3365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.430341209957, Press = -1.40891068362709
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -17451.489     -17451.489     -17622.204     -17622.204      330.25947      330.25947      44209.93       44209.93      -751.87516     -751.87516    
     55000  -17454.235     -17454.235     -17625.215     -17625.215      330.77354      330.77354      44251.46       44251.46      -2734.8792     -2734.8792    
Loop time of 74.4142 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.671 hours/ns, 13.438 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    | 74.257     | 74.257     | 74.257     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022903   | 0.022903   | 0.022903   |   0.0 |  0.03
Output  | 4.9453e-05 | 4.9453e-05 | 4.9453e-05 |   0.0 |  0.00
Modify  | 0.12325    | 0.12325    | 0.12325    |   0.0 |  0.17
Other   |            | 0.01077    |            |       |  0.01

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

Total # of neighbors = 541208
Ave neighs/atom = 135.302
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.407103788406, Press = 0.845110308213361
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -17454.235     -17454.235     -17625.215     -17625.215      330.77354      330.77354      44251.46       44251.46      -2734.8792     -2734.8792    
     56000  -17454.194     -17454.194     -17625.501     -17625.501      331.4049       331.4049       44146.53       44146.53       1587.0203      1587.0203    
Loop time of 74.1381 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.594 hours/ns, 13.488 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    | 73.981     | 73.981     | 73.981     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022989   | 0.022989   | 0.022989   |   0.0 |  0.03
Output  | 4.9082e-05 | 4.9082e-05 | 4.9082e-05 |   0.0 |  0.00
Modify  | 0.12318    | 0.12318    | 0.12318    |   0.0 |  0.17
Other   |            | 0.01077    |            |       |  0.01

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

Total # of neighbors = 541012
Ave neighs/atom = 135.253
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.412411614334, Press = 0.57650976021278
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -17454.194     -17454.194     -17625.501     -17625.501      331.4049       331.4049       44146.53       44146.53       1587.0203      1587.0203    
     57000  -17452.251     -17452.251     -17624.876     -17624.876      333.95574      333.95574      44174.251      44174.251      520.27825      520.27825    
Loop time of 74.4211 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.673 hours/ns, 13.437 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    | 74.264     | 74.264     | 74.264     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022944   | 0.022944   | 0.022944   |   0.0 |  0.03
Output  | 4.6537e-05 | 4.6537e-05 | 4.6537e-05 |   0.0 |  0.00
Modify  | 0.12331    | 0.12331    | 0.12331    |   0.0 |  0.17
Other   |            | 0.0108     |            |       |  0.01

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

Total # of neighbors = 541260
Ave neighs/atom = 135.315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.405917645521, Press = -0.54534391173932
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -17452.251     -17452.251     -17624.876     -17624.876      333.95574      333.95574      44174.251      44174.251      520.27825      520.27825    
     58000  -17453.036     -17453.036     -17623.813     -17623.813      330.37963      330.37963      44206.896      44206.896     -750.03903     -750.03903    
Loop time of 74.1804 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.606 hours/ns, 13.481 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    | 74.023     | 74.023     | 74.023     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02319    | 0.02319    | 0.02319    |   0.0 |  0.03
Output  | 4.9203e-05 | 4.9203e-05 | 4.9203e-05 |   0.0 |  0.00
Modify  | 0.12334    | 0.12334    | 0.12334    |   0.0 |  0.17
Other   |            | 0.01084    |            |       |  0.01

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

Total # of neighbors = 541170
Ave neighs/atom = 135.2925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.442524109325, Press = -0.247038644718734
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -17453.036     -17453.036     -17623.813     -17623.813      330.37963      330.37963      44206.896      44206.896     -750.03903     -750.03903    
     59000  -17452.376     -17452.376     -17626.093     -17626.093      336.06736      336.06736      44192.023      44192.023     -246.02166     -246.02166    
Loop time of 74.2774 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.633 hours/ns, 13.463 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    | 74.12      | 74.12      | 74.12      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022789   | 0.022789   | 0.022789   |   0.0 |  0.03
Output  | 4.8902e-05 | 4.8902e-05 | 4.8902e-05 |   0.0 |  0.00
Modify  | 0.12329    | 0.12329    | 0.12329    |   0.0 |  0.17
Other   |            | 0.01081    |            |       |  0.01

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

Total # of neighbors = 540970
Ave neighs/atom = 135.2425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.435264814617, Press = 0.303243672824366
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -17452.376     -17452.376     -17626.093     -17626.093      336.06736      336.06736      44192.023      44192.023     -246.02166     -246.02166    
     60000  -17455.592     -17455.592     -17625.707     -17625.707      329.09992      329.09992      44125.072      44125.072      2409.0216      2409.0216    
Loop time of 74.3237 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.645 hours/ns, 13.455 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    | 74.167     | 74.167     | 74.167     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022945   | 0.022945   | 0.022945   |   0.0 |  0.03
Output  | 5.0505e-05 | 5.0505e-05 | 5.0505e-05 |   0.0 |  0.00
Modify  | 0.12321    | 0.12321    | 0.12321    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541034
Ave neighs/atom = 135.2585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.430067990697, Press = 0.0788403608347707
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -17455.592     -17455.592     -17625.707     -17625.707      329.09992      329.09992      44125.072      44125.072      2409.0216      2409.0216    
     61000  -17447.906     -17447.906     -17623.654     -17623.654      339.9954       339.9954       44216.317      44216.317     -974.02158     -974.02158    
Loop time of 74.3893 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.664 hours/ns, 13.443 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    | 74.232     | 74.232     | 74.232     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023067   | 0.023067   | 0.023067   |   0.0 |  0.03
Output  | 4.0256e-05 | 4.0256e-05 | 4.0256e-05 |   0.0 |  0.00
Modify  | 0.1234     | 0.1234     | 0.1234     |   0.0 |  0.17
Other   |            | 0.01078    |            |       |  0.01

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

Total # of neighbors = 541382
Ave neighs/atom = 135.3455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.437068527039, Press = -1.42578015503127
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -17447.906     -17447.906     -17623.654     -17623.654      339.9954       339.9954       44216.317      44216.317     -974.02158     -974.02158    
     62000  -17456.045     -17456.045     -17626.525     -17626.525      329.80385      329.80385      44228.119      44228.119     -1921.062      -1921.062     
Loop time of 74.1613 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.600 hours/ns, 13.484 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    | 74.004     | 74.004     | 74.004     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023028   | 0.023028   | 0.023028   |   0.0 |  0.03
Output  | 4.8411e-05 | 4.8411e-05 | 4.8411e-05 |   0.0 |  0.00
Modify  | 0.12315    | 0.12315    | 0.12315    |   0.0 |  0.17
Other   |            | 0.01078    |            |       |  0.01

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

Total # of neighbors = 541086
Ave neighs/atom = 135.2715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.467023724236, Press = 0.289435740749243
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -17456.045     -17456.045     -17626.525     -17626.525      329.80385      329.80385      44228.119      44228.119     -1921.062      -1921.062     
     63000  -17453.435     -17453.435     -17625.913     -17625.913      333.67177      333.67177      44163.756      44163.756      820.54502      820.54502    
Loop time of 74.3247 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.646 hours/ns, 13.454 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    | 74.168     | 74.168     | 74.168     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022709   | 0.022709   | 0.022709   |   0.0 |  0.03
Output  | 5.0325e-05 | 5.0325e-05 | 5.0325e-05 |   0.0 |  0.00
Modify  | 0.12304    | 0.12304    | 0.12304    |   0.0 |  0.17
Other   |            | 0.01082    |            |       |  0.01

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

Total # of neighbors = 540952
Ave neighs/atom = 135.238
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.468461055047, Press = 0.371679152823608
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -17453.435     -17453.435     -17625.913     -17625.913      333.67177      333.67177      44163.756      44163.756      820.54502      820.54502    
     64000  -17452.744     -17452.744     -17623.807     -17623.807      330.9329       330.9329       44178.945      44178.945      491.34144      491.34144    
Loop time of 74.3927 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.665 hours/ns, 13.442 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    | 74.236     | 74.236     | 74.236     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023001   | 0.023001   | 0.023001   |   0.0 |  0.03
Output  | 5.0425e-05 | 5.0425e-05 | 5.0425e-05 |   0.0 |  0.00
Modify  | 0.12305    | 0.12305    | 0.12305    |   0.0 |  0.17
Other   |            | 0.0108     |            |       |  0.01

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

Total # of neighbors = 541388
Ave neighs/atom = 135.347
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.463863388233, Press = -0.351812965397902
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -17452.744     -17452.744     -17623.807     -17623.807      330.9329       330.9329       44178.945      44178.945      491.34144      491.34144    
     65000  -17456.555     -17456.555     -17624.056     -17624.056      324.04323      324.04323      44188.288      44188.288     -39.728283     -39.728283    
Loop time of 74.3568 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.655 hours/ns, 13.449 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    | 74.2       | 74.2       | 74.2       |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022982   | 0.022982   | 0.022982   |   0.0 |  0.03
Output  | 6.5834e-05 | 6.5834e-05 | 6.5834e-05 |   0.0 |  0.00
Modify  | 0.12321    | 0.12321    | 0.12321    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541134
Ave neighs/atom = 135.2835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.462517018706, Press = -0.19557201098957
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -17456.555     -17456.555     -17624.056     -17624.056      324.04323      324.04323      44188.288      44188.288     -39.728283     -39.728283    
     66000  -17449.409     -17449.409     -17623.566     -17623.566      336.91791      336.91791      44196.641      44196.641     -189.01656     -189.01656    
Loop time of 74.4123 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.670 hours/ns, 13.439 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    | 74.255     | 74.255     | 74.255     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02287    | 0.02287    | 0.02287    |   0.0 |  0.03
Output  | 6.0143e-05 | 6.0143e-05 | 6.0143e-05 |   0.0 |  0.00
Modify  | 0.12329    | 0.12329    | 0.12329    |   0.0 |  0.17
Other   |            | 0.01082    |            |       |  0.01

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

Total # of neighbors = 541312
Ave neighs/atom = 135.328
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.448248124896, Press = 0.122164494834131
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -17449.409     -17449.409     -17623.566     -17623.566      336.91791      336.91791      44196.641      44196.641     -189.01656     -189.01656    
     67000  -17456.454     -17456.454     -17627.198     -17627.198      330.31439      330.31439      44165.574      44165.574      581.52112      581.52112    
Loop time of 74.374 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.659 hours/ns, 13.446 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    | 74.217     | 74.217     | 74.217     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022953   | 0.022953   | 0.022953   |   0.0 |  0.03
Output  | 6.0594e-05 | 6.0594e-05 | 6.0594e-05 |   0.0 |  0.00
Modify  | 0.12318    | 0.12318    | 0.12318    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541280
Ave neighs/atom = 135.32
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.444231340726, Press = -0.0609359390160248
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -17456.454     -17456.454     -17627.198     -17627.198      330.31439      330.31439      44165.574      44165.574      581.52112      581.52112    
     68000  -17453.257     -17453.257     -17624.615     -17624.615      331.50344      331.50344      44215.856      44215.856     -1199.3186     -1199.3186    
Loop time of 74.0557 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.167 ns/day, 20.571 hours/ns, 13.503 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    | 73.899     | 73.899     | 73.899     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023      | 0.023      | 0.023      |   0.0 |  0.03
Output  | 6.414e-05  | 6.414e-05  | 6.414e-05  |   0.0 |  0.00
Modify  | 0.1231     | 0.1231     | 0.1231     |   0.0 |  0.17
Other   |            | 0.0108     |            |       |  0.01

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

Total # of neighbors = 541150
Ave neighs/atom = 135.2875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.447317543026, Press = -0.591499663256093
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -17453.257     -17453.257     -17624.615     -17624.615      331.50344      331.50344      44215.856      44215.856     -1199.3186     -1199.3186    
     69000  -17456.777     -17456.777     -17628.443     -17628.443      332.09964      332.09964      44203.984      44203.984     -1008.6393     -1008.6393    
Loop time of 74.082 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.166 ns/day, 20.578 hours/ns, 13.499 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    | 73.925     | 73.925     | 73.925     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022888   | 0.022888   | 0.022888   |   0.0 |  0.03
Output  | 6.4611e-05 | 6.4611e-05 | 6.4611e-05 |   0.0 |  0.00
Modify  | 0.12331    | 0.12331    | 0.12331    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

Total # of neighbors = 541016
Ave neighs/atom = 135.254
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.443738514877, Press = 0.943438532701631
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -17456.777     -17456.777     -17628.443     -17628.443      332.09964      332.09964      44203.984      44203.984     -1008.6393     -1008.6393    
     70000  -17450.513     -17450.513     -17628.191     -17628.191      343.72949      343.72949      44132.472      44132.472      2014.955       2014.955     
Loop time of 74.323 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.645 hours/ns, 13.455 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    | 74.166     | 74.166     | 74.166     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022642   | 0.022642   | 0.022642   |   0.0 |  0.03
Output  | 5.7999e-05 | 5.7999e-05 | 5.7999e-05 |   0.0 |  0.00
Modify  | 0.12328    | 0.12328    | 0.12328    |   0.0 |  0.17
Other   |            | 0.01074    |            |       |  0.01

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

Total # of neighbors = 540990
Ave neighs/atom = 135.2475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.424922931867, Press = 0.0977341759839026
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -17450.513     -17450.513     -17628.191     -17628.191      343.72949      343.72949      44132.472      44132.472      2014.955       2014.955     
     71000  -17458.286     -17458.286     -17629.189     -17629.189      330.62288      330.62288      44178.226      44178.226     -81.620903     -81.620903    
Loop time of 74.1781 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.605 hours/ns, 13.481 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    | 74.02      | 74.02      | 74.02      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023425   | 0.023425   | 0.023425   |   0.0 |  0.03
Output  | 6.3359e-05 | 6.3359e-05 | 6.3359e-05 |   0.0 |  0.00
Modify  | 0.1233     | 0.1233     | 0.1233     |   0.0 |  0.17
Other   |            | 0.01081    |            |       |  0.01

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

Total # of neighbors = 541336
Ave neighs/atom = 135.334
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.400623766683, Press = -0.715076323082071
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -17458.286     -17458.286     -17629.189     -17629.189      330.62288      330.62288      44178.226      44178.226     -81.620903     -81.620903    
     72000  -17452.484     -17452.484     -17622.57      -17622.57       329.04343      329.04343      44210.441      44210.441     -880.83141     -880.83141    
Loop time of 74.1746 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.604 hours/ns, 13.482 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    | 74.018     | 74.018     | 74.018     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022774   | 0.022774   | 0.022774   |   0.0 |  0.03
Output  | 6.2207e-05 | 6.2207e-05 | 6.2207e-05 |   0.0 |  0.00
Modify  | 0.12316    | 0.12316    | 0.12316    |   0.0 |  0.17
Other   |            | 0.01077    |            |       |  0.01

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

Total # of neighbors = 541178
Ave neighs/atom = 135.2945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.36903118355, Press = -0.0716415341039983
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -17452.484     -17452.484     -17622.57      -17622.57       329.04343      329.04343      44210.441      44210.441     -880.83141     -880.83141    
     73000  -17457.887     -17457.887     -17628.948     -17628.948      330.9296       330.9296       44171.232      44171.232      162.71471      162.71471    
Loop time of 74.3164 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.643 hours/ns, 13.456 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    | 74.159     | 74.159     | 74.159     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023022   | 0.023022   | 0.023022   |   0.0 |  0.03
Output  | 6.9029e-05 | 6.9029e-05 | 6.9029e-05 |   0.0 |  0.00
Modify  | 0.1232     | 0.1232     | 0.1232     |   0.0 |  0.17
Other   |            | 0.01076    |            |       |  0.01

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

Total # of neighbors = 541226
Ave neighs/atom = 135.3065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.352200566593, Press = 0.0522440310240848
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -17457.887     -17457.887     -17628.948     -17628.948      330.9296       330.9296       44171.232      44171.232      162.71471      162.71471    
     74000  -17453.149     -17453.149     -17625.302     -17625.302      333.04233      333.04233      44183.399      44183.399      24.270864      24.270864    
Loop time of 74.304 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.640 hours/ns, 13.458 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    | 74.147     | 74.147     | 74.147     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022862   | 0.022862   | 0.022862   |   0.0 |  0.03
Output  | 5.6296e-05 | 5.6296e-05 | 5.6296e-05 |   0.0 |  0.00
Modify  | 0.12325    | 0.12325    | 0.12325    |   0.0 |  0.17
Other   |            | 0.01079    |            |       |  0.01

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0