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

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

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

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23173.4740665253 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_262519520678_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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  -8479.0811     -8479.0811     -8559.9963     -8559.9963      313.15         313.15         23173.474      23173.474      3729.5672      3729.5672    
      1000  -8402.0205     -8402.0205     -8480.0038     -8480.0038      301.80338      301.80338      23451.95       23451.95       5902.2841      5902.2841    
Loop time of 232.201 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.500 hours/ns, 4.307 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    | 231.69     | 231.69     | 231.69     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097926   | 0.097926   | 0.097926   |   0.0 |  0.04
Output  | 0.00021184 | 0.00021184 | 0.00021184 |   0.0 |  0.00
Modify  | 0.35172    | 0.35172    | 0.35172    |   0.0 |  0.15
Other   |            | 0.06149    |            |       |  0.03

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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
      1000  -8402.0205     -8402.0205     -8480.0038     -8480.0038      301.80338      301.80338      23451.95       23451.95       5902.2841      5902.2841    
      2000  -8397.7599     -8397.7599     -8481.0419     -8481.0419      322.30993      322.30993      23520.717      23520.717      737.43455      737.43455    
Loop time of 224.164 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.385 ns/day, 62.268 hours/ns, 4.461 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    | 223.65     | 223.65     | 223.65     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10029    | 0.10029    | 0.10029    |   0.0 |  0.04
Output  | 0.00024609 | 0.00024609 | 0.00024609 |   0.0 |  0.00
Modify  | 0.35481    | 0.35481    | 0.35481    |   0.0 |  0.16
Other   |            | 0.06152    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245840 ave      245840 max      245840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245840
Ave neighs/atom = 122.92
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
      2000  -8397.7599     -8397.7599     -8481.0419     -8481.0419      322.30993      322.30993      23520.717      23520.717      737.43455      737.43455    
      3000  -8403.1183     -8403.1183     -8482.7926     -8482.7926      308.34773      308.34773      23512.145      23512.145      1097.0442      1097.0442    
Loop time of 227.382 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.162 hours/ns, 4.398 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    | 226.86     | 226.86     | 226.86     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10142    | 0.10142    | 0.10142    |   0.0 |  0.04
Output  | 0.00019849 | 0.00019849 | 0.00019849 |   0.0 |  0.00
Modify  | 0.36275    | 0.36275    | 0.36275    |   0.0 |  0.16
Other   |            | 0.06246    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4147 ave        4147 max        4147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244432 ave      244432 max      244432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244432
Ave neighs/atom = 122.216
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
      3000  -8403.1183     -8403.1183     -8482.7926     -8482.7926      308.34773      308.34773      23512.145      23512.145      1097.0442      1097.0442    
      4000  -8397.8828     -8397.8828     -8481.278      -8481.278       322.74768      322.74768      23535.841      23535.841     -342.62374     -342.62374    
Loop time of 226.369 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.382 ns/day, 62.880 hours/ns, 4.418 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    | 225.84     | 225.84     | 225.84     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10137    | 0.10137    | 0.10137    |   0.0 |  0.04
Output  | 0.0001997  | 0.0001997  | 0.0001997  |   0.0 |  0.00
Modify  | 0.3642     | 0.3642     | 0.3642     |   0.0 |  0.16
Other   |            | 0.06208    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4144 ave        4144 max        4144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244552 ave      244552 max      244552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244552
Ave neighs/atom = 122.276
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
      4000  -8397.8828     -8397.8828     -8481.278      -8481.278       322.74768      322.74768      23535.841      23535.841     -342.62374     -342.62374    
      5000  -8402.8253     -8402.8253     -8481.5752     -8481.5752      304.77011      304.77011      23512.471      23512.471      961.932        961.932      
Loop time of 229.595 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.776 hours/ns, 4.355 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    | 229.06     | 229.06     | 229.06     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10204    | 0.10204    | 0.10204    |   0.0 |  0.04
Output  | 0.00016399 | 0.00016399 | 0.00016399 |   0.0 |  0.00
Modify  | 0.36797    | 0.36797    | 0.36797    |   0.0 |  0.16
Other   |            | 0.06244    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4138 ave        4138 max        4138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244412 ave      244412 max      244412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244412
Ave neighs/atom = 122.206
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 308.2949875111, Press = -838.292981129306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
      5000  -8402.8253     -8402.8253     -8481.5752     -8481.5752      304.77011      304.77011      23512.471      23512.471      961.932        961.932      
      6000  -8402.837      -8402.837      -8482.7057     -8482.7057      309.1004       309.1004       23511.823      23511.823      962.92144      962.92144    
Loop time of 228.479 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.466 hours/ns, 4.377 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    | 227.93     | 227.93     | 227.93     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10265    | 0.10265    | 0.10265    |   0.0 |  0.04
Output  | 0.00020621 | 0.00020621 | 0.00020621 |   0.0 |  0.00
Modify  | 0.38554    | 0.38554    | 0.38554    |   0.0 |  0.17
Other   |            | 0.06298    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4161 ave        4161 max        4161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244726 ave      244726 max      244726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244726
Ave neighs/atom = 122.363
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.520763398765, Press = -84.8587054335382
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
      6000  -8402.837      -8402.837      -8482.7057     -8482.7057      309.1004       309.1004       23511.823      23511.823      962.92144      962.92144    
      7000  -8399.284      -8399.284      -8479.4181     -8479.4181      310.12699      310.12699      23516.444      23516.444      1373.5847      1373.5847    
Loop time of 230.04 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.900 hours/ns, 4.347 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    | 229.49     | 229.49     | 229.49     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10207    | 0.10207    | 0.10207    |   0.0 |  0.04
Output  | 0.00016459 | 0.00016459 | 0.00016459 |   0.0 |  0.00
Modify  | 0.38783    | 0.38783    | 0.38783    |   0.0 |  0.17
Other   |            | 0.06211    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4142 ave        4142 max        4142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244658 ave      244658 max      244658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244658
Ave neighs/atom = 122.329
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.262491515256, Press = -63.514670971697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
      7000  -8399.284      -8399.284      -8479.4181     -8479.4181      310.12699      310.12699      23516.444      23516.444      1373.5847      1373.5847    
      8000  -8400.9894     -8400.9894     -8482.204      -8482.204       314.30899      314.30899      23521.948      23521.948      273.27071      273.27071    
Loop time of 229.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.732 hours/ns, 4.359 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    | 228.88     | 228.88     | 228.88     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10181    | 0.10181    | 0.10181    |   0.0 |  0.04
Output  | 0.00016475 | 0.00016475 | 0.00016475 |   0.0 |  0.00
Modify  | 0.38828    | 0.38828    | 0.38828    |   0.0 |  0.17
Other   |            | 0.0621     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4132 ave        4132 max        4132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244776 ave      244776 max      244776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244776
Ave neighs/atom = 122.388
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.138772058774, Press = -42.0703220559885
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
      8000  -8400.9894     -8400.9894     -8482.204      -8482.204       314.30899      314.30899      23521.948      23521.948      273.27071      273.27071    
      9000  -8398.3695     -8398.3695     -8479.4094     -8479.4094      313.63282      313.63282      23526.161      23526.161      739.76989      739.76989    
Loop time of 229.28 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.689 hours/ns, 4.361 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    | 228.73     | 228.73     | 228.73     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10257    | 0.10257    | 0.10257    |   0.0 |  0.04
Output  | 0.00016621 | 0.00016621 | 0.00016621 |   0.0 |  0.00
Modify  | 0.38532    | 0.38532    | 0.38532    |   0.0 |  0.17
Other   |            | 0.06157    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4146 ave        4146 max        4146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244574 ave      244574 max      244574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244574
Ave neighs/atom = 122.287
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.844482485247, Press = -20.2856481439669
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
      9000  -8398.3695     -8398.3695     -8479.4094     -8479.4094      313.63282      313.63282      23526.161      23526.161      739.76989      739.76989    
     10000  -8404.2758     -8404.2758     -8485.003      -8485.003       312.42265      312.42265      23508.991      23508.991      582.56848      582.56848    
Loop time of 229.704 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.807 hours/ns, 4.353 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    | 229.15     | 229.15     | 229.15     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10279    | 0.10279    | 0.10279    |   0.0 |  0.04
Output  | 0.00016429 | 0.00016429 | 0.00016429 |   0.0 |  0.00
Modify  | 0.39199    | 0.39199    | 0.39199    |   0.0 |  0.17
Other   |            | 0.0622     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4140 ave        4140 max        4140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244418 ave      244418 max      244418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244418
Ave neighs/atom = 122.209
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.584221858673, Press = -12.9239405723384
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     10000  -8404.2758     -8404.2758     -8485.003      -8485.003       312.42265      312.42265      23508.991      23508.991      582.56848      582.56848    
     11000  -8398.4198     -8398.4198     -8482.2149     -8482.2149      324.29599      324.29599      23531.791      23531.791     -253.30466     -253.30466    
Loop time of 228.494 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.471 hours/ns, 4.376 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    | 227.94     | 227.94     | 227.94     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10205    | 0.10205    | 0.10205    |   0.0 |  0.04
Output  | 0.00016471 | 0.00016471 | 0.00016471 |   0.0 |  0.00
Modify  | 0.38899    | 0.38899    | 0.38899    |   0.0 |  0.17
Other   |            | 0.06229    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4136 ave        4136 max        4136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244716 ave      244716 max      244716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244716
Ave neighs/atom = 122.358
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.358814677068, Press = -8.29480892870273
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     11000  -8398.4198     -8398.4198     -8482.2149     -8482.2149      324.29599      324.29599      23531.791      23531.791     -253.30466     -253.30466    
     12000  -8400.4159     -8400.4159     -8481.8107     -8481.8107      315.00645      315.00645      23504.543      23504.543      1724.44        1724.44      
Loop time of 231.951 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.431 hours/ns, 4.311 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    | 231.39     | 231.39     | 231.39     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10255    | 0.10255    | 0.10255    |   0.0 |  0.04
Output  | 0.00021223 | 0.00021223 | 0.00021223 |   0.0 |  0.00
Modify  | 0.39291    | 0.39291    | 0.39291    |   0.0 |  0.17
Other   |            | 0.06256    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4138 ave        4138 max        4138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244344 ave      244344 max      244344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244344
Ave neighs/atom = 122.172
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.450056534745, Press = -8.97765827123092
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     12000  -8400.4159     -8400.4159     -8481.8107     -8481.8107      315.00645      315.00645      23504.543      23504.543      1724.44        1724.44      
     13000  -8403.1577     -8403.1577     -8483.6151     -8483.6151      311.37825      311.37825      23468.468      23468.468      4058.7627      4058.7627    
Loop time of 231.809 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.391 hours/ns, 4.314 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    | 231.25     | 231.25     | 231.25     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10275    | 0.10275    | 0.10275    |   0.0 |  0.04
Output  | 0.00016417 | 0.00016417 | 0.00016417 |   0.0 |  0.00
Modify  | 0.39397    | 0.39397    | 0.39397    |   0.0 |  0.17
Other   |            | 0.06274    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4140 ave        4140 max        4140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244868 ave      244868 max      244868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244868
Ave neighs/atom = 122.434
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.57171279518, Press = -10.899307746417
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     13000  -8403.1577     -8403.1577     -8483.6151     -8483.6151      311.37825      311.37825      23468.468      23468.468      4058.7627      4058.7627    
     14000  -8400.2558     -8400.2558     -8482.234      -8482.234       317.26403      317.26403      23487.469      23487.469      2921.9647      2921.9647    
Loop time of 230.338 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.983 hours/ns, 4.341 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    | 229.78     | 229.78     | 229.78     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10212    | 0.10212    | 0.10212    |   0.0 |  0.04
Output  | 0.00047798 | 0.00047798 | 0.00047798 |   0.0 |  0.00
Modify  | 0.39263    | 0.39263    | 0.39263    |   0.0 |  0.17
Other   |            | 0.06281    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245434 ave      245434 max      245434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245434
Ave neighs/atom = 122.717
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.600701110952, Press = -5.11865617748878
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     14000  -8400.2558     -8400.2558     -8482.234      -8482.234       317.26403      317.26403      23487.469      23487.469      2921.9647      2921.9647    
     15000  -8398.9226     -8398.9226     -8482.3724     -8482.3724      322.9593       322.9593       23503.259      23503.259      1742.3357      1742.3357    
Loop time of 230.198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.944 hours/ns, 4.344 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    | 229.64     | 229.64     | 229.64     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10364    | 0.10364    | 0.10364    |   0.0 |  0.05
Output  | 0.00016512 | 0.00016512 | 0.00016512 |   0.0 |  0.00
Modify  | 0.39076    | 0.39076    | 0.39076    |   0.0 |  0.17
Other   |            | 0.06235    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4144 ave        4144 max        4144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245156 ave      245156 max      245156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245156
Ave neighs/atom = 122.578
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.389316231822, Press = -5.56463416136385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     15000  -8398.9226     -8398.9226     -8482.3724     -8482.3724      322.9593       322.9593       23503.259      23503.259      1742.3357      1742.3357    
     16000  -8401.1326     -8401.1326     -8481.9127     -8481.9127      312.62708      312.62708      23507.024      23507.024      1651.4449      1651.4449    
Loop time of 233.96 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.369 ns/day, 64.989 hours/ns, 4.274 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    | 233.39     | 233.39     | 233.39     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10393    | 0.10393    | 0.10393    |   0.0 |  0.04
Output  | 0.00016414 | 0.00016414 | 0.00016414 |   0.0 |  0.00
Modify  | 0.40051    | 0.40051    | 0.40051    |   0.0 |  0.17
Other   |            | 0.06345    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4150 ave        4150 max        4150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245054 ave      245054 max      245054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245054
Ave neighs/atom = 122.527
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.571683227601, Press = -5.22779584722972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     16000  -8401.1326     -8401.1326     -8481.9127     -8481.9127      312.62708      312.62708      23507.024      23507.024      1651.4449      1651.4449    
     17000  -8398.7092     -8398.7092     -8478.685      -8478.685       309.51472      309.51472      23512.359      23512.359      1793.4496      1793.4496    
Loop time of 230.677 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 64.077 hours/ns, 4.335 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    | 230.12     | 230.12     | 230.12     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10367    | 0.10367    | 0.10367    |   0.0 |  0.04
Output  | 0.00017587 | 0.00017587 | 0.00017587 |   0.0 |  0.00
Modify  | 0.39312    | 0.39312    | 0.39312    |   0.0 |  0.17
Other   |            | 0.06261    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4140 ave        4140 max        4140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244848 ave      244848 max      244848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244848
Ave neighs/atom = 122.424
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.822421504129, Press = -2.88371058390925
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     17000  -8398.7092     -8398.7092     -8478.685      -8478.685       309.51472      309.51472      23512.359      23512.359      1793.4496      1793.4496    
     18000  -8402.9389     -8402.9389     -8483.5904     -8483.5904      312.12962      312.12962      23477.061      23477.061      3247.9641      3247.9641    
Loop time of 231.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.348 hours/ns, 4.317 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    | 231.09     | 231.09     | 231.09     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1034     | 0.1034     | 0.1034     |   0.0 |  0.04
Output  | 0.00020077 | 0.00020077 | 0.00020077 |   0.0 |  0.00
Modify  | 0.39379    | 0.39379    | 0.39379    |   0.0 |  0.17
Other   |            | 0.06321    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4148 ave        4148 max        4148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244850 ave      244850 max      244850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244850
Ave neighs/atom = 122.425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.869524987324, Press = -3.01797689061418
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     18000  -8402.9389     -8402.9389     -8483.5904     -8483.5904      312.12962      312.12962      23477.061      23477.061      3247.9641      3247.9641    
     19000  -8395.9287     -8395.9287     -8478.2687     -8478.2687      318.66469      318.66469      23490.94       23490.94       3812.7172      3812.7172    
Loop time of 231.332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.259 hours/ns, 4.323 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    | 230.78     | 230.78     | 230.78     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10229    | 0.10229    | 0.10229    |   0.0 |  0.04
Output  | 0.00016305 | 0.00016305 | 0.00016305 |   0.0 |  0.00
Modify  | 0.39032    | 0.39032    | 0.39032    |   0.0 |  0.17
Other   |            | 0.06272    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4151 ave        4151 max        4151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245332 ave      245332 max      245332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245332
Ave neighs/atom = 122.666
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.905509216197, Press = -0.925862334196196
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     19000  -8395.9287     -8395.9287     -8478.2687     -8478.2687      318.66469      318.66469      23490.94       23490.94       3812.7172      3812.7172    
     20000  -8401.0449     -8401.0449     -8482.9056     -8482.9056      316.80931      316.80931      23488.158      23488.158      2792.6378      2792.6378    
Loop time of 231.569 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.325 hours/ns, 4.318 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    | 231        | 231        | 231        |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10479    | 0.10479    | 0.10479    |   0.0 |  0.05
Output  | 0.00019963 | 0.00019963 | 0.00019963 |   0.0 |  0.00
Modify  | 0.39941    | 0.39941    | 0.39941    |   0.0 |  0.17
Other   |            | 0.06325    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4150 ave        4150 max        4150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245176 ave      245176 max      245176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245176
Ave neighs/atom = 122.588
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.046593667081, Press = -2.14235016525862
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     20000  -8401.0449     -8401.0449     -8482.9056     -8482.9056      316.80931      316.80931      23488.158      23488.158      2792.6378      2792.6378    
     21000  -8392.9138     -8392.9138     -8477.0134     -8477.0134      325.47425      325.47425      23525.615      23525.615      1520.4638      1520.4638    
Loop time of 234.984 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.368 ns/day, 65.273 hours/ns, 4.256 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    | 234.41     | 234.41     | 234.41     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1054     | 0.1054     | 0.1054     |   0.0 |  0.04
Output  | 0.00021276 | 0.00021276 | 0.00021276 |   0.0 |  0.00
Modify  | 0.40557    | 0.40557    | 0.40557    |   0.0 |  0.17
Other   |            | 0.06324    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4147 ave        4147 max        4147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245118 ave      245118 max      245118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245118
Ave neighs/atom = 122.559
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.180202203885, Press = -1.69194983933776
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     21000  -8392.9138     -8392.9138     -8477.0134     -8477.0134      325.47425      325.47425      23525.615      23525.615      1520.4638      1520.4638    
     22000  -8401.0068     -8401.0068     -8482.3022     -8482.3022      314.62183      314.62183      23519.726      23519.726      512.06556      512.06556    
Loop time of 230.621 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 64.061 hours/ns, 4.336 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    | 230.06     | 230.06     | 230.06     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10218    | 0.10218    | 0.10218    |   0.0 |  0.04
Output  | 0.0001662  | 0.0001662  | 0.0001662  |   0.0 |  0.00
Modify  | 0.39224    | 0.39224    | 0.39224    |   0.0 |  0.17
Other   |            | 0.06257    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244658 ave      244658 max      244658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244658
Ave neighs/atom = 122.329
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.311655759892, Press = -3.11896254688368
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     22000  -8401.0068     -8401.0068     -8482.3022     -8482.3022      314.62183      314.62183      23519.726      23519.726      512.06556      512.06556    
     23000  -8397.7711     -8397.7711     -8479.8615     -8479.8615      317.69811      317.69811      23529.582      23529.582      385.66843      385.66843    
Loop time of 229.34 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.706 hours/ns, 4.360 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    | 228.78     | 228.78     | 228.78     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10212    | 0.10212    | 0.10212    |   0.0 |  0.04
Output  | 0.00016409 | 0.00016409 | 0.00016409 |   0.0 |  0.00
Modify  | 0.39204    | 0.39204    | 0.39204    |   0.0 |  0.17
Other   |            | 0.06263    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244518 ave      244518 max      244518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244518
Ave neighs/atom = 122.259
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.327615390031, Press = -2.56169886985472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     23000  -8397.7711     -8397.7711     -8479.8615     -8479.8615      317.69811      317.69811      23529.582      23529.582      385.66843      385.66843    
     24000  -8401.5745     -8401.5745     -8480.955      -8480.955       307.2105       307.2105       23520.647      23520.647      527.09821      527.09821    
Loop time of 230.947 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.152 hours/ns, 4.330 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    | 230.39     | 230.39     | 230.39     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10295    | 0.10295    | 0.10295    |   0.0 |  0.04
Output  | 0.00016636 | 0.00016636 | 0.00016636 |   0.0 |  0.00
Modify  | 0.39429    | 0.39429    | 0.39429    |   0.0 |  0.17
Other   |            | 0.06249    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4147 ave        4147 max        4147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244478 ave      244478 max      244478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244478
Ave neighs/atom = 122.239
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.387246525882, Press = -2.98540285337963
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     24000  -8401.5745     -8401.5745     -8480.955      -8480.955       307.2105       307.2105       23520.647      23520.647      527.09821      527.09821    
     25000  -8397.5305     -8397.5305     -8479.375      -8479.375       316.74657      316.74657      23531.513      23531.513      400.44359      400.44359    
Loop time of 227.578 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.216 hours/ns, 4.394 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    | 227.03     | 227.03     | 227.03     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10155    | 0.10155    | 0.10155    |   0.0 |  0.04
Output  | 0.00020476 | 0.00020476 | 0.00020476 |   0.0 |  0.00
Modify  | 0.38388    | 0.38388    | 0.38388    |   0.0 |  0.17
Other   |            | 0.06203    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4145 ave        4145 max        4145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244536 ave      244536 max      244536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244536
Ave neighs/atom = 122.268
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.514404686842, Press = -3.68600994276803
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     25000  -8397.5305     -8397.5305     -8479.375      -8479.375       316.74657      316.74657      23531.513      23531.513      400.44359      400.44359    
     26000  -8399.279      -8399.279      -8479.8512     -8479.8512      311.82287      311.82287      23526.271      23526.271      661.46337      661.46337    
Loop time of 229.671 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.798 hours/ns, 4.354 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    | 229.12     | 229.12     | 229.12     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10162    | 0.10162    | 0.10162    |   0.0 |  0.04
Output  | 0.00016634 | 0.00016634 | 0.00016634 |   0.0 |  0.00
Modify  | 0.38695    | 0.38695    | 0.38695    |   0.0 |  0.17
Other   |            | 0.06155    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244372 ave      244372 max      244372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244372
Ave neighs/atom = 122.186
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.472699711704, Press = -5.29167704318538
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     26000  -8399.279      -8399.279      -8479.8512     -8479.8512      311.82287      311.82287      23526.271      23526.271      661.46337      661.46337    
     27000  -8401.527      -8401.527      -8482.4866     -8482.4866      313.32206      313.32206      23521.446      23521.446      201.87232      201.87232    
Loop time of 227.856 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.293 hours/ns, 4.389 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    | 227.3      | 227.3      | 227.3      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10152    | 0.10152    | 0.10152    |   0.0 |  0.04
Output  | 0.00016495 | 0.00016495 | 0.00016495 |   0.0 |  0.00
Modify  | 0.38808    | 0.38808    | 0.38808    |   0.0 |  0.17
Other   |            | 0.06273    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244396 ave      244396 max      244396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244396
Ave neighs/atom = 122.198
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.401069861898, Press = -7.60898598690032
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     27000  -8401.527      -8401.527      -8482.4866     -8482.4866      313.32206      313.32206      23521.446      23521.446      201.87232      201.87232    
     28000  -8399.9925     -8399.9925     -8479.8864     -8479.8864      309.19761      309.19761      23528.245      23528.245      254.88485      254.88485    
Loop time of 227.523 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.201 hours/ns, 4.395 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    | 226.97     | 226.97     | 226.97     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10257    | 0.10257    | 0.10257    |   0.0 |  0.05
Output  | 0.00016457 | 0.00016457 | 0.00016457 |   0.0 |  0.00
Modify  | 0.3842     | 0.3842     | 0.3842     |   0.0 |  0.17
Other   |            | 0.06173    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244572 ave      244572 max      244572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244572
Ave neighs/atom = 122.286
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.367237807135, Press = -5.12245785280128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     28000  -8399.9925     -8399.9925     -8479.8864     -8479.8864      309.19761      309.19761      23528.245      23528.245      254.88485      254.88485    
     29000  -8400.7748     -8400.7748     -8481.9284     -8481.9284      314.07278      314.07278      23522.559      23522.559      322.9167       322.9167     
Loop time of 229.613 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.782 hours/ns, 4.355 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    | 229.06     | 229.06     | 229.06     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10162    | 0.10162    | 0.10162    |   0.0 |  0.04
Output  | 0.00016433 | 0.00016433 | 0.00016433 |   0.0 |  0.00
Modify  | 0.38884    | 0.38884    | 0.38884    |   0.0 |  0.17
Other   |            | 0.06286    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4134 ave        4134 max        4134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244482 ave      244482 max      244482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244482
Ave neighs/atom = 122.241
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.428112743139, Press = -3.5351107781768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     29000  -8400.7748     -8400.7748     -8481.9284     -8481.9284      314.07278      314.07278      23522.559      23522.559      322.9167       322.9167     
     30000  -8396.9428     -8396.9428     -8480.3693     -8480.3693      322.86903      322.86903      23533.111      23533.111     -156.83153     -156.83153    
Loop time of 228.658 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.516 hours/ns, 4.373 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    | 228.11     | 228.11     | 228.11     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10213    | 0.10213    | 0.10213    |   0.0 |  0.04
Output  | 0.00025324 | 0.00025324 | 0.00025324 |   0.0 |  0.00
Modify  | 0.38659    | 0.38659    | 0.38659    |   0.0 |  0.17
Other   |            | 0.06246    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4140 ave        4140 max        4140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244642 ave      244642 max      244642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244642
Ave neighs/atom = 122.321
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.469823556209, Press = -3.1937282904679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     30000  -8396.9428     -8396.9428     -8480.3693     -8480.3693      322.86903      322.86903      23533.111      23533.111     -156.83153     -156.83153    
     31000  -8401.6208     -8401.6208     -8481.7525     -8481.7525      310.11818      310.11818      23519.579      23519.579      458.3123       458.3123     
Loop time of 231.775 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.382 hours/ns, 4.315 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    | 231.22     | 231.22     | 231.22     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10322    | 0.10322    | 0.10322    |   0.0 |  0.04
Output  | 0.00016545 | 0.00016545 | 0.00016545 |   0.0 |  0.00
Modify  | 0.39067    | 0.39067    | 0.39067    |   0.0 |  0.17
Other   |            | 0.06271    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4155 ave        4155 max        4155 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244416 ave      244416 max      244416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244416
Ave neighs/atom = 122.208
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.584748641003, Press = -4.75597102630649
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     31000  -8401.6208     -8401.6208     -8481.7525     -8481.7525      310.11818      310.11818      23519.579      23519.579      458.3123       458.3123     
     32000  -8400.477      -8400.477      -8480.6014     -8480.6014      310.08952      310.08952      23522.839      23522.839      649.05195      649.05195    
Loop time of 227.974 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.326 hours/ns, 4.386 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    | 227.42     | 227.42     | 227.42     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10133    | 0.10133    | 0.10133    |   0.0 |  0.04
Output  | 0.00021189 | 0.00021189 | 0.00021189 |   0.0 |  0.00
Modify  | 0.38681    | 0.38681    | 0.38681    |   0.0 |  0.17
Other   |            | 0.06159    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4148 ave        4148 max        4148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244672 ave      244672 max      244672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244672
Ave neighs/atom = 122.336
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.60445649308, Press = -3.75729403311792
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     32000  -8400.477      -8400.477      -8480.6014     -8480.6014      310.08952      310.08952      23522.839      23522.839      649.05195      649.05195    
     33000  -8401.139      -8401.139      -8481.7991     -8481.7991      312.16311      312.16311      23515.325      23515.325      660.09122      660.09122    
Loop time of 231.915 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.421 hours/ns, 4.312 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    | 231.36     | 231.36     | 231.36     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10346    | 0.10346    | 0.10346    |   0.0 |  0.04
Output  | 0.00024433 | 0.00024433 | 0.00024433 |   0.0 |  0.00
Modify  | 0.39214    | 0.39214    | 0.39214    |   0.0 |  0.17
Other   |            | 0.06238    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4157 ave        4157 max        4157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244576 ave      244576 max      244576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244576
Ave neighs/atom = 122.288
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.565713824902, Press = -5.3605957287691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     33000  -8401.139      -8401.139      -8481.7991     -8481.7991      312.16311      312.16311      23515.325      23515.325      660.09122      660.09122    
     34000  -8397.9185     -8397.9185     -8479.758      -8479.758       316.72735      316.72735      23539.98       23539.98      -371.60333     -371.60333    
Loop time of 229.937 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.872 hours/ns, 4.349 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    | 229.38     | 229.38     | 229.38     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10226    | 0.10226    | 0.10226    |   0.0 |  0.04
Output  | 0.00016661 | 0.00016661 | 0.00016661 |   0.0 |  0.00
Modify  | 0.38788    | 0.38788    | 0.38788    |   0.0 |  0.17
Other   |            | 0.06218    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4161 ave        4161 max        4161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244820 ave      244820 max      244820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244820
Ave neighs/atom = 122.41
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.477990427332, Press = -2.57559267386426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     34000  -8397.9185     -8397.9185     -8479.758      -8479.758       316.72735      316.72735      23539.98       23539.98      -371.60333     -371.60333    
     35000  -8400.9436     -8400.9436     -8481.64       -8481.64        312.30366      312.30366      23515.634      23515.634      1067.4122      1067.4122    
Loop time of 230.116 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.921 hours/ns, 4.346 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    | 229.56     | 229.56     | 229.56     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10288    | 0.10288    | 0.10288    |   0.0 |  0.04
Output  | 0.00016564 | 0.00016564 | 0.00016564 |   0.0 |  0.00
Modify  | 0.39437    | 0.39437    | 0.39437    |   0.0 |  0.17
Other   |            | 0.06245    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244262 ave      244262 max      244262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244262
Ave neighs/atom = 122.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.465544672122, Press = -2.38590598838511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     35000  -8400.9436     -8400.9436     -8481.64       -8481.64        312.30366      312.30366      23515.634      23515.634      1067.4122      1067.4122    
     36000  -8399.9883     -8399.9883     -8482.2366     -8482.2366      318.30937      318.30937      23507.468      23507.468      1426.4802      1426.4802    
Loop time of 226.629 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.381 ns/day, 62.952 hours/ns, 4.413 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    | 226.09     | 226.09     | 226.09     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10126    | 0.10126    | 0.10126    |   0.0 |  0.04
Output  | 0.00016664 | 0.00016664 | 0.00016664 |   0.0 |  0.00
Modify  | 0.37994    | 0.37994    | 0.37994    |   0.0 |  0.17
Other   |            | 0.0618     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4138 ave        4138 max        4138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244570 ave      244570 max      244570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244570
Ave neighs/atom = 122.285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.464573682, Press = -1.47582572448668
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     36000  -8399.9883     -8399.9883     -8482.2366     -8482.2366      318.30937      318.30937      23507.468      23507.468      1426.4802      1426.4802    
     37000  -8400.1032     -8400.1032     -8482.2299     -8482.2299      317.8387       317.8387       23506.342      23506.342      1571.8671      1571.8671    
Loop time of 227.899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.305 hours/ns, 4.388 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    | 227.35     | 227.35     | 227.35     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.101      | 0.101      | 0.101      |   0.0 |  0.04
Output  | 0.0002022  | 0.0002022  | 0.0002022  |   0.0 |  0.00
Modify  | 0.3834     | 0.3834     | 0.3834     |   0.0 |  0.17
Other   |            | 0.06147    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244752 ave      244752 max      244752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244752
Ave neighs/atom = 122.376
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.4072008718, Press = -1.81184735609861
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     37000  -8400.1032     -8400.1032     -8482.2299     -8482.2299      317.8387       317.8387       23506.342      23506.342      1571.8671      1571.8671    
     38000  -8400.9914     -8400.9914     -8481.8543     -8481.8543      312.94796      312.94796      23494.258      23494.258      2419.0489      2419.0489    
Loop time of 229.983 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.884 hours/ns, 4.348 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    | 229.43     | 229.43     | 229.43     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1027     | 0.1027     | 0.1027     |   0.0 |  0.04
Output  | 0.00016332 | 0.00016332 | 0.00016332 |   0.0 |  0.00
Modify  | 0.38986    | 0.38986    | 0.38986    |   0.0 |  0.17
Other   |            | 0.06317    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4156 ave        4156 max        4156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244896 ave      244896 max      244896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244896
Ave neighs/atom = 122.448
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.457844448293, Press = -3.7196478766554
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     38000  -8400.9914     -8400.9914     -8481.8543     -8481.8543      312.94796      312.94796      23494.258      23494.258      2419.0489      2419.0489    
     39000  -8396.1634     -8396.1634     -8479.2027     -8479.2027      321.37057      321.37057      23504.546      23504.546      2511.6682      2511.6682    
Loop time of 231.892 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.414 hours/ns, 4.312 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    | 231.33     | 231.33     | 231.33     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10361    | 0.10361    | 0.10361    |   0.0 |  0.04
Output  | 0.00020818 | 0.00020818 | 0.00020818 |   0.0 |  0.00
Modify  | 0.39208    | 0.39208    | 0.39208    |   0.0 |  0.17
Other   |            | 0.06278    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4151 ave        4151 max        4151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245158 ave      245158 max      245158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245158
Ave neighs/atom = 122.579
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.475406764842, Press = -2.23900800758659
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     39000  -8396.1634     -8396.1634     -8479.2027     -8479.2027      321.37057      321.37057      23504.546      23504.546      2511.6682      2511.6682    
     40000  -8400.9178     -8400.9178     -8481.6705     -8481.6705      312.52138      312.52138      23495.331      23495.331      2320.8552      2320.8552    
Loop time of 232.402 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.556 hours/ns, 4.303 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    | 231.84     | 231.84     | 231.84     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1034     | 0.1034     | 0.1034     |   0.0 |  0.04
Output  | 0.00019748 | 0.00019748 | 0.00019748 |   0.0 |  0.00
Modify  | 0.39607    | 0.39607    | 0.39607    |   0.0 |  0.17
Other   |            | 0.0627     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4146 ave        4146 max        4146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244762 ave      244762 max      244762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244762
Ave neighs/atom = 122.381
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.549995454603, Press = -1.7125016145044
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     40000  -8400.9178     -8400.9178     -8481.6705     -8481.6705      312.52138      312.52138      23495.331      23495.331      2320.8552      2320.8552    
     41000  -8398.8086     -8398.8086     -8479.106      -8479.106       310.75912      310.75912      23523.434      23523.434      946.96732      946.96732    
Loop time of 230.263 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.962 hours/ns, 4.343 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    | 229.7      | 229.7      | 229.7      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10409    | 0.10409    | 0.10409    |   0.0 |  0.05
Output  | 0.0002566  | 0.0002566  | 0.0002566  |   0.0 |  0.00
Modify  | 0.39962    | 0.39962    | 0.39962    |   0.0 |  0.17
Other   |            | 0.06315    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4140 ave        4140 max        4140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244972 ave      244972 max      244972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244972
Ave neighs/atom = 122.486
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.54045165831, Press = -1.20297517004474
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     41000  -8398.8086     -8398.8086     -8479.106      -8479.106       310.75912      310.75912      23523.434      23523.434      946.96732      946.96732    
     42000  -8400.6524     -8400.6524     -8480.1742     -8480.1742      307.75757      307.75757      23503.92       23503.92       2027.865       2027.865     
Loop time of 232.35 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.542 hours/ns, 4.304 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    | 231.78     | 231.78     | 231.78     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10385    | 0.10385    | 0.10385    |   0.0 |  0.04
Output  | 0.00016499 | 0.00016499 | 0.00016499 |   0.0 |  0.00
Modify  | 0.40007    | 0.40007    | 0.40007    |   0.0 |  0.17
Other   |            | 0.0635     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4133 ave        4133 max        4133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244644 ave      244644 max      244644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244644
Ave neighs/atom = 122.322
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.554510000463, Press = -1.01315032702612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     42000  -8400.6524     -8400.6524     -8480.1742     -8480.1742      307.75757      307.75757      23503.92       23503.92       2027.865       2027.865     
     43000  -8397.9272     -8397.9272     -8478.0383     -8478.0383      310.03812      310.03812      23482.859      23482.859      4464.0556      4464.0556    
Loop time of 229.582 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.773 hours/ns, 4.356 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    | 229.02     | 229.02     | 229.02     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1025     | 0.1025     | 0.1025     |   0.0 |  0.04
Output  | 0.00020554 | 0.00020554 | 0.00020554 |   0.0 |  0.00
Modify  | 0.3925     | 0.3925     | 0.3925     |   0.0 |  0.17
Other   |            | 0.06264    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244962 ave      244962 max      244962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244962
Ave neighs/atom = 122.481
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.526421020345, Press = -0.940615376170729
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     43000  -8397.9272     -8397.9272     -8478.0383     -8478.0383      310.03812      310.03812      23482.859      23482.859      4464.0556      4464.0556    
     44000  -8401.9117     -8401.9117     -8482.8269     -8482.8269      313.1504       313.1504       23461.86       23461.86       4592.7733      4592.7733    
Loop time of 230.244 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.957 hours/ns, 4.343 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    | 229.69     | 229.69     | 229.69     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10254    | 0.10254    | 0.10254    |   0.0 |  0.04
Output  | 0.00016495 | 0.00016495 | 0.00016495 |   0.0 |  0.00
Modify  | 0.39118    | 0.39118    | 0.39118    |   0.0 |  0.17
Other   |            | 0.06303    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245340 ave      245340 max      245340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245340
Ave neighs/atom = 122.67
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.513440104864, Press = -0.750583740376664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     44000  -8401.9117     -8401.9117     -8482.8269     -8482.8269      313.1504       313.1504       23461.86       23461.86       4592.7733      4592.7733    
     45000  -8400.229      -8400.229      -8481.8094     -8481.8094      315.72468      315.72468      23500.167      23500.167      2015.2179      2015.2179    
Loop time of 232.613 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.615 hours/ns, 4.299 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    | 232.06     | 232.06     | 232.06     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10263    | 0.10263    | 0.10263    |   0.0 |  0.04
Output  | 0.00016452 | 0.00016452 | 0.00016452 |   0.0 |  0.00
Modify  | 0.39261    | 0.39261    | 0.39261    |   0.0 |  0.17
Other   |            | 0.06268    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4149 ave        4149 max        4149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245492 ave      245492 max      245492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245492
Ave neighs/atom = 122.746
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.520953110329, Press = -1.8000886944839
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     45000  -8400.229      -8400.229      -8481.8094     -8481.8094      315.72468      315.72468      23500.167      23500.167      2015.2179      2015.2179    
     46000  -8400.9172     -8400.9172     -8482.1073     -8482.1073      314.21413      314.21413      23514.874      23514.874      886.18899      886.18899    
Loop time of 232.122 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.478 hours/ns, 4.308 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    | 231.56     | 231.56     | 231.56     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10251    | 0.10251    | 0.10251    |   0.0 |  0.04
Output  | 0.00016294 | 0.00016294 | 0.00016294 |   0.0 |  0.00
Modify  | 0.39654    | 0.39654    | 0.39654    |   0.0 |  0.17
Other   |            | 0.0628     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4139 ave        4139 max        4139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245098 ave      245098 max      245098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245098
Ave neighs/atom = 122.549
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.438458910285, Press = -1.35667264719995
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     46000  -8400.9172     -8400.9172     -8482.1073     -8482.1073      314.21413      314.21413      23514.874      23514.874      886.18899      886.18899    
     47000  -8402.241      -8402.241      -8481.5159     -8481.5159      306.8019       306.8019       23516.299      23516.299      517.83588      517.83588    
Loop time of 230.105 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.918 hours/ns, 4.346 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    | 229.55     | 229.55     | 229.55     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10153    | 0.10153    | 0.10153    |   0.0 |  0.04
Output  | 0.00016466 | 0.00016466 | 0.00016466 |   0.0 |  0.00
Modify  | 0.38697    | 0.38697    | 0.38697    |   0.0 |  0.17
Other   |            | 0.06169    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244528 ave      244528 max      244528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244528
Ave neighs/atom = 122.264
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.423033256695, Press = -1.74182873683623
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     47000  -8402.241      -8402.241      -8481.5159     -8481.5159      306.8019       306.8019       23516.299      23516.299      517.83588      517.83588    
     48000  -8399.3929     -8399.3929     -8479.6553     -8479.6553      310.62385      310.62385      23535.144      23535.144      33.386589      33.386589    
Loop time of 230.181 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.939 hours/ns, 4.344 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    | 229.63     | 229.63     | 229.63     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10254    | 0.10254    | 0.10254    |   0.0 |  0.04
Output  | 0.00016458 | 0.00016458 | 0.00016458 |   0.0 |  0.00
Modify  | 0.38977    | 0.38977    | 0.38977    |   0.0 |  0.17
Other   |            | 0.06239    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244746 ave      244746 max      244746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244746
Ave neighs/atom = 122.373
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.343514451284, Press = -2.53448046293858
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     48000  -8399.3929     -8399.3929     -8479.6553     -8479.6553      310.62385      310.62385      23535.144      23535.144      33.386589      33.386589    
     49000  -8400.516      -8400.516      -8482.6085     -8482.6085      317.70662      317.70662      23542.85       23542.85      -1278.1904     -1278.1904    
Loop time of 230.755 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.099 hours/ns, 4.334 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    | 230.19     | 230.19     | 230.19     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10318    | 0.10318    | 0.10318    |   0.0 |  0.04
Output  | 0.00021007 | 0.00021007 | 0.00021007 |   0.0 |  0.00
Modify  | 0.39683    | 0.39683    | 0.39683    |   0.0 |  0.17
Other   |            | 0.06258    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4139 ave        4139 max        4139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244400 ave      244400 max      244400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244400
Ave neighs/atom = 122.2
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.306636851774, Press = -4.25092346778336
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     49000  -8400.516      -8400.516      -8482.6085     -8482.6085      317.70662      317.70662      23542.85       23542.85      -1278.1904     -1278.1904    
     50000  -8400.7532     -8400.7532     -8481.5952     -8481.5952      312.86701      312.86701      23548.691      23548.691     -1697.1784     -1697.1784    
Loop time of 231.045 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.179 hours/ns, 4.328 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    | 230.49     | 230.49     | 230.49     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10227    | 0.10227    | 0.10227    |   0.0 |  0.04
Output  | 0.0001651  | 0.0001651  | 0.0001651  |   0.0 |  0.00
Modify  | 0.39242    | 0.39242    | 0.39242    |   0.0 |  0.17
Other   |            | 0.06249    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4136 ave        4136 max        4136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244166 ave      244166 max      244166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244166
Ave neighs/atom = 122.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.231371543211, Press = -2.31853526707252
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     50000  -8400.7532     -8400.7532     -8481.5952     -8481.5952      312.86701      312.86701      23548.691      23548.691     -1697.1784     -1697.1784    
     51000  -8400.4469     -8400.4469     -8481.9331     -8481.9331      315.36004      315.36004      23539.052      23539.052     -908.70008     -908.70008    
Loop time of 232.427 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.563 hours/ns, 4.302 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    | 231.86     | 231.86     | 231.86     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10397    | 0.10397    | 0.10397    |   0.0 |  0.04
Output  | 0.00016528 | 0.00016528 | 0.00016528 |   0.0 |  0.00
Modify  | 0.39767    | 0.39767    | 0.39767    |   0.0 |  0.17
Other   |            | 0.06304    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244106 ave      244106 max      244106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244106
Ave neighs/atom = 122.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 = 313.233289778374, Press = -1.69386784168145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     51000  -8400.4469     -8400.4469     -8481.9331     -8481.9331      315.36004      315.36004      23539.052      23539.052     -908.70008     -908.70008    
     52000  -8401.2831     -8401.2831     -8479.0481     -8479.0481      300.95887      300.95887      23543.881      23543.881     -751.02968     -751.02968    
Loop time of 228.282 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.412 hours/ns, 4.381 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    | 227.73     | 227.73     | 227.73     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10151    | 0.10151    | 0.10151    |   0.0 |  0.04
Output  | 0.00043351 | 0.00043351 | 0.00043351 |   0.0 |  0.00
Modify  | 0.38393    | 0.38393    | 0.38393    |   0.0 |  0.17
Other   |            | 0.06192    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244098 ave      244098 max      244098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244098
Ave neighs/atom = 122.049
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.176606128135, Press = -1.11070333772803
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     52000  -8401.2831     -8401.2831     -8479.0481     -8479.0481      300.95887      300.95887      23543.881      23543.881     -751.02968     -751.02968    
     53000  -8402.4868     -8402.4868     -8481.6593     -8481.6593      306.40572      306.40572      23542.066      23542.066     -1206.9754     -1206.9754    
Loop time of 229.96 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.878 hours/ns, 4.349 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    | 229.4      | 229.4      | 229.4      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10338    | 0.10338    | 0.10338    |   0.0 |  0.04
Output  | 0.00016419 | 0.00016419 | 0.00016419 |   0.0 |  0.00
Modify  | 0.39735    | 0.39735    | 0.39735    |   0.0 |  0.17
Other   |            | 0.06339    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4144 ave        4144 max        4144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244316 ave      244316 max      244316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244316
Ave neighs/atom = 122.158
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.14202217246, Press = -1.42309143407556
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     53000  -8402.4868     -8402.4868     -8481.6593     -8481.6593      306.40572      306.40572      23542.066      23542.066     -1206.9754     -1206.9754    
     54000  -8401.26       -8401.26       -8479.5938     -8479.5938      303.15977      303.15977      23553.301      23553.301     -1474.5431     -1474.5431    
Loop time of 230.668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 64.074 hours/ns, 4.335 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    | 230.11     | 230.11     | 230.11     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10261    | 0.10261    | 0.10261    |   0.0 |  0.04
Output  | 0.00016544 | 0.00016544 | 0.00016544 |   0.0 |  0.00
Modify  | 0.39484    | 0.39484    | 0.39484    |   0.0 |  0.17
Other   |            | 0.06321    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4136 ave        4136 max        4136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244038 ave      244038 max      244038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244038
Ave neighs/atom = 122.019
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.078182543441, Press = -1.10377854137132
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     54000  -8401.26       -8401.26       -8479.5938     -8479.5938      303.15977      303.15977      23553.301      23553.301     -1474.5431     -1474.5431    
     55000  -8400.8944     -8400.8944     -8480.3429     -8480.3429      307.474        307.474        23592.097      23592.097     -4752.0935     -4752.0935    
Loop time of 231.153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.209 hours/ns, 4.326 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    | 230.59     | 230.59     | 230.59     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10302    | 0.10302    | 0.10302    |   0.0 |  0.04
Output  | 0.00020621 | 0.00020621 | 0.00020621 |   0.0 |  0.00
Modify  | 0.39616    | 0.39616    | 0.39616    |   0.0 |  0.17
Other   |            | 0.06276    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244106 ave      244106 max      244106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244106
Ave neighs/atom = 122.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 = 313.088756288599, Press = -0.782191581806812
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     55000  -8400.8944     -8400.8944     -8480.3429     -8480.3429      307.474        307.474        23592.097      23592.097     -4752.0935     -4752.0935    
     56000  -8399.1293     -8399.1293     -8482.6051     -8482.6051      323.05988      323.05988      23574.917      23574.917     -3705.1458     -3705.1458    
Loop time of 227.376 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.160 hours/ns, 4.398 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    | 226.83     | 226.83     | 226.83     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10102    | 0.10102    | 0.10102    |   0.0 |  0.04
Output  | 0.00020225 | 0.00020225 | 0.00020225 |   0.0 |  0.00
Modify  | 0.38719    | 0.38719    | 0.38719    |   0.0 |  0.17
Other   |            | 0.06225    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243518 ave      243518 max      243518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 243518
Ave neighs/atom = 121.759
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.120251817093, Press = -1.08663165521893
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     56000  -8399.1293     -8399.1293     -8482.6051     -8482.6051      323.05988      323.05988      23574.917      23574.917     -3705.1458     -3705.1458    
     57000  -8402.82       -8402.82       -8479.8693     -8479.8693      298.18885      298.18885      23535.221      23535.221     -446.54386     -446.54386    
Loop time of 230.459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 64.016 hours/ns, 4.339 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    | 229.9      | 229.9      | 229.9      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10319    | 0.10319    | 0.10319    |   0.0 |  0.04
Output  | 0.00016374 | 0.00016374 | 0.00016374 |   0.0 |  0.00
Modify  | 0.39438    | 0.39438    | 0.39438    |   0.0 |  0.17
Other   |            | 0.06337    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4144 ave        4144 max        4144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243606 ave      243606 max      243606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 243606
Ave neighs/atom = 121.803
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.141397456564, Press = -0.333427023448455
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     57000  -8402.82       -8402.82       -8479.8693     -8479.8693      298.18885      298.18885      23535.221      23535.221     -446.54386     -446.54386    
     58000  -8399.7277     -8399.7277     -8481.1281     -8481.1281      315.02771      315.02771      23543.996      23543.996     -1103.0631     -1103.0631    
Loop time of 230.433 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 64.009 hours/ns, 4.340 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    | 229.88     | 229.88     | 229.88     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10185    | 0.10185    | 0.10185    |   0.0 |  0.04
Output  | 0.00025717 | 0.00025717 | 0.00025717 |   0.0 |  0.00
Modify  | 0.38649    | 0.38649    | 0.38649    |   0.0 |  0.17
Other   |            | 0.06206    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4145 ave        4145 max        4145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244232 ave      244232 max      244232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244232
Ave neighs/atom = 122.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.149788446654, Press = -0.736888592217988
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     58000  -8399.7277     -8399.7277     -8481.1281     -8481.1281      315.02771      315.02771      23543.996      23543.996     -1103.0631     -1103.0631    
     59000  -8401.3051     -8401.3051     -8481.9575     -8481.9575      312.13314      312.13314      23549.579      23549.579     -1838.8703     -1838.8703    
Loop time of 227.351 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.153 hours/ns, 4.398 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    | 226.8      | 226.8      | 226.8      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10078    | 0.10078    | 0.10078    |   0.0 |  0.04
Output  | 0.00016248 | 0.00016248 | 0.00016248 |   0.0 |  0.00
Modify  | 0.38372    | 0.38372    | 0.38372    |   0.0 |  0.17
Other   |            | 0.06218    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4140 ave        4140 max        4140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244088 ave      244088 max      244088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244088
Ave neighs/atom = 122.044
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.127358613871, Press = -0.469515578518884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   
     59000  -8401.3051     -8401.3051     -8481.9575     -8481.9575      312.13314      312.13314      23549.579      23549.579     -1838.8703     -1838.8703    
     60000  -8397.4543     -8397.4543     -8479.2649     -8479.2649      316.61529      316.61529      23582.166      23582.166     -3340.129      -3340.129     
Loop time of 230.73 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.092 hours/ns, 4.334 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    | 230.17     | 230.17     | 230.17     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10267    | 0.10267    | 0.10267    |   0.0 |  0.04
Output  | 0.00023045 | 0.00023045 | 0.00023045 |   0.0 |  0.00
Modify  | 0.39261    | 0.39261    | 0.39261    |   0.0 |  0.17
Other   |            | 0.06262    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243918 ave      243918 max      243918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 243918
Ave neighs/atom = 121.959
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
23528.5692949457

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0