# 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 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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  -8484.2489     -8484.2489     -8559.9963     -8559.9963      293.15         293.15         23173.474      23173.474      3491.3707      3491.3707    
      1000  -8412.2183     -8412.2183     -8485.1952     -8485.1952      282.42803      282.42803      23437.685      23437.685      5346.9298      5346.9298    
Loop time of 232.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.558 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.9      | 231.9      | 231.9      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097693   | 0.097693   | 0.097693   |   0.0 |  0.04
Output  | 0.00021604 | 0.00021604 | 0.00021604 |   0.0 |  0.00
Modify  | 0.35147    | 0.35147    | 0.35147    |   0.0 |  0.15
Other   |            | 0.06042    |            |       |  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  -8412.2183     -8412.2183     -8485.1952     -8485.1952      282.42803      282.42803      23437.685      23437.685      5346.9298      5346.9298    
      2000  -8408.1468     -8408.1468     -8485.7752     -8485.7752      300.42986      300.42986      23519.36       23519.36      -741.81937     -741.81937    
Loop time of 227.43 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.175 hours/ns, 4.397 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.91     | 226.91     | 226.91     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10038    | 0.10038    | 0.10038    |   0.0 |  0.04
Output  | 0.0002646  | 0.0002646  | 0.0002646  |   0.0 |  0.00
Modify  | 0.3609     | 0.3609     | 0.3609     |   0.0 |  0.16
Other   |            | 0.06126    |            |       |  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:       246058 ave      246058 max      246058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 246058
Ave neighs/atom = 123.029
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -8408.1468     -8408.1468     -8485.7752     -8485.7752      300.42986      300.42986      23519.36       23519.36      -741.81937     -741.81937    
      3000  -8413.2499     -8413.2499     -8488.0502     -8488.0502      289.48456      289.48456      23504.325      23504.325     -44.716994     -44.716994    
Loop time of 228.315 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.421 hours/ns, 4.380 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.78     | 227.78     | 227.78     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10191    | 0.10191    | 0.10191    |   0.0 |  0.04
Output  | 0.00020901 | 0.00020901 | 0.00020901 |   0.0 |  0.00
Modify  | 0.36789    | 0.36789    | 0.36789    |   0.0 |  0.16
Other   |            | 0.06128    |            |       |  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:       244364 ave      244364 max      244364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244364
Ave neighs/atom = 122.182
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -8413.2499     -8413.2499     -8488.0502     -8488.0502      289.48456      289.48456      23504.325      23504.325     -44.716994     -44.716994    
      4000  -8408.3368     -8408.3368     -8486.0759     -8486.0759      300.8583       300.8583       23513.855      23513.855     -319.1493      -319.1493     
Loop time of 230.052 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.903 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.52     | 229.52     | 229.52     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10145    | 0.10145    | 0.10145    |   0.0 |  0.04
Output  | 0.00024647 | 0.00024647 | 0.00024647 |   0.0 |  0.00
Modify  | 0.36618    | 0.36618    | 0.36618    |   0.0 |  0.16
Other   |            | 0.06172    |            |       |  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:       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 = 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  -8408.3368     -8408.3368     -8486.0759     -8486.0759      300.8583       300.8583       23513.855      23513.855     -319.1493      -319.1493     
      5000  -8412.7198     -8412.7198     -8487.1426     -8487.1426      288.02383      288.02383      23474.895      23474.895      2083.335       2083.335     
Loop time of 228.316 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.421 hours/ns, 4.380 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.79     | 227.79     | 227.79     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10088    | 0.10088    | 0.10088    |   0.0 |  0.04
Output  | 0.00022586 | 0.00022586 | 0.00022586 |   0.0 |  0.00
Modify  | 0.36671    | 0.36671    | 0.36671    |   0.0 |  0.16
Other   |            | 0.06232    |            |       |  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:       244768 ave      244768 max      244768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244768
Ave neighs/atom = 122.384
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 289.441259286938, Press = -571.873933576771
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.7198     -8412.7198     -8487.1426     -8487.1426      288.02383      288.02383      23474.895      23474.895      2083.335       2083.335     
      6000  -8412.346      -8412.346      -8487.9863     -8487.9863      292.73582      292.73582      23478.873      23478.873      1758.3067      1758.3067    
Loop time of 228.314 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.421 hours/ns, 4.380 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.77     | 227.77     | 227.77     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10104    | 0.10104    | 0.10104    |   0.0 |  0.04
Output  | 0.00016613 | 0.00016613 | 0.00016613 |   0.0 |  0.00
Modify  | 0.38344    | 0.38344    | 0.38344    |   0.0 |  0.17
Other   |            | 0.06148    |            |       |  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:       245258 ave      245258 max      245258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245258
Ave neighs/atom = 122.629
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.703389522507, Press = 13.9643173181612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.346      -8412.346      -8487.9863     -8487.9863      292.73582      292.73582      23478.873      23478.873      1758.3067      1758.3067    
      7000  -8408.7277     -8408.7277     -8484.7843     -8484.7843      294.34719      294.34719      23535.699      23535.699     -1742.938      -1742.938     
Loop time of 231.941 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.428 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.38     | 231.38     | 231.38     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10308    | 0.10308    | 0.10308    |   0.0 |  0.04
Output  | 0.0001659  | 0.0001659  | 0.0001659  |   0.0 |  0.00
Modify  | 0.39667    | 0.39667    | 0.39667    |   0.0 |  0.17
Other   |            | 0.06209    |            |       |  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:       245168 ave      245168 max      245168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245168
Ave neighs/atom = 122.584
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.705871504111, Press = 26.9271237718598
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8408.7277     -8408.7277     -8484.7843     -8484.7843      294.34719      294.34719      23535.699      23535.699     -1742.938      -1742.938     
      8000  -8412.5846     -8412.5846     -8486.8487     -8486.8487      287.40994      287.40994      23549.157      23549.157     -3322.7018     -3322.7018    
Loop time of 229.153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.654 hours/ns, 4.364 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.6      | 228.6      | 228.6      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1011     | 0.1011     | 0.1011     |   0.0 |  0.04
Output  | 0.00016462 | 0.00016462 | 0.00016462 |   0.0 |  0.00
Modify  | 0.38628    | 0.38628    | 0.38628    |   0.0 |  0.17
Other   |            | 0.0612     |            |       |  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:       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 = 291.968932847407, Press = -21.1213411414682
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.5846     -8412.5846     -8486.8487     -8486.8487      287.40994      287.40994      23549.157      23549.157     -3322.7018     -3322.7018    
      9000  -8408.7396     -8408.7396     -8486.0293     -8486.0293      299.11933      299.11933      23510.235      23510.235     -159.14647     -159.14647    
Loop time of 228.863 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.573 hours/ns, 4.369 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.31     | 228.31     | 228.31     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10022    | 0.10022    | 0.10022    |   0.0 |  0.04
Output  | 0.00016617 | 0.00016617 | 0.00016617 |   0.0 |  0.00
Modify  | 0.38666    | 0.38666    | 0.38666    |   0.0 |  0.17
Other   |            | 0.06137    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4126 ave        4126 max        4126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244044 ave      244044 max      244044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244044
Ave neighs/atom = 122.022
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.27796840497, Press = -16.4474048809948
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8408.7396     -8408.7396     -8486.0293     -8486.0293      299.11933      299.11933      23510.235      23510.235     -159.14647     -159.14647    
     10000  -8412.9897     -8412.9897     -8486.8867     -8486.8867      285.98931      285.98931      23477.795      23477.795      2055.0461      2055.0461    
Loop time of 230.56 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 64.044 hours/ns, 4.337 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        | 230        | 230        |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10115    | 0.10115    | 0.10115    |   0.0 |  0.04
Output  | 0.00016527 | 0.00016527 | 0.00016527 |   0.0 |  0.00
Modify  | 0.39241    | 0.39241    | 0.39241    |   0.0 |  0.17
Other   |            | 0.06196    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4122 ave        4122 max        4122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244678 ave      244678 max      244678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244678
Ave neighs/atom = 122.339
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.234933008343, Press = -17.1641804977961
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.9897     -8412.9897     -8486.8867     -8486.8867      285.98931      285.98931      23477.795      23477.795      2055.0461      2055.0461    
     11000  -8408.7703     -8408.7703     -8485.0313     -8485.0313      295.13821      295.13821      23485.162      23485.162      2153.1429      2153.1429    
Loop time of 231.05 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.181 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.10304    | 0.10304    | 0.10304    |   0.0 |  0.04
Output  | 0.0001652  | 0.0001652  | 0.0001652  |   0.0 |  0.00
Modify  | 0.39631    | 0.39631    | 0.39631    |   0.0 |  0.17
Other   |            | 0.06233    |            |       |  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:       245028 ave      245028 max      245028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245028
Ave neighs/atom = 122.514
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.386928041774, Press = -3.52275574562664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8408.7703     -8408.7703     -8485.0313     -8485.0313      295.13821      295.13821      23485.162      23485.162      2153.1429      2153.1429    
     12000  -8411.1129     -8411.1129     -8485.6623     -8485.6623      288.51365      288.51365      23505.3        23505.3        174.11708      174.11708    
Loop time of 230.6 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 64.056 hours/ns, 4.337 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.04     | 230.04     | 230.04     |   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.00016959 | 0.00016959 | 0.00016959 |   0.0 |  0.00
Modify  | 0.39451    | 0.39451    | 0.39451    |   0.0 |  0.17
Other   |            | 0.06122    |            |       |  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:       245140 ave      245140 max      245140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245140
Ave neighs/atom = 122.57
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.383948546886, Press = -1.71028179906132
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8411.1129     -8411.1129     -8485.6623     -8485.6623      288.51365      288.51365      23505.3        23505.3        174.11708      174.11708    
     13000  -8410.7875     -8410.7875     -8486.833      -8486.833       294.30384      294.30384      23514.763      23514.763     -795.22117     -795.22117    
Loop time of 229.733 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.815 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.18     | 229.18     | 229.18     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10237    | 0.10237    | 0.10237    |   0.0 |  0.04
Output  | 0.00016423 | 0.00016423 | 0.00016423 |   0.0 |  0.00
Modify  | 0.3924     | 0.3924     | 0.3924     |   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:           4154 ave        4154 max        4154 min
Histogram: 1 0 0 0 0 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 = 292.482034122654, Press = -3.08982998579518
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8410.7875     -8410.7875     -8486.833      -8486.833       294.30384      294.30384      23514.763      23514.763     -795.22117     -795.22117    
     14000  -8411.1306     -8411.1306     -8486.4576     -8486.4576      291.52302      291.52302      23524.553      23524.553     -1159.7286     -1159.7286    
Loop time of 232.311 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.531 hours/ns, 4.305 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.75     | 231.75     | 231.75     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10326    | 0.10326    | 0.10326    |   0.0 |  0.04
Output  | 0.00044856 | 0.00044856 | 0.00044856 |   0.0 |  0.00
Modify  | 0.39837    | 0.39837    | 0.39837    |   0.0 |  0.17
Other   |            | 0.06241    |            |       |  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:       244646 ave      244646 max      244646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244646
Ave neighs/atom = 122.323
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.485318423736, Press = -5.59517009549123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8411.1306     -8411.1306     -8486.4576     -8486.4576      291.52302      291.52302      23524.553      23524.553     -1159.7286     -1159.7286    
     15000  -8407.2601     -8407.2601     -8485.3454     -8485.3454      302.1983       302.1983       23521.385      23521.385     -708.25935     -708.25935    
Loop time of 231.85 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.403 hours/ns, 4.313 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.29     | 231.29     | 231.29     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10235    | 0.10235    | 0.10235    |   0.0 |  0.04
Output  | 0.00016425 | 0.00016425 | 0.00016425 |   0.0 |  0.00
Modify  | 0.39689    | 0.39689    | 0.39689    |   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:           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:       244250 ave      244250 max      244250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244250
Ave neighs/atom = 122.125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.765346847563, Press = -6.38332087536684
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8407.2601     -8407.2601     -8485.3454     -8485.3454      302.1983       302.1983       23521.385      23521.385     -708.25935     -708.25935    
     16000  -8413.0471     -8413.0471     -8489.2954     -8489.2954      295.08892      295.08892      23475.238      23475.238      1779.1227      1779.1227    
Loop time of 231.466 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.296 hours/ns, 4.320 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.9      | 230.9      | 230.9      |   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.00022286 | 0.00022286 | 0.00022286 |   0.0 |  0.00
Modify  | 0.40025    | 0.40025    | 0.40025    |   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:           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:       244568 ave      244568 max      244568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244568
Ave neighs/atom = 122.284
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.647547676668, Press = -5.00242915886161
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8413.0471     -8413.0471     -8489.2954     -8489.2954      295.08892      295.08892      23475.238      23475.238      1779.1227      1779.1227    
     17000  -8412.3911     -8412.3911     -8485.7051     -8485.7051      283.73269      283.73269      23479.274      23479.274      2196.5248      2196.5248    
Loop time of 231.598 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.333 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.04     | 231.04     | 231.04     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10258    | 0.10258    | 0.10258    |   0.0 |  0.04
Output  | 0.00016167 | 0.00016167 | 0.00016167 |   0.0 |  0.00
Modify  | 0.39264    | 0.39264    | 0.39264    |   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:           4137 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 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 = 292.684612036203, Press = -1.22832122049849
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.3911     -8412.3911     -8485.7051     -8485.7051      283.73269      283.73269      23479.274      23479.274      2196.5248      2196.5248    
     18000  -8409.0922     -8409.0922     -8484.2015     -8484.2015      290.68066      290.68066      23509.551      23509.551      391.62325      391.62325    
Loop time of 232.323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.534 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.76     | 231.76     | 231.76     |   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.00022551 | 0.00022551 | 0.00022551 |   0.0 |  0.00
Modify  | 0.39649    | 0.39649    | 0.39649    |   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:           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:       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 = 292.729017117342, Press = 0.695073131301246
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8409.0922     -8409.0922     -8484.2015     -8484.2015      290.68066      290.68066      23509.551      23509.551      391.62325      391.62325    
     19000  -8411.4057     -8411.4057     -8485.003      -8485.003       284.82918      284.82918      23528.068      23528.068     -1365.5341     -1365.5341    
Loop time of 231.94 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.428 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.10126    | 0.10126    | 0.10126    |   0.0 |  0.04
Output  | 0.00016617 | 0.00016617 | 0.00016617 |   0.0 |  0.00
Modify  | 0.39084    | 0.39084    | 0.39084    |   0.0 |  0.17
Other   |            | 0.06158    |            |       |  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:       244542 ave      244542 max      244542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244542
Ave neighs/atom = 122.271
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.911836501971, Press = -1.91977552328639
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8411.4057     -8411.4057     -8485.003      -8485.003       284.82918      284.82918      23528.068      23528.068     -1365.5341     -1365.5341    
     20000  -8411.5245     -8411.5245     -8487.1329     -8487.1329      292.61267      292.61267      23521.248      23521.248     -1297.2591     -1297.2591    
Loop time of 232.182 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.495 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.61     | 231.61     | 231.61     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10306    | 0.10306    | 0.10306    |   0.0 |  0.04
Output  | 0.00016661 | 0.00016661 | 0.00016661 |   0.0 |  0.00
Modify  | 0.40307    | 0.40307    | 0.40307    |   0.0 |  0.17
Other   |            | 0.06252    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4126 ave        4126 max        4126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244456 ave      244456 max      244456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244456
Ave neighs/atom = 122.228
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.924558489663, Press = -3.01027417906821
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8411.5245     -8411.5245     -8487.1329     -8487.1329      292.61267      292.61267      23521.248      23521.248     -1297.2591     -1297.2591    
     21000  -8409.0908     -8409.0908     -8487.2303     -8487.2303      302.40799      302.40799      23512.732      23512.732     -683.56525     -683.56525    
Loop time of 231.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.215 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.62     | 230.62     | 230.62     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10291    | 0.10291    | 0.10291    |   0.0 |  0.04
Output  | 0.00016667 | 0.00016667 | 0.00016667 |   0.0 |  0.00
Modify  | 0.3929     | 0.3929     | 0.3929     |   0.0 |  0.17
Other   |            | 0.06186    |            |       |  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:       244554 ave      244554 max      244554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244554
Ave neighs/atom = 122.277
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.898997546489, Press = -4.54638042330634
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8409.0908     -8409.0908     -8487.2303     -8487.2303      302.40799      302.40799      23512.732      23512.732     -683.56525     -683.56525    
     22000  -8413.2759     -8413.2759     -8488.4418     -8488.4418      290.8996       290.8996       23502.784      23502.784     -273.29228     -273.29228    
Loop time of 232.942 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.706 hours/ns, 4.293 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.38     | 232.38     | 232.38     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10303    | 0.10303    | 0.10303    |   0.0 |  0.04
Output  | 0.00022569 | 0.00022569 | 0.00022569 |   0.0 |  0.00
Modify  | 0.39902    | 0.39902    | 0.39902    |   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:           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:       244592 ave      244592 max      244592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244592
Ave neighs/atom = 122.296
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.860861073345, Press = -0.239975392294363
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8413.2759     -8413.2759     -8488.4418     -8488.4418      290.8996       290.8996       23502.784      23502.784     -273.29228     -273.29228    
     23000  -8408.8964     -8408.8964     -8485.7851     -8485.7851      297.56725      297.56725      23545.786      23545.786     -2812.0947     -2812.0947    
Loop time of 231.523 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.312 hours/ns, 4.319 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.96     | 230.96     | 230.96     |   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.00020771 | 0.00020771 | 0.00020771 |   0.0 |  0.00
Modify  | 0.3941     | 0.3941     | 0.3941     |   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:           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:       244854 ave      244854 max      244854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244854
Ave neighs/atom = 122.427
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.86347318044, Press = -5.41906790835796
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8408.8964     -8408.8964     -8485.7851     -8485.7851      297.56725      297.56725      23545.786      23545.786     -2812.0947     -2812.0947    
     24000  -8411.4221     -8411.4221     -8486.3001     -8486.3001      289.78573      289.78573      23503.877      23503.877      137.32732      137.32732    
Loop time of 229.894 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.860 hours/ns, 4.350 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.34     | 229.34     | 229.34     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10189    | 0.10189    | 0.10189    |   0.0 |  0.04
Output  | 0.00016897 | 0.00016897 | 0.00016897 |   0.0 |  0.00
Modify  | 0.39432    | 0.39432    | 0.39432    |   0.0 |  0.17
Other   |            | 0.06176    |            |       |  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:       244000 ave      244000 max      244000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244000
Ave neighs/atom = 122
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.888789881483, Press = -5.59097356324445
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8411.4221     -8411.4221     -8486.3001     -8486.3001      289.78573      289.78573      23503.877      23503.877      137.32732      137.32732    
     25000  -8410.3492     -8410.3492     -8487.0726     -8487.0726      296.92712      296.92712      23495.189      23495.189      787.21076      787.21076    
Loop time of 228.869 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.575 hours/ns, 4.369 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.31     | 228.31     | 228.31     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10136    | 0.10136    | 0.10136    |   0.0 |  0.04
Output  | 0.00016528 | 0.00016528 | 0.00016528 |   0.0 |  0.00
Modify  | 0.3918     | 0.3918     | 0.3918     |   0.0 |  0.17
Other   |            | 0.06172    |            |       |  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:       244616 ave      244616 max      244616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244616
Ave neighs/atom = 122.308
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.059281439932, Press = -5.04159015214647
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8410.3492     -8410.3492     -8487.0726     -8487.0726      296.92712      296.92712      23495.189      23495.189      787.21076      787.21076    
     26000  -8409.7508     -8409.7508     -8485.8491     -8485.8491      294.50844      294.50844      23478.228      23478.228      2240.2064      2240.2064    
Loop time of 227.989 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.330 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.44     | 227.44     | 227.44     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1008     | 0.1008     | 0.1008     |   0.0 |  0.04
Output  | 0.00016536 | 0.00016536 | 0.00016536 |   0.0 |  0.00
Modify  | 0.38558    | 0.38558    | 0.38558    |   0.0 |  0.17
Other   |            | 0.06161    |            |       |  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:       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 = 293.113199787206, Press = -1.46095434241703
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8409.7508     -8409.7508     -8485.8491     -8485.8491      294.50844      294.50844      23478.228      23478.228      2240.2064      2240.2064    
     27000  -8411.2495     -8411.2495     -8485.9744     -8485.9744      289.19306      289.19306      23485.6        23485.6        1558.1186      1558.1186    
Loop time of 227.41 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.169 hours/ns, 4.397 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.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10159    | 0.10159    | 0.10159    |   0.0 |  0.04
Output  | 0.0002156  | 0.0002156  | 0.0002156  |   0.0 |  0.00
Modify  | 0.38705    | 0.38705    | 0.38705    |   0.0 |  0.17
Other   |            | 0.06134    |            |       |  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:       245252 ave      245252 max      245252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245252
Ave neighs/atom = 122.626
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.161694954106, Press = 1.34688755988364
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8411.2495     -8411.2495     -8485.9744     -8485.9744      289.19306      289.19306      23485.6        23485.6        1558.1186      1558.1186    
     28000  -8405.0178     -8405.0178     -8483.1449     -8483.1449      302.35992      302.35992      23566.808      23566.808     -3417.4823     -3417.4823    
Loop time of 226.96 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.381 ns/day, 63.044 hours/ns, 4.406 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.41     | 226.41     | 226.41     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10056    | 0.10056    | 0.10056    |   0.0 |  0.04
Output  | 0.00016394 | 0.00016394 | 0.00016394 |   0.0 |  0.00
Modify  | 0.3835     | 0.3835     | 0.3835     |   0.0 |  0.17
Other   |            | 0.06146    |            |       |  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:       245112 ave      245112 max      245112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245112
Ave neighs/atom = 122.556
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.247481591792, Press = 2.09544722867554
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8405.0178     -8405.0178     -8483.1449     -8483.1449      302.35992      302.35992      23566.808      23566.808     -3417.4823     -3417.4823    
     29000  -8412.305      -8412.305      -8486.5403     -8486.5403      287.29858      287.29858      23531.324      23531.324     -2056.0134     -2056.0134    
Loop time of 227.753 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.265 hours/ns, 4.391 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.2      | 227.2      | 227.2      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1014     | 0.1014     | 0.1014     |   0.0 |  0.04
Output  | 0.00020744 | 0.00020744 | 0.00020744 |   0.0 |  0.00
Modify  | 0.38846    | 0.38846    | 0.38846    |   0.0 |  0.17
Other   |            | 0.06179    |            |       |  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:       243784 ave      243784 max      243784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 243784
Ave neighs/atom = 121.892
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.295769367183, Press = -1.96395699680576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.305      -8412.305      -8486.5403     -8486.5403      287.29858      287.29858      23531.324      23531.324     -2056.0134     -2056.0134    
     30000  -8409.2736     -8409.2736     -8485.4464     -8485.4464      294.79647      294.79647      23515.37       23515.37      -502.48701     -502.48701    
Loop time of 227.627 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.230 hours/ns, 4.393 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.07     | 227.07     | 227.07     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1021     | 0.1021     | 0.1021     |   0.0 |  0.04
Output  | 0.0001631  | 0.0001631  | 0.0001631  |   0.0 |  0.00
Modify  | 0.39289    | 0.39289    | 0.39289    |   0.0 |  0.17
Other   |            | 0.06162    |            |       |  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:       244310 ave      244310 max      244310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244310
Ave neighs/atom = 122.155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.284937811281, Press = -3.4704672157237
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8409.2736     -8409.2736     -8485.4464     -8485.4464      294.79647      294.79647      23515.37       23515.37      -502.48701     -502.48701    
     31000  -8411.9601     -8411.9601     -8486.8324     -8486.8324      289.76372      289.76372      23499.458      23499.458      392.87673      392.87673    
Loop time of 231.186 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.218 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.62     | 230.62     | 230.62     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1024     | 0.1024     | 0.1024     |   0.0 |  0.04
Output  | 0.00020964 | 0.00020964 | 0.00020964 |   0.0 |  0.00
Modify  | 0.39917    | 0.39917    | 0.39917    |   0.0 |  0.17
Other   |            | 0.06231    |            |       |  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:       244554 ave      244554 max      244554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244554
Ave neighs/atom = 122.277
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.25022797536, Press = -2.51064310746103
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8411.9601     -8411.9601     -8486.8324     -8486.8324      289.76372      289.76372      23499.458      23499.458      392.87673      392.87673    
     32000  -8410.5138     -8410.5138     -8486.7838     -8486.7838      295.17302      295.17302      23472.605      23472.605      2361.7819      2361.7819    
Loop time of 229.04 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.622 hours/ns, 4.366 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.49     | 228.49     | 228.49     |   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.00016637 | 0.00016637 | 0.00016637 |   0.0 |  0.00
Modify  | 0.39061    | 0.39061    | 0.39061    |   0.0 |  0.17
Other   |            | 0.06182    |            |       |  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:       244846 ave      244846 max      244846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244846
Ave neighs/atom = 122.423
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.288137712613, Press = -2.75299699345285
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8410.5138     -8410.5138     -8486.7838     -8486.7838      295.17302      295.17302      23472.605      23472.605      2361.7819      2361.7819    
     33000  -8408.1257     -8408.1257     -8485.4261     -8485.4261      299.16034      299.16034      23458.048      23458.048      4131.1944      4131.1944    
Loop time of 229.642 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.790 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.1      | 229.1      | 229.1      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10076    | 0.10076    | 0.10076    |   0.0 |  0.04
Output  | 0.00016556 | 0.00016556 | 0.00016556 |   0.0 |  0.00
Modify  | 0.3844     | 0.3844     | 0.3844     |   0.0 |  0.17
Other   |            | 0.06167    |            |       |  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:       245452 ave      245452 max      245452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245452
Ave neighs/atom = 122.726
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.334167731825, Press = 1.15962192249868
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8408.1257     -8408.1257     -8485.4261     -8485.4261      299.16034      299.16034      23458.048      23458.048      4131.1944      4131.1944    
     34000  -8412.5101     -8412.5101     -8486.9898     -8486.9898      288.24423      288.24423      23529.311      23529.311     -1799.8638     -1799.8638    
Loop time of 229.282 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.690 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.10132    | 0.10132    | 0.10132    |   0.0 |  0.04
Output  | 0.00016502 | 0.00016502 | 0.00016502 |   0.0 |  0.00
Modify  | 0.38514    | 0.38514    | 0.38514    |   0.0 |  0.17
Other   |            | 0.06101    |            |       |  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:       245516 ave      245516 max      245516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245516
Ave neighs/atom = 122.758
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.388014308704, Press = 1.05058941965455
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.5101     -8412.5101     -8486.9898     -8486.9898      288.24423      288.24423      23529.311      23529.311     -1799.8638     -1799.8638    
     35000  -8412.4758     -8412.4758     -8487.5797     -8487.5797      290.65989      290.65989      23533.193      23533.193     -2346.3393     -2346.3393    
Loop time of 230.601 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 64.056 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.04     | 230.04     | 230.04     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10224    | 0.10224    | 0.10224    |   0.0 |  0.04
Output  | 0.00020734 | 0.00020734 | 0.00020734 |   0.0 |  0.00
Modify  | 0.39241    | 0.39241    | 0.39241    |   0.0 |  0.17
Other   |            | 0.06187    |            |       |  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:       244250 ave      244250 max      244250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244250
Ave neighs/atom = 122.125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.381784890561, Press = -2.00586390582301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.4758     -8412.4758     -8487.5797     -8487.5797      290.65989      290.65989      23533.193      23533.193     -2346.3393     -2346.3393    
     36000  -8412.5317     -8412.5317     -8486.4433     -8486.4433      286.04584      286.04584      23517.771      23517.771     -1004.1832     -1004.1832    
Loop time of 228.553 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.487 hours/ns, 4.375 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        | 228        | 228        |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10093    | 0.10093    | 0.10093    |   0.0 |  0.04
Output  | 0.00016601 | 0.00016601 | 0.00016601 |   0.0 |  0.00
Modify  | 0.39004    | 0.39004    | 0.39004    |   0.0 |  0.17
Other   |            | 0.06196    |            |       |  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:       244298 ave      244298 max      244298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244298
Ave neighs/atom = 122.149
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.292920500015, Press = -2.30413553394069
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.5317     -8412.5317     -8486.4433     -8486.4433      286.04584      286.04584      23517.771      23517.771     -1004.1832     -1004.1832    
     37000  -8412.6022     -8412.6022     -8487.3466     -8487.3466      289.26881      289.26881      23484.146      23484.146      1418.1219      1418.1219    
Loop time of 228.166 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.379 hours/ns, 4.383 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.62     | 227.62     | 227.62     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10117    | 0.10117    | 0.10117    |   0.0 |  0.04
Output  | 0.00016555 | 0.00016555 | 0.00016555 |   0.0 |  0.00
Modify  | 0.38667    | 0.38667    | 0.38667    |   0.0 |  0.17
Other   |            | 0.06164    |            |       |  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:       244540 ave      244540 max      244540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244540
Ave neighs/atom = 122.27
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.307178927661, Press = -2.37769012881708
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.6022     -8412.6022     -8487.3466     -8487.3466      289.26881      289.26881      23484.146      23484.146      1418.1219      1418.1219    
     38000  -8411.7829     -8411.7829     -8487.7831     -8487.7831      294.12868      294.12868      23461.31       23461.31       3248.6937      3248.6937    
Loop time of 231.118 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.200 hours/ns, 4.327 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.56     | 230.56     | 230.56     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10246    | 0.10246    | 0.10246    |   0.0 |  0.04
Output  | 0.00020758 | 0.00020758 | 0.00020758 |   0.0 |  0.00
Modify  | 0.39256    | 0.39256    | 0.39256    |   0.0 |  0.17
Other   |            | 0.06162    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4163 ave        4163 max        4163 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245168 ave      245168 max      245168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245168
Ave neighs/atom = 122.584
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.210630099228, Press = -0.277561558142885
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8411.7829     -8411.7829     -8487.7831     -8487.7831      294.12868      294.12868      23461.31       23461.31       3248.6937      3248.6937    
     39000  -8412.0099     -8412.0099     -8486.3794     -8486.3794      287.81781      287.81781      23493.869      23493.869      1015.4583      1015.4583    
Loop time of 234.056 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.369 ns/day, 65.016 hours/ns, 4.272 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.48     | 233.48     | 233.48     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10362    | 0.10362    | 0.10362    |   0.0 |  0.04
Output  | 0.00016458 | 0.00016458 | 0.00016458 |   0.0 |  0.00
Modify  | 0.4056     | 0.4056     | 0.4056     |   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:           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:       245530 ave      245530 max      245530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245530
Ave neighs/atom = 122.765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.200880502631, Press = 1.44293744140454
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.0099     -8412.0099     -8486.3794     -8486.3794      287.81781      287.81781      23493.869      23493.869      1015.4583      1015.4583    
     40000  -8410.3653     -8410.3653     -8485.4832     -8485.4832      290.71402      290.71402      23538.351      23538.351     -2028.3565     -2028.3565    
Loop time of 235.109 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.367 ns/day, 65.308 hours/ns, 4.253 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.54     | 234.54     | 234.54     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10303    | 0.10303    | 0.10303    |   0.0 |  0.04
Output  | 0.00016654 | 0.00016654 | 0.00016654 |   0.0 |  0.00
Modify  | 0.4018     | 0.4018     | 0.4018     |   0.0 |  0.17
Other   |            | 0.06312    |            |       |  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:       245014 ave      245014 max      245014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245014
Ave neighs/atom = 122.507
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.139508930823, Press = 0.210820211969045
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8410.3653     -8410.3653     -8485.4832     -8485.4832      290.71402      290.71402      23538.351      23538.351     -2028.3565     -2028.3565    
     41000  -8412.3412     -8412.3412     -8487.9231     -8487.9231      292.50967      292.50967      23529.324      23529.324     -2111.8094     -2111.8094    
Loop time of 233.004 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.723 hours/ns, 4.292 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.44     | 232.44     | 232.44     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10317    | 0.10317    | 0.10317    |   0.0 |  0.04
Output  | 0.00016693 | 0.00016693 | 0.00016693 |   0.0 |  0.00
Modify  | 0.39811    | 0.39811    | 0.39811    |   0.0 |  0.17
Other   |            | 0.06233    |            |       |  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:       244192 ave      244192 max      244192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244192
Ave neighs/atom = 122.096
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.110855422213, Press = -2.0609468343527
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.3412     -8412.3412     -8487.9231     -8487.9231      292.50967      292.50967      23529.324      23529.324     -2111.8094     -2111.8094    
     42000  -8408.7091     -8408.7091     -8485.7085     -8485.7085      297.99574      297.99574      23489.447      23489.447      1705.3188      1705.3188    
Loop time of 231.501 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.306 hours/ns, 4.320 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.95     | 230.95     | 230.95     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10132    | 0.10132    | 0.10132    |   0.0 |  0.04
Output  | 0.00016517 | 0.00016517 | 0.00016517 |   0.0 |  0.00
Modify  | 0.39172    | 0.39172    | 0.39172    |   0.0 |  0.17
Other   |            | 0.0616     |            |       |  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:       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 = 293.090139107956, Press = -1.64178680681058
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8408.7091     -8408.7091     -8485.7085     -8485.7085      297.99574      297.99574      23489.447      23489.447      1705.3188      1705.3188    
     43000  -8412.4827     -8412.4827     -8488.8891     -8488.8891      295.70086      295.70086      23482.813      23482.813      1192.565       1192.565     
Loop time of 232.154 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.487 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.59     | 231.59     | 231.59     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10305    | 0.10305    | 0.10305    |   0.0 |  0.04
Output  | 0.00016683 | 0.00016683 | 0.00016683 |   0.0 |  0.00
Modify  | 0.39867    | 0.39867    | 0.39867    |   0.0 |  0.17
Other   |            | 0.0619     |            |       |  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:       245034 ave      245034 max      245034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245034
Ave neighs/atom = 122.517
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.113085758571, Press = -0.503010258655555
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8412.4827     -8412.4827     -8488.8891     -8488.8891      295.70086      295.70086      23482.813      23482.813      1192.565       1192.565     
     44000  -8410.498      -8410.498      -8486.9458     -8486.9458      295.86072      295.86072      23498.023      23498.023      640.27907      640.27907    
Loop time of 230.034 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.898 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.48     | 229.48     | 229.48     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10081    | 0.10081    | 0.10081    |   0.0 |  0.04
Output  | 0.00016295 | 0.00016295 | 0.00016295 |   0.0 |  0.00
Modify  | 0.38939    | 0.38939    | 0.38939    |   0.0 |  0.17
Other   |            | 0.06136    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4128 ave        4128 max        4128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245232 ave      245232 max      245232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245232
Ave neighs/atom = 122.616
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.102069942899, Press = 0.565569568888636
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8410.498      -8410.498      -8486.9458     -8486.9458      295.86072      295.86072      23498.023      23498.023      640.27907      640.27907    
     45000  -8411.2635     -8411.2635     -8486.0109     -8486.0109      289.28016      289.28016      23545.548      23545.548     -2882.1759     -2882.1759    
Loop time of 230.713 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.087 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.16     | 230.16     | 230.16     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10169    | 0.10169    | 0.10169    |   0.0 |  0.04
Output  | 0.0001665  | 0.0001665  | 0.0001665  |   0.0 |  0.00
Modify  | 0.3908     | 0.3908     | 0.3908     |   0.0 |  0.17
Other   |            | 0.06167    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4154 ave        4154 max        4154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244852 ave      244852 max      244852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0