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

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

kim_interactions Mo

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

kim interactions Mo
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_ParkFellingerLenosky_2012_Mo__MO_269937397263_002
pair_coeff * * Mo
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 95.94

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 31777.0908166668 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_269937397263_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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13559.008     -13559.008     -13634.755     -13634.755      293.15         293.15         31777.091      31777.091      2546.0514      2546.0514    
      1000  -13482.51      -13482.51      -13556.574     -13556.574      286.63313      286.63313      31989.635      31989.635     -4177.02       -4177.02      
Loop time of 578.615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.149 ns/day, 160.727 hours/ns, 1.728 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 578.09     | 578.09     | 578.09     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09874    | 0.09874    | 0.09874    |   0.0 |  0.02
Output  | 0.00027306 | 0.00027306 | 0.00027306 |   0.0 |  0.00
Modify  | 0.36831    | 0.36831    | 0.36831    |   0.0 |  0.06
Other   |            | 0.06311    |            |       |  0.01

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

Total # of neighbors = 272000
Ave neighs/atom = 136
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13482.51      -13482.51      -13556.574     -13556.574      286.63313      286.63313      31989.635      31989.635     -4177.02       -4177.02      
      2000  -13480.705     -13480.705     -13554.468     -13554.468      285.47006      285.47006      31915.589      31915.589      1205.8947      1205.8947    
Loop time of 596.952 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.820 hours/ns, 1.675 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.39     | 596.39     | 596.39     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10886    | 0.10886    | 0.10886    |   0.0 |  0.02
Output  | 0.00023654 | 0.00023654 | 0.00023654 |   0.0 |  0.00
Modify  | 0.38776    | 0.38776    | 0.38776    |   0.0 |  0.06
Other   |            | 0.06647    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4406 ave        4406 max        4406 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:       269878 ave      269878 max      269878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269878
Ave neighs/atom = 134.939
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13480.705     -13480.705     -13554.468     -13554.468      285.47006      285.47006      31915.589      31915.589      1205.8947      1205.8947    
      3000  -13484.174     -13484.174     -13562.591     -13562.591      303.48023      303.48023      31936.976      31936.976     -1131.308      -1131.308     
Loop time of 597.066 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.852 hours/ns, 1.675 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.5      | 596.5      | 596.5      |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10961    | 0.10961    | 0.10961    |   0.0 |  0.02
Output  | 0.00024279 | 0.00024279 | 0.00024279 |   0.0 |  0.00
Modify  | 0.38812    | 0.38812    | 0.38812    |   0.0 |  0.07
Other   |            | 0.06637    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4455 ave        4455 max        4455 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:       269834 ave      269834 max      269834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269834
Ave neighs/atom = 134.917
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13484.174     -13484.174     -13562.591     -13562.591      303.48023      303.48023      31936.976      31936.976     -1131.308      -1131.308     
      4000  -13479.785     -13479.785     -13559.433     -13559.433      308.24661      308.24661      31910.306      31910.306      1499.3457      1499.3457    
Loop time of 597.451 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.959 hours/ns, 1.674 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.89     | 596.89     | 596.89     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11106    | 0.11106    | 0.11106    |   0.0 |  0.02
Output  | 0.00020208 | 0.00020208 | 0.00020208 |   0.0 |  0.00
Modify  | 0.3881     | 0.3881     | 0.3881     |   0.0 |  0.06
Other   |            | 0.06594    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4457 ave        4457 max        4457 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:       270348 ave      270348 max      270348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270348
Ave neighs/atom = 135.174
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13479.785     -13479.785     -13559.433     -13559.433      308.24661      308.24661      31910.306      31910.306      1499.3457      1499.3457    
      5000  -13483.548     -13483.548     -13554.817     -13554.817      275.81817      275.81817      31933.643      31933.643      405.83927      405.83927    
Loop time of 601.869 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 167.186 hours/ns, 1.661 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 601.3      | 601.3      | 601.3      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10982    | 0.10982    | 0.10982    |   0.0 |  0.02
Output  | 0.00024792 | 0.00024792 | 0.00024792 |   0.0 |  0.00
Modify  | 0.39535    | 0.39535    | 0.39535    |   0.0 |  0.07
Other   |            | 0.06649    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4430 ave        4430 max        4430 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:       270420 ave      270420 max      270420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270420
Ave neighs/atom = 135.21
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 = 286.235504396471, Press = 381.614020339291
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13483.548     -13483.548     -13554.817     -13554.817      275.81817      275.81817      31933.643      31933.643      405.83927      405.83927    
      6000  -13481.721     -13481.721     -13559.922     -13559.922      302.64433      302.64433      31903.71       31903.71       2044.7596      2044.7596    
Loop time of 598.923 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.367 hours/ns, 1.670 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 598.33     | 598.33     | 598.33     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11008    | 0.11008    | 0.11008    |   0.0 |  0.02
Output  | 0.00016999 | 0.00016999 | 0.00016999 |   0.0 |  0.00
Modify  | 0.41218    | 0.41218    | 0.41218    |   0.0 |  0.07
Other   |            | 0.06568    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4444 ave        4444 max        4444 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:       270090 ave      270090 max      270090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270090
Ave neighs/atom = 135.045
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 = 292.183638981235, Press = 25.7647992307559
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13481.721     -13481.721     -13559.922     -13559.922      302.64433      302.64433      31903.71       31903.71       2044.7596      2044.7596    
      7000  -13481.667     -13481.667     -13564.457     -13564.457      320.40265      320.40265      31961.631      31961.631     -2696.1947     -2696.1947    
Loop time of 597.403 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.945 hours/ns, 1.674 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.82     | 596.82     | 596.82     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11048    | 0.11048    | 0.11048    |   0.0 |  0.02
Output  | 0.00016476 | 0.00016476 | 0.00016476 |   0.0 |  0.00
Modify  | 0.40887    | 0.40887    | 0.40887    |   0.0 |  0.07
Other   |            | 0.06636    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4475 ave        4475 max        4475 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:       270290 ave      270290 max      270290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270290
Ave neighs/atom = 135.145
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 = 291.850773194569, Press = 17.5017684123686
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13481.667     -13481.667     -13564.457     -13564.457      320.40265      320.40265      31961.631      31961.631     -2696.1947     -2696.1947    
      8000  -13481.188     -13481.188     -13555.911     -13555.911      289.1861       289.1861       31899.166      31899.166      2463.9937      2463.9937    
Loop time of 590.569 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.047 hours/ns, 1.693 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 589.99     | 589.99     | 589.99     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10852    | 0.10852    | 0.10852    |   0.0 |  0.02
Output  | 0.00020801 | 0.00020801 | 0.00020801 |   0.0 |  0.00
Modify  | 0.40368    | 0.40368    | 0.40368    |   0.0 |  0.07
Other   |            | 0.06544    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4437 ave        4437 max        4437 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:       270484 ave      270484 max      270484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270484
Ave neighs/atom = 135.242
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 = 292.382789285204, Press = 16.5531196145332
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13481.188     -13481.188     -13555.911     -13555.911      289.1861       289.1861       31899.166      31899.166      2463.9937      2463.9937    
      9000  -13482.442     -13482.442     -13558.98      -13558.98       296.21162      296.21162      31951.01       31951.01      -1694.4257     -1694.4257    
Loop time of 592.893 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.693 hours/ns, 1.687 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 592.31     | 592.31     | 592.31     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11019    | 0.11019    | 0.11019    |   0.0 |  0.02
Output  | 0.00029153 | 0.00029153 | 0.00029153 |   0.0 |  0.00
Modify  | 0.40767    | 0.40767    | 0.40767    |   0.0 |  0.07
Other   |            | 0.06577    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4482 ave        4482 max        4482 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:       270046 ave      270046 max      270046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270046
Ave neighs/atom = 135.023
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 = 292.241371686153, Press = 1.03520116123699
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13482.442     -13482.442     -13558.98      -13558.98       296.21162      296.21162      31951.01       31951.01      -1694.4257     -1694.4257    
     10000  -13482.136     -13482.136     -13558.388     -13558.388      295.10208      295.10208      31956.283      31956.283     -2162.5264     -2162.5264    
Loop time of 587.739 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.261 hours/ns, 1.701 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 587.16     | 587.16     | 587.16     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10901    | 0.10901    | 0.10901    |   0.0 |  0.02
Output  | 0.000207   | 0.000207   | 0.000207   |   0.0 |  0.00
Modify  | 0.40197    | 0.40197    | 0.40197    |   0.0 |  0.07
Other   |            | 0.06531    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4496 ave        4496 max        4496 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:       270226 ave      270226 max      270226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270226
Ave neighs/atom = 135.113
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 = 292.393572925485, Press = 7.93373501774373
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13482.136     -13482.136     -13558.388     -13558.388      295.10208      295.10208      31956.283      31956.283     -2162.5264     -2162.5264    
     11000  -13481.833     -13481.833     -13554.114     -13554.114      279.73241      279.73241      31896.83       31896.83       2923.9198      2923.9198    
Loop time of 600.773 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.881 hours/ns, 1.665 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 600.19     | 600.19     | 600.19     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10897    | 0.10897    | 0.10897    |   0.0 |  0.02
Output  | 0.00020549 | 0.00020549 | 0.00020549 |   0.0 |  0.00
Modify  | 0.40688    | 0.40688    | 0.40688    |   0.0 |  0.07
Other   |            | 0.06518    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4424 ave        4424 max        4424 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:       270050 ave      270050 max      270050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270050
Ave neighs/atom = 135.025
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 = 292.67739473783, Press = 12.9430228833334
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13481.833     -13481.833     -13554.114     -13554.114      279.73241      279.73241      31896.83       31896.83       2923.9198      2923.9198    
     12000  -13482.896     -13482.896     -13555.127     -13555.127      279.54075      279.54075      31923.299      31923.299      758.28249      758.28249    
Loop time of 599.307 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.474 hours/ns, 1.669 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 598.72     | 598.72     | 598.72     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11221    | 0.11221    | 0.11221    |   0.0 |  0.02
Output  | 0.00016708 | 0.00016708 | 0.00016708 |   0.0 |  0.00
Modify  | 0.41224    | 0.41224    | 0.41224    |   0.0 |  0.07
Other   |            | 0.06623    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4526 ave        4526 max        4526 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:       270040 ave      270040 max      270040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270040
Ave neighs/atom = 135.02
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 = 292.814412946097, Press = 6.37792662711912
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13482.896     -13482.896     -13555.127     -13555.127      279.54075      279.54075      31923.299      31923.299      758.28249      758.28249    
     13000  -13483.778     -13483.778     -13555.748     -13555.748      278.5342       278.5342       31920.994      31920.994      876.46996      876.46996    
Loop time of 598.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.193 hours/ns, 1.671 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.71     | 597.71     | 597.71     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11167    | 0.11167    | 0.11167    |   0.0 |  0.02
Output  | 0.00016536 | 0.00016536 | 0.00016536 |   0.0 |  0.00
Modify  | 0.40953    | 0.40953    | 0.40953    |   0.0 |  0.07
Other   |            | 0.06702    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4531 ave        4531 max        4531 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:       269794 ave      269794 max      269794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269794
Ave neighs/atom = 134.897
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 = 292.657516301109, Press = 5.01436891544056
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13483.778     -13483.778     -13555.748     -13555.748      278.5342       278.5342       31920.994      31920.994      876.46996      876.46996    
     14000  -13484.058     -13484.058     -13558.158     -13558.158      286.77431      286.77431      31935.868      31935.868     -484.53639     -484.53639    
Loop time of 605.169 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 168.103 hours/ns, 1.652 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 604.57     | 604.57     | 604.57     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11117    | 0.11117    | 0.11117    |   0.0 |  0.02
Output  | 0.00017621 | 0.00017621 | 0.00017621 |   0.0 |  0.00
Modify  | 0.421      | 0.421      | 0.421      |   0.0 |  0.07
Other   |            | 0.06634    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4449 ave        4449 max        4449 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:       269978 ave      269978 max      269978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269978
Ave neighs/atom = 134.989
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 = 292.345882321609, Press = 1.71156885797724
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13484.058     -13484.058     -13558.158     -13558.158      286.77431      286.77431      31935.868      31935.868     -484.53639     -484.53639    
     15000  -13483.459     -13483.459     -13556.57      -13556.57       282.94671      282.94671      31890.839      31890.839      3113.0045      3113.0045    
Loop time of 598.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.225 hours/ns, 1.671 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.82     | 597.82     | 597.82     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11214    | 0.11214    | 0.11214    |   0.0 |  0.02
Output  | 0.0001655  | 0.0001655  | 0.0001655  |   0.0 |  0.00
Modify  | 0.41357    | 0.41357    | 0.41357    |   0.0 |  0.07
Other   |            | 0.06595    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4531 ave        4531 max        4531 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:       270314 ave      270314 max      270314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270314
Ave neighs/atom = 135.157
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 = 292.335459718827, Press = 7.79175653012761
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13483.459     -13483.459     -13556.57      -13556.57       282.94671      282.94671      31890.839      31890.839      3113.0045      3113.0045    
     16000  -13481.267     -13481.267     -13556.025     -13556.025      289.32376      289.32376      31942.863      31942.863     -970.10965     -970.10965    
Loop time of 595.275 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.354 hours/ns, 1.680 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 594.69     | 594.69     | 594.69     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11029    | 0.11029    | 0.11029    |   0.0 |  0.02
Output  | 0.0002442  | 0.0002442  | 0.0002442  |   0.0 |  0.00
Modify  | 0.40908    | 0.40908    | 0.40908    |   0.0 |  0.07
Other   |            | 0.06557    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4480 ave        4480 max        4480 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:       270064 ave      270064 max      270064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270064
Ave neighs/atom = 135.032
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 = 292.518235182154, Press = -4.35741276152472
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13481.267     -13481.267     -13556.025     -13556.025      289.32376      289.32376      31942.863      31942.863     -970.10965     -970.10965    
     17000  -13484.231     -13484.231     -13556.104     -13556.104      278.15284      278.15284      31929.577      31929.577     -106.15328     -106.15328    
Loop time of 595.613 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.448 hours/ns, 1.679 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.02     | 595.02     | 595.02     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11171    | 0.11171    | 0.11171    |   0.0 |  0.02
Output  | 0.0002009  | 0.0002009  | 0.0002009  |   0.0 |  0.00
Modify  | 0.41486    | 0.41486    | 0.41486    |   0.0 |  0.07
Other   |            | 0.06596    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4494 ave        4494 max        4494 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:       269750 ave      269750 max      269750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269750
Ave neighs/atom = 134.875
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 = 292.517511639545, Press = 4.57455016596092
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13484.231     -13484.231     -13556.104     -13556.104      278.15284      278.15284      31929.577      31929.577     -106.15328     -106.15328    
     18000  -13482.828     -13482.828     -13560.937     -13560.937      302.28698      302.28698      31933.891      31933.891     -410.29621     -410.29621    
Loop time of 596.366 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.657 hours/ns, 1.677 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.78     | 595.78     | 595.78     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10956    | 0.10956    | 0.10956    |   0.0 |  0.02
Output  | 0.000224   | 0.000224   | 0.000224   |   0.0 |  0.00
Modify  | 0.4079     | 0.4079     | 0.4079     |   0.0 |  0.07
Other   |            | 0.06591    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4464 ave        4464 max        4464 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:       269968 ave      269968 max      269968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269968
Ave neighs/atom = 134.984
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 = 292.667830974602, Press = -0.664733694614036
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13482.828     -13482.828     -13560.937     -13560.937      302.28698      302.28698      31933.891      31933.891     -410.29621     -410.29621    
     19000  -13483.44      -13483.44      -13556.862     -13556.862      284.152        284.152        31949.904      31949.904     -1457.2041     -1457.2041    
Loop time of 595.71 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.475 hours/ns, 1.679 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.12     | 595.12     | 595.12     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11152    | 0.11152    | 0.11152    |   0.0 |  0.02
Output  | 0.00016442 | 0.00016442 | 0.00016442 |   0.0 |  0.00
Modify  | 0.40857    | 0.40857    | 0.40857    |   0.0 |  0.07
Other   |            | 0.06575    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4532 ave        4532 max        4532 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:       270056 ave      270056 max      270056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270056
Ave neighs/atom = 135.028
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 = 292.810385573925, Press = 2.87644702675816
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13483.44      -13483.44      -13556.862     -13556.862      284.152        284.152        31949.904      31949.904     -1457.2041     -1457.2041    
     20000  -13481.824     -13481.824     -13557.033     -13557.033      291.06476      291.06476      31927.1        31927.1        128.06621      128.06621    
Loop time of 597.742 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 166.040 hours/ns, 1.673 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.16     | 597.16     | 597.16     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10945    | 0.10945    | 0.10945    |   0.0 |  0.02
Output  | 0.00016894 | 0.00016894 | 0.00016894 |   0.0 |  0.00
Modify  | 0.40698    | 0.40698    | 0.40698    |   0.0 |  0.07
Other   |            | 0.0659     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4459 ave        4459 max        4459 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:       269882 ave      269882 max      269882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269882
Ave neighs/atom = 134.941
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 = 292.964050824979, Press = 5.02699535142278
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13481.824     -13481.824     -13557.033     -13557.033      291.06476      291.06476      31927.1        31927.1        128.06621      128.06621    
     21000  -13484.859     -13484.859     -13557.453     -13557.453      280.9434       280.9434       31921.846      31921.846      574.2347       574.2347     
Loop time of 598.025 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.118 hours/ns, 1.672 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.44     | 597.44     | 597.44     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1098     | 0.1098     | 0.1098     |   0.0 |  0.02
Output  | 0.0001647  | 0.0001647  | 0.0001647  |   0.0 |  0.00
Modify  | 0.40975    | 0.40975    | 0.40975    |   0.0 |  0.07
Other   |            | 0.06612    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4474 ave        4474 max        4474 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:       270158 ave      270158 max      270158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270158
Ave neighs/atom = 135.079
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 = 292.990965324641, Press = 0.299058707837577
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13484.859     -13484.859     -13557.453     -13557.453      280.9434       280.9434       31921.846      31921.846      574.2347       574.2347     
     22000  -13481.976     -13481.976     -13557.572     -13557.572      292.56604      292.56604      31916.511      31916.511      1069.0603      1069.0603    
Loop time of 595.737 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.482 hours/ns, 1.679 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.15     | 595.15     | 595.15     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11112    | 0.11112    | 0.11112    |   0.0 |  0.02
Output  | 0.00016629 | 0.00016629 | 0.00016629 |   0.0 |  0.00
Modify  | 0.40999    | 0.40999    | 0.40999    |   0.0 |  0.07
Other   |            | 0.06538    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4489 ave        4489 max        4489 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:       270086 ave      270086 max      270086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270086
Ave neighs/atom = 135.043
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 = 292.925419830509, Press = 3.14542413038996
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13481.976     -13481.976     -13557.572     -13557.572      292.56604      292.56604      31916.511      31916.511      1069.0603      1069.0603    
     23000  -13484.266     -13484.266     -13559.194     -13559.194      289.97821      289.97821      31922.047      31922.047      527.91704      527.91704    
Loop time of 598.519 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.255 hours/ns, 1.671 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.93     | 597.93     | 597.93     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11029    | 0.11029    | 0.11029    |   0.0 |  0.02
Output  | 0.00021376 | 0.00021376 | 0.00021376 |   0.0 |  0.00
Modify  | 0.41157    | 0.41157    | 0.41157    |   0.0 |  0.07
Other   |            | 0.06576    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4459 ave        4459 max        4459 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:       270036 ave      270036 max      270036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270036
Ave neighs/atom = 135.018
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 = 292.773033093542, Press = -3.05462266357022
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13484.266     -13484.266     -13559.194     -13559.194      289.97821      289.97821      31922.047      31922.047      527.91704      527.91704    
     24000  -13482.219     -13482.219     -13560.788     -13560.788      304.07108      304.07108      31950.058      31950.058     -1692.5358     -1692.5358    
Loop time of 597.666 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 166.018 hours/ns, 1.673 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.08     | 597.08     | 597.08     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11082    | 0.11082    | 0.11082    |   0.0 |  0.02
Output  | 0.00016305 | 0.00016305 | 0.00016305 |   0.0 |  0.00
Modify  | 0.41138    | 0.41138    | 0.41138    |   0.0 |  0.07
Other   |            | 0.06683    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4497 ave        4497 max        4497 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:       270310 ave      270310 max      270310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270310
Ave neighs/atom = 135.155
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 = 292.73038053865, Press = 3.14304580185083
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13482.219     -13482.219     -13560.788     -13560.788      304.07108      304.07108      31950.058      31950.058     -1692.5358     -1692.5358    
     25000  -13484.352     -13484.352     -13557.887     -13557.887      284.59016      284.59016      31909.849      31909.849      1341.7062      1341.7062    
Loop time of 598.108 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.141 hours/ns, 1.672 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.52     | 597.52     | 597.52     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10904    | 0.10904    | 0.10904    |   0.0 |  0.02
Output  | 0.00025446 | 0.00025446 | 0.00025446 |   0.0 |  0.00
Modify  | 0.41175    | 0.41175    | 0.41175    |   0.0 |  0.07
Other   |            | 0.06594    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4402 ave        4402 max        4402 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:       270116 ave      270116 max      270116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270116
Ave neighs/atom = 135.058
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 = 292.757968269035, Press = -0.091608456680927
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13484.352     -13484.352     -13557.887     -13557.887      284.59016      284.59016      31909.849      31909.849      1341.7062      1341.7062    
     26000  -13482.066     -13482.066     -13557.689     -13557.689      292.66651      292.66651      31943.011      31943.011     -1080.3452     -1080.3452    
Loop time of 600.383 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.773 hours/ns, 1.666 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.79     | 599.79     | 599.79     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11122    | 0.11122    | 0.11122    |   0.0 |  0.02
Output  | 0.00016383 | 0.00016383 | 0.00016383 |   0.0 |  0.00
Modify  | 0.4128     | 0.4128     | 0.4128     |   0.0 |  0.07
Other   |            | 0.06598    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4497 ave        4497 max        4497 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:       269946 ave      269946 max      269946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269946
Ave neighs/atom = 134.973
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 = 292.907432051914, Press = 1.60930221997647
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13482.066     -13482.066     -13557.689     -13557.689      292.66651      292.66651      31943.011      31943.011     -1080.3452     -1080.3452    
     27000  -13483.493     -13483.493     -13562.789     -13562.789      306.88304      306.88304      31923.727      31923.727      105.06044      105.06044    
Loop time of 594.971 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.270 hours/ns, 1.681 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 594.39     | 594.39     | 594.39     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10803    | 0.10803    | 0.10803    |   0.0 |  0.02
Output  | 0.00017881 | 0.00017881 | 0.00017881 |   0.0 |  0.00
Modify  | 0.4065     | 0.4065     | 0.4065     |   0.0 |  0.07
Other   |            | 0.06517    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4419 ave        4419 max        4419 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:       270084 ave      270084 max      270084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270084
Ave neighs/atom = 135.042
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 = 293.047906671999, Press = 1.99368067555324
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13483.493     -13483.493     -13562.789     -13562.789      306.88304      306.88304      31923.727      31923.727      105.06044      105.06044    
     28000  -13481.582     -13481.582     -13556.697     -13556.697      290.70502      290.70502      31951.302      31951.302     -1433.5899     -1433.5899    
Loop time of 594.372 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.103 hours/ns, 1.682 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 593.79     | 593.79     | 593.79     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10949    | 0.10949    | 0.10949    |   0.0 |  0.02
Output  | 0.000172   | 0.000172   | 0.000172   |   0.0 |  0.00
Modify  | 0.40818    | 0.40818    | 0.40818    |   0.0 |  0.07
Other   |            | 0.06569    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4473 ave        4473 max        4473 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:       270466 ave      270466 max      270466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270466
Ave neighs/atom = 135.233
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 = 292.998704730746, Press = 0.535450491862977
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13481.582     -13481.582     -13556.697     -13556.697      290.70502      290.70502      31951.302      31951.302     -1433.5899     -1433.5899    
     29000  -13485.503     -13485.503     -13558.039     -13558.039      280.7207       280.7207       31902.405      31902.405      1849.3376      1849.3376    
Loop time of 600.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.783 hours/ns, 1.666 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.83     | 599.83     | 599.83     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10992    | 0.10992    | 0.10992    |   0.0 |  0.02
Output  | 0.00017022 | 0.00017022 | 0.00017022 |   0.0 |  0.00
Modify  | 0.41193    | 0.41193    | 0.41193    |   0.0 |  0.07
Other   |            | 0.06574    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4433 ave        4433 max        4433 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:       269952 ave      269952 max      269952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269952
Ave neighs/atom = 134.976
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 = 292.931463685676, Press = 2.79101907745067
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13485.503     -13485.503     -13558.039     -13558.039      280.7207       280.7207       31902.405      31902.405      1849.3376      1849.3376    
     30000  -13481.644     -13481.644     -13558.332     -13558.332      296.7906       296.7906       31944.793      31944.793     -1086.3344     -1086.3344    
Loop time of 601.039 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.955 hours/ns, 1.664 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 600.45     | 600.45     | 600.45     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10978    | 0.10978    | 0.10978    |   0.0 |  0.02
Output  | 0.00016743 | 0.00016743 | 0.00016743 |   0.0 |  0.00
Modify  | 0.41143    | 0.41143    | 0.41143    |   0.0 |  0.07
Other   |            | 0.06564    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4453 ave        4453 max        4453 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:       270162 ave      270162 max      270162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270162
Ave neighs/atom = 135.081
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 = 292.861353140155, Press = -0.419789289808241
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13481.644     -13481.644     -13558.332     -13558.332      296.7906       296.7906       31944.793      31944.793     -1086.3344     -1086.3344    
     31000  -13484.919     -13484.919     -13560.538     -13560.538      292.65358      292.65358      31907.995      31907.995      1246.3008      1246.3008    
Loop time of 598.39 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.219 hours/ns, 1.671 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.81     | 597.81     | 597.81     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10883    | 0.10883    | 0.10883    |   0.0 |  0.02
Output  | 0.00027856 | 0.00027856 | 0.00027856 |   0.0 |  0.00
Modify  | 0.4039     | 0.4039     | 0.4039     |   0.0 |  0.07
Other   |            | 0.06489    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4412 ave        4412 max        4412 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:       270118 ave      270118 max      270118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270118
Ave neighs/atom = 135.059
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 = 292.837444046566, Press = 3.52324833945206
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13484.919     -13484.919     -13560.538     -13560.538      292.65358      292.65358      31907.995      31907.995      1246.3008      1246.3008    
     32000  -13482.45      -13482.45      -13556.167     -13556.167      285.29281      285.29281      31930.225      31930.225      135.2344       135.2344     
Loop time of 597.004 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.835 hours/ns, 1.675 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.42     | 596.42     | 596.42     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10913    | 0.10913    | 0.10913    |   0.0 |  0.02
Output  | 0.00016556 | 0.00016556 | 0.00016556 |   0.0 |  0.00
Modify  | 0.40753    | 0.40753    | 0.40753    |   0.0 |  0.07
Other   |            | 0.06539    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4432 ave        4432 max        4432 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:       270440 ave      270440 max      270440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270440
Ave neighs/atom = 135.22
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.811267391926, Press = -1.18367575145914
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13482.45      -13482.45      -13556.167     -13556.167      285.29281      285.29281      31930.225      31930.225      135.2344       135.2344     
     33000  -13479.519     -13479.519     -13557.3       -13557.3        301.01996      301.01996      31937.984      31937.984     -377.48503     -377.48503    
Loop time of 595.774 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.493 hours/ns, 1.678 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.19     | 595.19     | 595.19     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10881    | 0.10881    | 0.10881    |   0.0 |  0.02
Output  | 0.00016927 | 0.00016927 | 0.00016927 |   0.0 |  0.00
Modify  | 0.40805    | 0.40805    | 0.40805    |   0.0 |  0.07
Other   |            | 0.06518    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4446 ave        4446 max        4446 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:       270046 ave      270046 max      270046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270046
Ave neighs/atom = 135.023
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 = 292.811689254501, Press = 1.51883052505571
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13479.519     -13479.519     -13557.3       -13557.3        301.01996      301.01996      31937.984      31937.984     -377.48503     -377.48503    
     34000  -13483.458     -13483.458     -13559.283     -13559.283      293.45045      293.45045      31925.103      31925.103      171.57958      171.57958    
Loop time of 599.116 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.421 hours/ns, 1.669 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 598.53     | 598.53     | 598.53     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10979    | 0.10979    | 0.10979    |   0.0 |  0.02
Output  | 0.00021343 | 0.00021343 | 0.00021343 |   0.0 |  0.00
Modify  | 0.41299    | 0.41299    | 0.41299    |   0.0 |  0.07
Other   |            | 0.06555    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4423 ave        4423 max        4423 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:       270180 ave      270180 max      270180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270180
Ave neighs/atom = 135.09
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 = 292.854951281173, Press = 1.0713263711941
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13483.458     -13483.458     -13559.283     -13559.283      293.45045      293.45045      31925.103      31925.103      171.57958      171.57958    
     35000  -13481.926     -13481.926     -13557.464     -13557.464      292.33843      292.33843      31939.683      31939.683     -597.62512     -597.62512    
Loop time of 600.362 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.767 hours/ns, 1.666 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.77     | 599.77     | 599.77     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11165    | 0.11165    | 0.11165    |   0.0 |  0.02
Output  | 0.00023294 | 0.00023294 | 0.00023294 |   0.0 |  0.00
Modify  | 0.41707    | 0.41707    | 0.41707    |   0.0 |  0.07
Other   |            | 0.06658    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4475 ave        4475 max        4475 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:       270282 ave      270282 max      270282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270282
Ave neighs/atom = 135.141
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 = 292.901634808792, Press = 1.22414554211511
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13481.926     -13481.926     -13557.464     -13557.464      292.33843      292.33843      31939.683      31939.683     -597.62512     -597.62512    
     36000  -13481.061     -13481.061     -13558.733     -13558.733      300.5987       300.5987       31928.81       31928.81       5.3175265      5.3175265    
Loop time of 602.639 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.400 hours/ns, 1.659 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 602.05     | 602.05     | 602.05     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10873    | 0.10873    | 0.10873    |   0.0 |  0.02
Output  | 0.00016324 | 0.00016324 | 0.00016324 |   0.0 |  0.00
Modify  | 0.41686    | 0.41686    | 0.41686    |   0.0 |  0.07
Other   |            | 0.06612    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4364 ave        4364 max        4364 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:       270134 ave      270134 max      270134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270134
Ave neighs/atom = 135.067
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 = 292.930563893246, Press = 1.03560734391149
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13481.061     -13481.061     -13558.733     -13558.733      300.5987       300.5987       31928.81       31928.81       5.3175265      5.3175265    
     37000  -13481.693     -13481.693     -13558.707     -13558.707      298.0542       298.0542       31939.449      31939.449     -785.71969     -785.71969    
Loop time of 603.191 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.553 hours/ns, 1.658 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 602.59     | 602.59     | 602.59     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11112    | 0.11112    | 0.11112    |   0.0 |  0.02
Output  | 0.0001661  | 0.0001661  | 0.0001661  |   0.0 |  0.00
Modify  | 0.41895    | 0.41895    | 0.41895    |   0.0 |  0.07
Other   |            | 0.06727    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4423 ave        4423 max        4423 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:       270300 ave      270300 max      270300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270300
Ave neighs/atom = 135.15
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 = 293.033455326798, Press = 0.330990741418723
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13481.693     -13481.693     -13558.707     -13558.707      298.0542       298.0542       31939.449      31939.449     -785.71969     -785.71969    
     38000  -13481.89      -13481.89      -13558.243     -13558.243      295.49091      295.49091      31922.005      31922.005      652.66476      652.66476    
Loop time of 599.768 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.602 hours/ns, 1.667 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.18     | 599.18     | 599.18     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10836    | 0.10836    | 0.10836    |   0.0 |  0.02
Output  | 0.00016675 | 0.00016675 | 0.00016675 |   0.0 |  0.00
Modify  | 0.4132     | 0.4132     | 0.4132     |   0.0 |  0.07
Other   |            | 0.066      |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4394 ave        4394 max        4394 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:       270226 ave      270226 max      270226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270226
Ave neighs/atom = 135.113
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 = 293.026388293882, Press = 1.56772083767234
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13481.89      -13481.89      -13558.243     -13558.243      295.49091      295.49091      31922.005      31922.005      652.66476      652.66476    
     39000  -13482.823     -13482.823     -13557.544     -13557.544      289.17799      289.17799      31946.615      31946.615     -1217.1272     -1217.1272    
Loop time of 599.659 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.572 hours/ns, 1.668 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.07     | 599.07     | 599.07     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10882    | 0.10882    | 0.10882    |   0.0 |  0.02
Output  | 0.00016449 | 0.00016449 | 0.00016449 |   0.0 |  0.00
Modify  | 0.41448    | 0.41448    | 0.41448    |   0.0 |  0.07
Other   |            | 0.06576    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4424 ave        4424 max        4424 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:       270218 ave      270218 max      270218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270218
Ave neighs/atom = 135.109
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 = 293.035849882801, Press = -0.211650246301387
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13482.823     -13482.823     -13557.544     -13557.544      289.17799      289.17799      31946.615      31946.615     -1217.1272     -1217.1272    
     40000  -13483.817     -13483.817     -13559.128     -13559.128      291.46132      291.46132      31913.282      31913.282      1058.6905      1058.6905    
Loop time of 600.35 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.764 hours/ns, 1.666 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.76     | 599.76     | 599.76     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10924    | 0.10924    | 0.10924    |   0.0 |  0.02
Output  | 0.00024306 | 0.00024306 | 0.00024306 |   0.0 |  0.00
Modify  | 0.41065    | 0.41065    | 0.41065    |   0.0 |  0.07
Other   |            | 0.06611    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4426 ave        4426 max        4426 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:       269956 ave      269956 max      269956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269956
Ave neighs/atom = 134.978
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 = 292.949964222389, Press = 1.79838500297159
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13483.817     -13483.817     -13559.128     -13559.128      291.46132      291.46132      31913.282      31913.282      1058.6905      1058.6905    
     41000  -13480.744     -13480.744     -13557.618     -13557.618      297.50981      297.50981      31930.24       31930.24       110.10721      110.10721    
Loop time of 599.195 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.443 hours/ns, 1.669 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 598.6      | 598.6      | 598.6      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11027    | 0.11027    | 0.11027    |   0.0 |  0.02
Output  | 0.00016509 | 0.00016509 | 0.00016509 |   0.0 |  0.00
Modify  | 0.41455    | 0.41455    | 0.41455    |   0.0 |  0.07
Other   |            | 0.06629    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4467 ave        4467 max        4467 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:       270336 ave      270336 max      270336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270336
Ave neighs/atom = 135.168
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 = 292.933686278743, Press = -0.578645232421463
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13480.744     -13480.744     -13557.618     -13557.618      297.50981      297.50981      31930.24       31930.24       110.10721      110.10721    
     42000  -13486.253     -13486.253     -13559.741     -13559.741      284.4056       284.4056       31918.585      31918.585      730.38269      730.38269    
Loop time of 596.353 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.654 hours/ns, 1.677 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.77     | 595.77     | 595.77     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10946    | 0.10946    | 0.10946    |   0.0 |  0.02
Output  | 0.00026953 | 0.00026953 | 0.00026953 |   0.0 |  0.00
Modify  | 0.40998    | 0.40998    | 0.40998    |   0.0 |  0.07
Other   |            | 0.06532    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4387 ave        4387 max        4387 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:       270216 ave      270216 max      270216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270216
Ave neighs/atom = 135.108
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 = 292.895103148325, Press = 1.69931017809337
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13486.253     -13486.253     -13559.741     -13559.741      284.4056       284.4056       31918.585      31918.585      730.38269      730.38269    
     43000  -13482.628     -13482.628     -13558.251     -13558.251      292.67025      292.67025      31951.817      31951.817     -1637.8996     -1637.8996    
Loop time of 589.603 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.779 hours/ns, 1.696 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 589.03     | 589.03     | 589.03     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10646    | 0.10646    | 0.10646    |   0.0 |  0.02
Output  | 0.00016469 | 0.00016469 | 0.00016469 |   0.0 |  0.00
Modify  | 0.39995    | 0.39995    | 0.39995    |   0.0 |  0.07
Other   |            | 0.06488    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4394 ave        4394 max        4394 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:       270260 ave      270260 max      270260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270260
Ave neighs/atom = 135.13
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 = 292.867592804261, Press = -1.21584499473573
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13482.628     -13482.628     -13558.251     -13558.251      292.67025      292.67025      31951.817      31951.817     -1637.8996     -1637.8996    
     44000  -13480.748     -13480.748     -13557.233     -13557.233      296.00461      296.00461      31920.242      31920.242      951.99657      951.99657    
Loop time of 586.856 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.016 hours/ns, 1.704 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 586.29     | 586.29     | 586.29     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10673    | 0.10673    | 0.10673    |   0.0 |  0.02
Output  | 0.00016391 | 0.00016391 | 0.00016391 |   0.0 |  0.00
Modify  | 0.39647    | 0.39647    | 0.39647    |   0.0 |  0.07
Other   |            | 0.06509    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4455 ave        4455 max        4455 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:       270072 ave      270072 max      270072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270072
Ave neighs/atom = 135.036
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 = 292.880055766539, Press = 1.98603035438912
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13480.748     -13480.748     -13557.233     -13557.233      296.00461      296.00461      31920.242      31920.242      951.99657      951.99657    
     45000  -13483.327     -13483.327     -13557.317     -13557.317      286.34944      286.34944      31931.977      31931.977      30.379814      30.379814    
Loop time of 590.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 163.949 hours/ns, 1.694 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 589.65     | 589.65     | 589.65     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10621    | 0.10621    | 0.10621    |   0.0 |  0.02
Output  | 0.00016265 | 0.00016265 | 0.00016265 |   0.0 |  0.00
Modify  | 0.39933    | 0.39933    | 0.39933    |   0.0 |  0.07
Other   |            | 0.06462    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4403 ave        4403 max        4403 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:       270224 ave      270224 max      270224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270224
Ave neighs/atom = 135.112
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 = 292.893304800245, Press = -0.151447369636704
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13483.327     -13483.327     -13557.317     -13557.317      286.34944      286.34944      31931.977      31931.977      30.379814      30.379814    
     46000  -13482.016     -13482.016     -13557.818     -13557.818      293.36093      293.36093      31932.671      31932.671     -254.8761      -254.8761     
Loop time of 587.979 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.327 hours/ns, 1.701 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 587.41     | 587.41     | 587.41     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10754    | 0.10754    | 0.10754    |   0.0 |  0.02
Output  | 0.00020793 | 0.00020793 | 0.00020793 |   0.0 |  0.00
Modify  | 0.39928    | 0.39928    | 0.39928    |   0.0 |  0.07
Other   |            | 0.06502    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4450 ave        4450 max        4450 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:       269986 ave      269986 max      269986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269986
Ave neighs/atom = 134.993
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 = 292.890643859789, Press = 1.80130339230613
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13482.016     -13482.016     -13557.818     -13557.818      293.36093      293.36093      31932.671      31932.671     -254.8761      -254.8761     
     47000  -13484.881     -13484.881     -13558.09      -13558.09       283.32726      283.32726      31920.247      31920.247      614.25765      614.25765    
Loop time of 595.536 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.427 hours/ns, 1.679 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 594.96     | 594.96     | 594.96     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1071     | 0.1071     | 0.1071     |   0.0 |  0.02
Output  | 0.00016886 | 0.00016886 | 0.00016886 |   0.0 |  0.00
Modify  | 0.40351    | 0.40351    | 0.40351    |   0.0 |  0.07
Other   |            | 0.06522    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4408 ave        4408 max        4408 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:       270032 ave      270032 max      270032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270032
Ave neighs/atom = 135.016
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 = 292.848325718725, Press = -0.387043064830706
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13484.881     -13484.881     -13558.09      -13558.09       283.32726      283.32726      31920.247      31920.247      614.25765      614.25765    
     48000  -13481.15      -13481.15      -13555.614     -13555.614      288.18599      288.18599      31930.286      31930.286      362.37617      362.37617    
Loop time of 596.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.669 hours/ns, 1.677 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.83     | 595.83     | 595.83     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10805    | 0.10805    | 0.10805    |   0.0 |  0.02
Output  | 0.00016458 | 0.00016458 | 0.00016458 |   0.0 |  0.00
Modify  | 0.40716    | 0.40716    | 0.40716    |   0.0 |  0.07
Other   |            | 0.06553    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4413 ave        4413 max        4413 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:       270186 ave      270186 max      270186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270186
Ave neighs/atom = 135.093
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 = 292.783199881057, Press = 0.86714181512524
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13481.15      -13481.15      -13555.614     -13555.614      288.18599      288.18599      31930.286      31930.286      362.37617      362.37617    
     49000  -13482.31      -13482.31      -13558.662     -13558.662      295.48842      295.48842      31930.254      31930.254     -92.218348     -92.218348    
Loop time of 601.229 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 167.008 hours/ns, 1.663 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 600.64     | 600.64     | 600.64     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10897    | 0.10897    | 0.10897    |   0.0 |  0.02
Output  | 0.00016169 | 0.00016169 | 0.00016169 |   0.0 |  0.00
Modify  | 0.41364    | 0.41364    | 0.41364    |   0.0 |  0.07
Other   |            | 0.06769    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4420 ave        4420 max        4420 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:       270044 ave      270044 max      270044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270044
Ave neighs/atom = 135.022
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 = 292.773150209817, Press = 0.417726889565935
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13482.31      -13482.31      -13558.662     -13558.662      295.48842      295.48842      31930.254      31930.254     -92.218348     -92.218348    
     50000  -13482.562     -13482.562     -13558.531     -13558.531      294.01147      294.01147      31940.72       31940.72      -881.73997     -881.73997    
Loop time of 595.638 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.455 hours/ns, 1.679 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.06     | 595.06     | 595.06     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10783    | 0.10783    | 0.10783    |   0.0 |  0.02
Output  | 0.00016364 | 0.00016364 | 0.00016364 |   0.0 |  0.00
Modify  | 0.40765    | 0.40765    | 0.40765    |   0.0 |  0.07
Other   |            | 0.06589    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4450 ave        4450 max        4450 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:       270106 ave      270106 max      270106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270106
Ave neighs/atom = 135.053
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 = 292.793033260722, Press = 0.987182646600825
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13482.562     -13482.562     -13558.531     -13558.531      294.01147      294.01147      31940.72       31940.72      -881.73997     -881.73997    
     51000  -13478.971     -13478.971     -13557.536     -13557.536      304.05296      304.05296      31888.093      31888.093      3323.5158      3323.5158    
Loop time of 596.824 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.784 hours/ns, 1.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.24     | 596.24     | 596.24     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10841    | 0.10841    | 0.10841    |   0.0 |  0.02
Output  | 0.00016515 | 0.00016515 | 0.00016515 |   0.0 |  0.00
Modify  | 0.4083     | 0.4083     | 0.4083     |   0.0 |  0.07
Other   |            | 0.06576    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4458 ave        4458 max        4458 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:       270204 ave      270204 max      270204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270204
Ave neighs/atom = 135.102
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 = 292.824840969954, Press = -0.594480853978504
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13478.971     -13478.971     -13557.536     -13557.536      304.05296      304.05296      31888.093      31888.093      3323.5158      3323.5158    
     52000  -13483.53      -13483.53      -13557.943     -13557.943      287.98815      287.98815      31964.631      31964.631     -2689.2231     -2689.2231    
Loop time of 598.146 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.152 hours/ns, 1.672 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.56     | 597.56     | 597.56     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11017    | 0.11017    | 0.11017    |   0.0 |  0.02
Output  | 0.00016505 | 0.00016505 | 0.00016505 |   0.0 |  0.00
Modify  | 0.4129     | 0.4129     | 0.4129     |   0.0 |  0.07
Other   |            | 0.06593    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4490 ave        4490 max        4490 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:       270276 ave      270276 max      270276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270276
Ave neighs/atom = 135.138
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 = 292.868137122538, Press = 1.02256612338973
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13483.53      -13483.53      -13557.943     -13557.943      287.98815      287.98815      31964.631      31964.631     -2689.2231     -2689.2231    
     53000  -13484.312     -13484.312     -13559.407     -13559.407      290.62341      290.62341      31907.969      31907.969      1637.1087      1637.1087    
Loop time of 596.994 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.832 hours/ns, 1.675 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.42     | 596.42     | 596.42     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10808    | 0.10808    | 0.10808    |   0.0 |  0.02
Output  | 0.00016383 | 0.00016383 | 0.00016383 |   0.0 |  0.00
Modify  | 0.40474    | 0.40474    | 0.40474    |   0.0 |  0.07
Other   |            | 0.06566    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4455 ave        4455 max        4455 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:       269956 ave      269956 max      269956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269956
Ave neighs/atom = 134.978
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 = 292.918114189515, Press = 0.43504883801935
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13484.312     -13484.312     -13559.407     -13559.407      290.62341      290.62341      31907.969      31907.969      1637.1087      1637.1087    
     54000  -13482.202     -13482.202     -13557.208     -13557.208      290.28073      290.28073      31955.173      31955.173     -1845.7221     -1845.7221    
Loop time of 597.186 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.885 hours/ns, 1.675 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.6      | 596.6      | 596.6      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10845    | 0.10845    | 0.10845    |   0.0 |  0.02
Output  | 0.00022334 | 0.00022334 | 0.00022334 |   0.0 |  0.00
Modify  | 0.40732    | 0.40732    | 0.40732    |   0.0 |  0.07
Other   |            | 0.06549    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4448 ave        4448 max        4448 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:       270264 ave      270264 max      270264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270264
Ave neighs/atom = 135.132
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 = 292.933981902332, Press = 0.190704540106336
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13482.202     -13482.202     -13557.208     -13557.208      290.28073      290.28073      31955.173      31955.173     -1845.7221     -1845.7221    
     55000  -13482.924     -13482.924     -13557.209     -13557.209      287.49248      287.49248      31908.022      31908.022      1740.3997      1740.3997    
Loop time of 589.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.709 hours/ns, 1.697 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 588.78     | 588.78     | 588.78     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10787    | 0.10787    | 0.10787    |   0.0 |  0.02
Output  | 0.00016607 | 0.00016607 | 0.00016607 |   0.0 |  0.00
Modify  | 0.40136    | 0.40136    | 0.40136    |   0.0 |  0.07
Other   |            | 0.06476    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4468 ave        4468 max        4468 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:       269952 ave      269952 max      269952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269952
Ave neighs/atom = 134.976
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 = 292.95057441364, Press = 0.739776621109897
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13482.924     -13482.924     -13557.209     -13557.209      287.49248      287.49248      31908.022      31908.022      1740.3997      1740.3997    
     56000  -13482.143     -13482.143     -13557.24      -13557.24       290.63463      290.63463      31957.262      31957.262     -2065.3993     -2065.3993    
Loop time of 587.239 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.122 hours/ns, 1.703 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 586.67     | 586.67     | 586.67     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1069     | 0.1069     | 0.1069     |   0.0 |  0.02
Output  | 0.00016532 | 0.00016532 | 0.00016532 |   0.0 |  0.00
Modify  | 0.39839    | 0.39839    | 0.39839    |   0.0 |  0.07
Other   |            | 0.0647     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4452 ave        4452 max        4452 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:       270212 ave      270212 max      270212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270212
Ave neighs/atom = 135.106
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 = 292.90759137769, Press = -0.436389636151356
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13482.143     -13482.143     -13557.24      -13557.24       290.63463      290.63463      31957.262      31957.262     -2065.3993     -2065.3993    
     57000  -13483.537     -13483.537     -13560.955     -13560.955      299.61314      299.61314      31913.594      31913.594      903.31963      903.31963    
Loop time of 587.891 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.303 hours/ns, 1.701 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 587.32     | 587.32     | 587.32     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10578    | 0.10578    | 0.10578    |   0.0 |  0.02
Output  | 0.00016263 | 0.00016263 | 0.00016263 |   0.0 |  0.00
Modify  | 0.39617    | 0.39617    | 0.39617    |   0.0 |  0.07
Other   |            | 0.06439    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4444 ave        4444 max        4444 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:       269868 ave      269868 max      269868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269868
Ave neighs/atom = 134.934
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 = 292.926494590798, Press = 1.63735121072282
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13483.537     -13483.537     -13560.955     -13560.955      299.61314      299.61314      31913.594      31913.594      903.31963      903.31963    
     58000  -13479.376     -13479.376     -13556.762     -13556.762      299.49422      299.49422      31949.574      31949.574     -1348.1319     -1348.1319    
Loop time of 589.986 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 163.885 hours/ns, 1.695 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 589.41     | 589.41     | 589.41     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10853    | 0.10853    | 0.10853    |   0.0 |  0.02
Output  | 0.00016258 | 0.00016258 | 0.00016258 |   0.0 |  0.00
Modify  | 0.40428    | 0.40428    | 0.40428    |   0.0 |  0.07
Other   |            | 0.06586    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4498 ave        4498 max        4498 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:       270376 ave      270376 max      270376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270376
Ave neighs/atom = 135.188
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 = 292.973492145377, Press = -0.496667052834356
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13479.376     -13479.376     -13556.762     -13556.762      299.49422      299.49422      31949.574      31949.574     -1348.1319     -1348.1319    
     59000  -13481.252     -13481.252     -13557.59      -13557.59       295.4371       295.4371       31923.734      31923.734      504.93619      504.93619    
Loop time of 592.688 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.636 hours/ns, 1.687 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 592.11     | 592.11     | 592.11     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10812    | 0.10812    | 0.10812    |   0.0 |  0.02
Output  | 0.00021169 | 0.00021169 | 0.00021169 |   0.0 |  0.00
Modify  | 0.40529    | 0.40529    | 0.40529    |   0.0 |  0.07
Other   |            | 0.06532    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4487 ave        4487 max        4487 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:       270086 ave      270086 max      270086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270086
Ave neighs/atom = 135.043
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 = 292.992921006448, Press = 1.19275831788469
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13481.252     -13481.252     -13557.59      -13557.59       295.4371       295.4371       31923.734      31923.734      504.93619      504.93619    
     60000  -13482.661     -13482.661     -13556.883     -13556.883      287.24674      287.24674      31919.003      31919.003      1051.5944      1051.5944    
Loop time of 586.941 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.039 hours/ns, 1.704 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 586.37     | 586.37     | 586.37     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10838    | 0.10838    | 0.10838    |   0.0 |  0.02
Output  | 0.00016345 | 0.00016345 | 0.00016345 |   0.0 |  0.00
Modify  | 0.39859    | 0.39859    | 0.39859    |   0.0 |  0.07
Other   |            | 0.06555    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4509 ave        4509 max        4509 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:       270132 ave      270132 max      270132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270132
Ave neighs/atom = 135.066
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 = 293.000104090488, Press = 0.219006801034348
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13482.661     -13482.661     -13556.883     -13556.883      287.24674      287.24674      31919.003      31919.003      1051.5944      1051.5944    
     61000  -13484.601     -13484.601     -13559.504     -13559.504      289.88361      289.88361      31920.313      31920.313      505.05173      505.05173    
Loop time of 591.78 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.383 hours/ns, 1.690 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 591.2      | 591.2      | 591.2      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10883    | 0.10883    | 0.10883    |   0.0 |  0.02
Output  | 0.00020702 | 0.00020702 | 0.00020702 |   0.0 |  0.00
Modify  | 0.40208    | 0.40208    | 0.40208    |   0.0 |  0.07
Other   |            | 0.06586    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4532 ave        4532 max        4532 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:       270254 ave      270254 max      270254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270254
Ave neighs/atom = 135.127
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 = 292.976265436206, Press = 0.49470330294257
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13484.601     -13484.601     -13559.504     -13559.504      289.88361      289.88361      31920.313      31920.313      505.05173      505.05173    
     62000  -13480.484     -13480.484     -13557.988     -13557.988      299.94503      299.94503      31967.385      31967.385     -2777.8587     -2777.8587    
Loop time of 590.073 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 163.909 hours/ns, 1.695 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 589.5      | 589.5      | 589.5      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1083     | 0.1083     | 0.1083     |   0.0 |  0.02
Output  | 0.00020756 | 0.00020756 | 0.00020756 |   0.0 |  0.00
Modify  | 0.40004    | 0.40004    | 0.40004    |   0.0 |  0.07
Other   |            | 0.0654     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4505 ave        4505 max        4505 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:       270168 ave      270168 max      270168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270168
Ave neighs/atom = 135.084
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 = 292.938883128623, Press = -0.535469705741939
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13480.484     -13480.484     -13557.988     -13557.988      299.94503      299.94503      31967.385      31967.385     -2777.8587     -2777.8587    
     63000  -13482.445     -13482.445     -13557.905     -13557.905      292.03783      292.03783      31899.14       31899.14       2383.9616      2383.9616    
Loop time of 587.256 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.127 hours/ns, 1.703 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 586.68     | 586.68     | 586.68     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10757    | 0.10757    | 0.10757    |   0.0 |  0.02
Output  | 0.00016315 | 0.00016315 | 0.00016315 |   0.0 |  0.00
Modify  | 0.39914    | 0.39914    | 0.39914    |   0.0 |  0.07
Other   |            | 0.06465    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4467 ave        4467 max        4467 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:       269924 ave      269924 max      269924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269924
Ave neighs/atom = 134.962
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 = 292.9262778055, Press = 1.53489731424354
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13482.445     -13482.445     -13557.905     -13557.905      292.03783      292.03783      31899.14       31899.14       2383.9616      2383.9616    
     64000  -13480.547     -13480.547     -13556.808     -13556.808      295.13788      295.13788      31942.627      31942.627     -854.5159      -854.5159     
Loop time of 591.298 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.249 hours/ns, 1.691 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 590.73     | 590.73     | 590.73     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10798    | 0.10798    | 0.10798    |   0.0 |  0.02
Output  | 0.00026062 | 0.00026062 | 0.00026062 |   0.0 |  0.00
Modify  | 0.39755    | 0.39755    | 0.39755    |   0.0 |  0.07
Other   |            | 0.06493    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4520 ave        4520 max        4520 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:       270146 ave      270146 max      270146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270146
Ave neighs/atom = 135.073
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
31929.9563467685

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0