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

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

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

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

kim_interactions Mo

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

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


mass          1 ${mass_converted}
mass          1 95.94

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_269937397263_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13548.672     -13548.672     -13634.755     -13634.755      333.15         333.15         31777.091      31777.091      2893.4614      2893.4614    
      1000  -13461.504     -13461.504     -13546.785     -13546.785      330.04499      330.04499      31915.297      31915.297      3052.2309      3052.2309    
Loop time of 579.104 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 578.58     | 578.58     | 578.58     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097656   | 0.097656   | 0.097656   |   0.0 |  0.02
Output  | 0.00028485 | 0.00028485 | 0.00028485 |   0.0 |  0.00
Modify  | 0.362      | 0.362      | 0.362      |   0.0 |  0.06
Other   |            | 0.06226    |            |       |  0.01

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

Total # of neighbors = 272000
Ave neighs/atom = 136
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13461.504     -13461.504     -13546.785     -13546.785      330.04499      330.04499      31915.297      31915.297      3052.2309      3052.2309    
      2000  -13459.652     -13459.652     -13542.417     -13542.417      320.30969      320.30969      31929.937      31929.937      1918.908       1918.908     
Loop time of 600.146 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.58     | 599.58     | 599.58     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11031    | 0.11031    | 0.11031    |   0.0 |  0.02
Output  | 0.00029833 | 0.00029833 | 0.00029833 |   0.0 |  0.00
Modify  | 0.39194    | 0.39194    | 0.39194    |   0.0 |  0.07
Other   |            | 0.06611    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4472 ave        4472 max        4472 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269778 ave      269778 max      269778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269778
Ave neighs/atom = 134.889
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13459.652     -13459.652     -13542.417     -13542.417      320.30969      320.30969      31929.937      31929.937      1918.908       1918.908     
      3000  -13463.403     -13463.403     -13551.63      -13551.63       341.4502       341.4502       31946.389      31946.389     -160.49546     -160.49546    
Loop time of 603.248 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 602.68     | 602.68     | 602.68     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11007    | 0.11007    | 0.11007    |   0.0 |  0.02
Output  | 0.00020357 | 0.00020357 | 0.00020357 |   0.0 |  0.00
Modify  | 0.39116    | 0.39116    | 0.39116    |   0.0 |  0.06
Other   |            | 0.0664     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4465 ave        4465 max        4465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269186 ave      269186 max      269186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269186
Ave neighs/atom = 134.593
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13463.403     -13463.403     -13551.63      -13551.63       341.4502       341.4502       31946.389      31946.389     -160.49546     -160.49546    
      4000  -13458.455     -13458.455     -13550.72      -13550.72       357.07538      357.07538      31955.593      31955.593     -425.74918     -425.74918    
Loop time of 601.909 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 601.34     | 601.34     | 601.34     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11072    | 0.11072    | 0.11072    |   0.0 |  0.02
Output  | 0.00024262 | 0.00024262 | 0.00024262 |   0.0 |  0.00
Modify  | 0.3902     | 0.3902     | 0.3902     |   0.0 |  0.06
Other   |            | 0.06656    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4455 ave        4455 max        4455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269814 ave      269814 max      269814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269814
Ave neighs/atom = 134.907
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13458.455     -13458.455     -13550.72      -13550.72       357.07538      357.07538      31955.593      31955.593     -425.74918     -425.74918    
      5000  -13462.755     -13462.755     -13545.512     -13545.512      320.28058      320.28058      31925.286      31925.286      2642.7982      2642.7982    
Loop time of 598.552 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.99     | 597.99     | 597.99     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1084     | 0.1084     | 0.1084     |   0.0 |  0.02
Output  | 0.00016714 | 0.00016714 | 0.00016714 |   0.0 |  0.00
Modify  | 0.39094    | 0.39094    | 0.39094    |   0.0 |  0.07
Other   |            | 0.06596    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4412 ave        4412 max        4412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269724 ave      269724 max      269724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269724
Ave neighs/atom = 134.862
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 326.955702590632, Press = -580.213475904371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13462.755     -13462.755     -13545.512     -13545.512      320.28058      320.28058      31925.286      31925.286      2642.7982      2642.7982    
      6000  -13460.443     -13460.443     -13547.334     -13547.334      336.27804      336.27804      31929.348      31929.348      1748.0643      1748.0643    
Loop time of 595.245 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 594.66     | 594.66     | 594.66     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11047    | 0.11047    | 0.11047    |   0.0 |  0.02
Output  | 0.00016765 | 0.00016765 | 0.00016765 |   0.0 |  0.00
Modify  | 0.40488    | 0.40488    | 0.40488    |   0.0 |  0.07
Other   |            | 0.0651     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4483 ave        4483 max        4483 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269708 ave      269708 max      269708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269708
Ave neighs/atom = 134.854
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.944462458185, Press = -83.2053504246885
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13460.443     -13460.443     -13547.334     -13547.334      336.27804      336.27804      31929.348      31929.348      1748.0643      1748.0643    
      7000  -13463.815     -13463.815     -13554.216     -13554.216      349.85881      349.85881      31942.536      31942.536     -95.530743     -95.530743    
Loop time of 594.302 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 593.73     | 593.73     | 593.73     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10853    | 0.10853    | 0.10853    |   0.0 |  0.02
Output  | 0.00021059 | 0.00021059 | 0.00021059 |   0.0 |  0.00
Modify  | 0.39868    | 0.39868    | 0.39868    |   0.0 |  0.07
Other   |            | 0.0645     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4486 ave        4486 max        4486 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269854 ave      269854 max      269854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269854
Ave neighs/atom = 134.927
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.656696574859, Press = -15.7798835059213
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13463.815     -13463.815     -13554.216     -13554.216      349.85881      349.85881      31942.536      31942.536     -95.530743     -95.530743    
      8000  -13461.112     -13461.112     -13544.623     -13544.623      323.19573      323.19573      31951.978      31951.978      140.90475      140.90475    
Loop time of 591.34 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 590.76     | 590.76     | 590.76     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.109      | 0.109      | 0.109      |   0.0 |  0.02
Output  | 0.00020096 | 0.00020096 | 0.00020096 |   0.0 |  0.00
Modify  | 0.40437    | 0.40437    | 0.40437    |   0.0 |  0.07
Other   |            | 0.0656     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4468 ave        4468 max        4468 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       270070 ave      270070 max      270070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270070
Ave neighs/atom = 135.035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.577892210566, Press = -9.55042128005011
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13461.112     -13461.112     -13544.623     -13544.623      323.19573      323.19573      31951.978      31951.978      140.90475      140.90475    
      9000  -13465.424     -13465.424     -13549.192     -13549.192      324.19047      324.19047      31964.088      31964.088     -1181.0207     -1181.0207    
Loop time of 590.338 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 589.77     | 589.77     | 589.77     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10886    | 0.10886    | 0.10886    |   0.0 |  0.02
Output  | 0.00017099 | 0.00017099 | 0.00017099 |   0.0 |  0.00
Modify  | 0.39737    | 0.39737    | 0.39737    |   0.0 |  0.07
Other   |            | 0.06441    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4477 ave        4477 max        4477 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269468 ave      269468 max      269468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269468
Ave neighs/atom = 134.734
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.515480246208, Press = -10.7823425137173
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13465.424     -13465.424     -13549.192     -13549.192      324.19047      324.19047      31964.088      31964.088     -1181.0207     -1181.0207    
     10000  -13458.808     -13458.808     -13543.405     -13543.405      327.40017      327.40017      31968.744      31968.744     -914.26116     -914.26116    
Loop time of 587.365 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 586.8      | 586.8      | 586.8      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10768    | 0.10768    | 0.10768    |   0.0 |  0.02
Output  | 0.0001688  | 0.0001688  | 0.0001688  |   0.0 |  0.00
Modify  | 0.39607    | 0.39607    | 0.39607    |   0.0 |  0.07
Other   |            | 0.06508    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4462 ave        4462 max        4462 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269700 ave      269700 max      269700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269700
Ave neighs/atom = 134.85
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.891509673887, Press = -0.879978995269873
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13458.808     -13458.808     -13543.405     -13543.405      327.40017      327.40017      31968.744      31968.744     -914.26116     -914.26116    
     11000  -13462.764     -13462.764     -13541.917     -13541.917      306.32999      306.32999      31978.396      31978.396     -1766.8817     -1766.8817    
Loop time of 601.686 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 601.09     | 601.09     | 601.09     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11139    | 0.11139    | 0.11139    |   0.0 |  0.02
Output  | 0.00021138 | 0.00021138 | 0.00021138 |   0.0 |  0.00
Modify  | 0.41658    | 0.41658    | 0.41658    |   0.0 |  0.07
Other   |            | 0.06629    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4478 ave        4478 max        4478 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269236 ave      269236 max      269236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269236
Ave neighs/atom = 134.618
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.206069537958, Press = -5.84150431873575
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13462.764     -13462.764     -13541.917     -13541.917      306.32999      306.32999      31978.396      31978.396     -1766.8817     -1766.8817    
     12000  -13460.001     -13460.001     -13539.404     -13539.404      307.29812      307.29812      31993.7        31993.7       -2512.4108     -2512.4108    
Loop time of 600.38 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.8      | 599.8      | 599.8      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10808    | 0.10808    | 0.10808    |   0.0 |  0.02
Output  | 0.00019931 | 0.00019931 | 0.00019931 |   0.0 |  0.00
Modify  | 0.4078     | 0.4078     | 0.4078     |   0.0 |  0.07
Other   |            | 0.06527    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4411 ave        4411 max        4411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269038 ave      269038 max      269038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269038
Ave neighs/atom = 134.519
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.447193362996, Press = -10.1268888510905
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13460.001     -13460.001     -13539.404     -13539.404      307.29812      307.29812      31993.7        31993.7       -2512.4108     -2512.4108    
     13000  -13463.388     -13463.388     -13549.9       -13549.9        334.80982      334.80982      31965.051      31965.051     -1053.4968     -1053.4968    
Loop time of 600.049 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.46     | 599.46     | 599.46     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11133    | 0.11133    | 0.11133    |   0.0 |  0.02
Output  | 0.00020681 | 0.00020681 | 0.00020681 |   0.0 |  0.00
Modify  | 0.41063    | 0.41063    | 0.41063    |   0.0 |  0.07
Other   |            | 0.06609    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4513 ave        4513 max        4513 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       268692 ave      268692 max      268692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 268692
Ave neighs/atom = 134.346
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.574287219782, Press = -2.84334099925797
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13463.388     -13463.388     -13549.9       -13549.9        334.80982      334.80982      31965.051      31965.051     -1053.4968     -1053.4968    
     14000  -13457.817     -13457.817     -13545.349     -13545.349      338.75843      338.75843      31986.919      31986.919     -2593.5769     -2593.5769    
Loop time of 601.958 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 601.36     | 601.36     | 601.36     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11068    | 0.11068    | 0.11068    |   0.0 |  0.02
Output  | 0.00020499 | 0.00020499 | 0.00020499 |   0.0 |  0.00
Modify  | 0.41786    | 0.41786    | 0.41786    |   0.0 |  0.07
Other   |            | 0.06618    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4452 ave        4452 max        4452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269510 ave      269510 max      269510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269510
Ave neighs/atom = 134.755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.67065654028, Press = -0.899118285465617
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13457.817     -13457.817     -13545.349     -13545.349      338.75843      338.75843      31986.919      31986.919     -2593.5769     -2593.5769    
     15000  -13461.569     -13461.569     -13545.488     -13545.488      324.77273      324.77273      31986.471      31986.471     -2413.4894     -2413.4894    
Loop time of 603.384 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 602.79     | 602.79     | 602.79     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11051    | 0.11051    | 0.11051    |   0.0 |  0.02
Output  | 0.0001641  | 0.0001641  | 0.0001641  |   0.0 |  0.00
Modify  | 0.41734    | 0.41734    | 0.41734    |   0.0 |  0.07
Other   |            | 0.06613    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4458 ave        4458 max        4458 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269326 ave      269326 max      269326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269326
Ave neighs/atom = 134.663
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.986402046557, Press = 1.21507337777492
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13461.569     -13461.569     -13545.488     -13545.488      324.77273      324.77273      31986.471      31986.471     -2413.4894     -2413.4894    
     16000  -13464.086     -13464.086     -13547.644     -13547.644      323.37976      323.37976      31971.387      31971.387     -1826.0798     -1826.0798    
Loop time of 596.931 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.35     | 596.35     | 596.35     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11009    | 0.11009    | 0.11009    |   0.0 |  0.02
Output  | 0.00016758 | 0.00016758 | 0.00016758 |   0.0 |  0.00
Modify  | 0.40603    | 0.40603    | 0.40603    |   0.0 |  0.07
Other   |            | 0.06537    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4483 ave        4483 max        4483 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269200 ave      269200 max      269200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269200
Ave neighs/atom = 134.6
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.962231273596, Press = -1.22521766720977
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13464.086     -13464.086     -13547.644     -13547.644      323.37976      323.37976      31971.387      31971.387     -1826.0798     -1826.0798    
     17000  -13461.607     -13461.607     -13550.561     -13550.561      344.26409      344.26409      31958.491      31958.491     -731.99268     -731.99268    
Loop time of 590.375 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 589.8      | 589.8      | 589.8      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10758    | 0.10758    | 0.10758    |   0.0 |  0.02
Output  | 0.00016826 | 0.00016826 | 0.00016826 |   0.0 |  0.00
Modify  | 0.39949    | 0.39949    | 0.39949    |   0.0 |  0.07
Other   |            | 0.06505    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4463 ave        4463 max        4463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269334 ave      269334 max      269334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269334
Ave neighs/atom = 134.667
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.908822655116, Press = 0.327565085907708
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13461.607     -13461.607     -13550.561     -13550.561      344.26409      344.26409      31958.491      31958.491     -731.99268     -731.99268    
     18000  -13460.958     -13460.958     -13544.47      -13544.47       323.20218      323.20218      31966.274      31966.274     -986.84694     -986.84694    
Loop time of 600.311 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.72     | 599.72     | 599.72     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11134    | 0.11134    | 0.11134    |   0.0 |  0.02
Output  | 0.00021279 | 0.00021279 | 0.00021279 |   0.0 |  0.00
Modify  | 0.41048    | 0.41048    | 0.41048    |   0.0 |  0.07
Other   |            | 0.06606    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4520 ave        4520 max        4520 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269692 ave      269692 max      269692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269692
Ave neighs/atom = 134.846
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.845422797112, Press = 1.18002709780572
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13460.958     -13460.958     -13544.47      -13544.47       323.20218      323.20218      31966.274      31966.274     -986.84694     -986.84694    
     19000  -13465.534     -13465.534     -13549.751     -13549.751      325.93019      325.93019      31982.741      31982.741     -2677.5127     -2677.5127    
Loop time of 599.376 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 598.79     | 598.79     | 598.79     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11041    | 0.11041    | 0.11041    |   0.0 |  0.02
Output  | 0.00020312 | 0.00020312 | 0.00020312 |   0.0 |  0.00
Modify  | 0.40927    | 0.40927    | 0.40927    |   0.0 |  0.07
Other   |            | 0.06586    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4481 ave        4481 max        4481 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269252 ave      269252 max      269252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269252
Ave neighs/atom = 134.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 = 332.715185222292, Press = 2.82287390899564
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13465.534     -13465.534     -13549.751     -13549.751      325.93019      325.93019      31982.741      31982.741     -2677.5127     -2677.5127    
     20000  -13459.735     -13459.735     -13544.93      -13544.93       329.7148       329.7148       31987.996      31987.996     -2599.7365     -2599.7365    
Loop time of 595.841 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.26     | 595.26     | 595.26     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10947    | 0.10947    | 0.10947    |   0.0 |  0.02
Output  | 0.00023128 | 0.00023128 | 0.00023128 |   0.0 |  0.00
Modify  | 0.40351    | 0.40351    | 0.40351    |   0.0 |  0.07
Other   |            | 0.06589    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4484 ave        4484 max        4484 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269286 ave      269286 max      269286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269286
Ave neighs/atom = 134.643
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.693495199116, Press = 3.18534821680548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13459.735     -13459.735     -13544.93      -13544.93       329.7148       329.7148       31987.996      31987.996     -2599.7365     -2599.7365    
     21000  -13463.034     -13463.034     -13545.331     -13545.331      318.50025      318.50025      31981.762      31981.762     -2271.1881     -2271.1881    
Loop time of 599.024 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 598.44     | 598.44     | 598.44     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10918    | 0.10918    | 0.10918    |   0.0 |  0.02
Output  | 0.00016636 | 0.00016636 | 0.00016636 |   0.0 |  0.00
Modify  | 0.40847    | 0.40847    | 0.40847    |   0.0 |  0.07
Other   |            | 0.06537    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4401 ave        4401 max        4401 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269280 ave      269280 max      269280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269280
Ave neighs/atom = 134.64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.914121833813, Press = 2.39396607130369
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13463.034     -13463.034     -13545.331     -13545.331      318.50025      318.50025      31981.762      31981.762     -2271.1881     -2271.1881    
     22000  -13460.666     -13460.666     -13545.343     -13545.343      327.7089       327.7089       31965.157      31965.157     -866.59732     -866.59732    
Loop time of 597.244 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.66     | 596.66     | 596.66     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11042    | 0.11042    | 0.11042    |   0.0 |  0.02
Output  | 0.00020758 | 0.00020758 | 0.00020758 |   0.0 |  0.00
Modify  | 0.40336    | 0.40336    | 0.40336    |   0.0 |  0.07
Other   |            | 0.06539    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4497 ave        4497 max        4497 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269118 ave      269118 max      269118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269118
Ave neighs/atom = 134.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 = 332.954367656287, Press = 1.57278193211254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13460.666     -13460.666     -13545.343     -13545.343      327.7089       327.7089       31965.157      31965.157     -866.59732     -866.59732    
     23000  -13459.677     -13459.677     -13549.387     -13549.387      347.18777      347.18777      31951.967      31951.967      32.74349       32.74349     
Loop time of 598.17 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.59     | 597.59     | 597.59     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10969    | 0.10969    | 0.10969    |   0.0 |  0.02
Output  | 0.0001658  | 0.0001658  | 0.0001658  |   0.0 |  0.00
Modify  | 0.40807    | 0.40807    | 0.40807    |   0.0 |  0.07
Other   |            | 0.06565    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4459 ave        4459 max        4459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269290 ave      269290 max      269290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269290
Ave neighs/atom = 134.645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.066763984193, Press = 0.950031845814194
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13459.677     -13459.677     -13549.387     -13549.387      347.18777      347.18777      31951.967      31951.967      32.74349       32.74349     
     24000  -13465.601     -13465.601     -13550.189     -13550.189      327.3654       327.3654       31934.485      31934.485      805.31563      805.31563    
Loop time of 597.84 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.26     | 597.26     | 597.26     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1099     | 0.1099     | 0.1099     |   0.0 |  0.02
Output  | 0.0002607  | 0.0002607  | 0.0002607  |   0.0 |  0.00
Modify  | 0.40798    | 0.40798    | 0.40798    |   0.0 |  0.07
Other   |            | 0.06557    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4463 ave        4463 max        4463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269812 ave      269812 max      269812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269812
Ave neighs/atom = 134.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.081383137731, Press = 2.40800271752147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13465.601     -13465.601     -13550.189     -13550.189      327.3654       327.3654       31934.485      31934.485      805.31563      805.31563    
     25000  -13460.883     -13460.883     -13544.692     -13544.692      324.35167      324.35167      31935.617      31935.617      1556.388       1556.388     
Loop time of 594.976 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 594.4      | 594.4      | 594.4      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11018    | 0.11018    | 0.11018    |   0.0 |  0.02
Output  | 0.00016539 | 0.00016539 | 0.00016539 |   0.0 |  0.00
Modify  | 0.40435    | 0.40435    | 0.40435    |   0.0 |  0.07
Other   |            | 0.06505    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4518 ave        4518 max        4518 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269696 ave      269696 max      269696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269696
Ave neighs/atom = 134.848
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.044449770332, Press = 2.63665436736129
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13460.883     -13460.883     -13544.692     -13544.692      324.35167      324.35167      31935.617      31935.617      1556.388       1556.388     
     26000  -13461.482     -13461.482     -13546.092     -13546.092      327.44646      327.44646      31929.156      31929.156      1991.3374      1991.3374    
Loop time of 599.077 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 598.49     | 598.49     | 598.49     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10914    | 0.10914    | 0.10914    |   0.0 |  0.02
Output  | 0.00022524 | 0.00022524 | 0.00022524 |   0.0 |  0.00
Modify  | 0.40824    | 0.40824    | 0.40824    |   0.0 |  0.07
Other   |            | 0.06564    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4462 ave        4462 max        4462 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269426 ave      269426 max      269426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269426
Ave neighs/atom = 134.713
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.071425525285, Press = 5.52961110879823
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13461.482     -13461.482     -13546.092     -13546.092      327.44646      327.44646      31929.156      31929.156      1991.3374      1991.3374    
     27000  -13461.794     -13461.794     -13545.346     -13545.346      323.35471      323.35471      31933.831      31933.831      1617.2309      1617.2309    
Loop time of 600.08 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.49     | 599.49     | 599.49     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11077    | 0.11077    | 0.11077    |   0.0 |  0.02
Output  | 0.0002915  | 0.0002915  | 0.0002915  |   0.0 |  0.00
Modify  | 0.41247    | 0.41247    | 0.41247    |   0.0 |  0.07
Other   |            | 0.06648    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4498 ave        4498 max        4498 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269540 ave      269540 max      269540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269540
Ave neighs/atom = 134.77
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.040467920484, Press = 3.47757503348962
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13461.794     -13461.794     -13545.346     -13545.346      323.35471      323.35471      31933.831      31933.831      1617.2309      1617.2309    
     28000  -13459.629     -13459.629     -13548.328     -13548.328      343.27455      343.27455      31944.52       31944.52       679.74914      679.74914    
Loop time of 600.684 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 600.09     | 600.09     | 600.09     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11043    | 0.11043    | 0.11043    |   0.0 |  0.02
Output  | 0.00020546 | 0.00020546 | 0.00020546 |   0.0 |  0.00
Modify  | 0.41215    | 0.41215    | 0.41215    |   0.0 |  0.07
Other   |            | 0.06643    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4490 ave        4490 max        4490 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269502 ave      269502 max      269502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269502
Ave neighs/atom = 134.751
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.17158961068, Press = 1.86844390352094
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13459.629     -13459.629     -13548.328     -13548.328      343.27455      343.27455      31944.52       31944.52       679.74914      679.74914    
     29000  -13461.703     -13461.703     -13549.36      -13549.36       339.24146      339.24146      31943.625      31943.625      294.6645       294.6645     
Loop time of 599.161 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 598.57     | 598.57     | 598.57     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11081    | 0.11081    | 0.11081    |   0.0 |  0.02
Output  | 0.00016817 | 0.00016817 | 0.00016817 |   0.0 |  0.00
Modify  | 0.40976    | 0.40976    | 0.40976    |   0.0 |  0.07
Other   |            | 0.06589    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4519 ave        4519 max        4519 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269598 ave      269598 max      269598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269598
Ave neighs/atom = 134.799
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.166311018809, Press = 2.37211700106342
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13461.703     -13461.703     -13549.36      -13549.36       339.24146      339.24146      31943.625      31943.625      294.6645       294.6645     
     30000  -13464.842     -13464.842     -13553.693     -13553.693      343.8601       343.8601       31931.178      31931.178      1035.2535      1035.2535    
Loop time of 601.966 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 601.38     | 601.38     | 601.38     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11077    | 0.11077    | 0.11077    |   0.0 |  0.02
Output  | 0.00016588 | 0.00016588 | 0.00016588 |   0.0 |  0.00
Modify  | 0.41297    | 0.41297    | 0.41297    |   0.0 |  0.07
Other   |            | 0.06552    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4468 ave        4468 max        4468 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269672 ave      269672 max      269672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269672
Ave neighs/atom = 134.836
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.128934322879, Press = 2.72820354634221
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13464.842     -13464.842     -13553.693     -13553.693      343.8601       343.8601       31931.178      31931.178      1035.2535      1035.2535    
     31000  -13460.026     -13460.026     -13546.439     -13546.439      334.42819      334.42819      31930.143      31930.143      1729.8837      1729.8837    
Loop time of 599.986 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.4      | 599.4      | 599.4      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10964    | 0.10964    | 0.10964    |   0.0 |  0.02
Output  | 0.00017464 | 0.00017464 | 0.00017464 |   0.0 |  0.00
Modify  | 0.41191    | 0.41191    | 0.41191    |   0.0 |  0.07
Other   |            | 0.06584    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4452 ave        4452 max        4452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       270004 ave      270004 max      270004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270004
Ave neighs/atom = 135.002
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.073831449166, Press = 2.92035052452441
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13460.026     -13460.026     -13546.439     -13546.439      334.42819      334.42819      31930.143      31930.143      1729.8837      1729.8837    
     32000  -13466.416     -13466.416     -13550.377     -13550.377      324.93817      324.93817      31909.622      31909.622      2769.8835      2769.8835    
Loop time of 599.353 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 598.77     | 598.77     | 598.77     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11023    | 0.11023    | 0.11023    |   0.0 |  0.02
Output  | 0.000208   | 0.000208   | 0.000208   |   0.0 |  0.00
Modify  | 0.41062    | 0.41062    | 0.41062    |   0.0 |  0.07
Other   |            | 0.06559    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4452 ave        4452 max        4452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269694 ave      269694 max      269694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269694
Ave neighs/atom = 134.847
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.99444947465, Press = 3.0887235129949
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13466.416     -13466.416     -13550.377     -13550.377      324.93817      324.93817      31909.622      31909.622      2769.8835      2769.8835    
     33000  -13459.165     -13459.165     -13544.915     -13544.915      331.86387      331.86387      31921.449      31921.449      2626.4475      2626.4475    
Loop time of 599.732 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.14     | 599.14     | 599.14     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10991    | 0.10991    | 0.10991    |   0.0 |  0.02
Output  | 0.00021044 | 0.00021044 | 0.00021044 |   0.0 |  0.00
Modify  | 0.41169    | 0.41169    | 0.41169    |   0.0 |  0.07
Other   |            | 0.06617    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4476 ave        4476 max        4476 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269902 ave      269902 max      269902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269902
Ave neighs/atom = 134.951
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.925863853198, Press = 2.67111942847093
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13459.165     -13459.165     -13544.915     -13544.915      331.86387      331.86387      31921.449      31921.449      2626.4475      2626.4475    
     34000  -13462.1       -13462.1       -13547.107     -13547.107      328.98502      328.98502      31949.249      31949.249      150.20498      150.20498    
Loop time of 599.523 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 598.94     | 598.94     | 598.94     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10987    | 0.10987    | 0.10987    |   0.0 |  0.02
Output  | 0.00016654 | 0.00016654 | 0.00016654 |   0.0 |  0.00
Modify  | 0.40862    | 0.40862    | 0.40862    |   0.0 |  0.07
Other   |            | 0.06585    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4468 ave        4468 max        4468 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269700 ave      269700 max      269700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269700
Ave neighs/atom = 134.85
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.983249803198, Press = 1.57820260492109
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13462.1       -13462.1       -13547.107     -13547.107      328.98502      328.98502      31949.249      31949.249      150.20498      150.20498    
     35000  -13460.921     -13460.921     -13547.262     -13547.262      334.14961      334.14961      31951.749      31951.749      157.88397      157.88397    
Loop time of 596.549 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.97     | 595.97     | 595.97     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1079     | 0.1079     | 0.1079     |   0.0 |  0.02
Output  | 0.00016468 | 0.00016468 | 0.00016468 |   0.0 |  0.00
Modify  | 0.40205    | 0.40205    | 0.40205    |   0.0 |  0.07
Other   |            | 0.0651     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4414 ave        4414 max        4414 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269546 ave      269546 max      269546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269546
Ave neighs/atom = 134.773
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.099773935223, Press = 0.791642526371558
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13460.921     -13460.921     -13547.262     -13547.262      334.14961      334.14961      31951.749      31951.749      157.88397      157.88397    
     36000  -13460.554     -13460.554     -13548.08      -13548.08       338.73678      338.73678      31937.821      31937.821      1223.3458      1223.3458    
Loop time of 608.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.142 ns/day, 169.010 hours/ns, 1.644 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    | 607.83     | 607.83     | 607.83     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11239    | 0.11239    | 0.11239    |   0.0 |  0.02
Output  | 0.00020915 | 0.00020915 | 0.00020915 |   0.0 |  0.00
Modify  | 0.4245     | 0.4245     | 0.4245     |   0.0 |  0.07
Other   |            | 0.06687    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4468 ave        4468 max        4468 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269472 ave      269472 max      269472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269472
Ave neighs/atom = 134.736
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.157341111457, Press = 1.25590595261038
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13460.554     -13460.554     -13548.08      -13548.08       338.73678      338.73678      31937.821      31937.821      1223.3458      1223.3458    
     37000  -13463.298     -13463.298     -13550.078     -13550.078      335.8484       335.8484       31897.765      31897.765      3941.425       3941.425     
Loop time of 601.445 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 600.86     | 600.86     | 600.86     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10926    | 0.10926    | 0.10926    |   0.0 |  0.02
Output  | 0.00016401 | 0.00016401 | 0.00016401 |   0.0 |  0.00
Modify  | 0.41138    | 0.41138    | 0.41138    |   0.0 |  0.07
Other   |            | 0.06546    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4423 ave        4423 max        4423 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269776 ave      269776 max      269776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269776
Ave neighs/atom = 134.888
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.144508396665, Press = 1.53153554185018
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13463.298     -13463.298     -13550.078     -13550.078      335.8484       335.8484       31897.765      31897.765      3941.425       3941.425     
     38000  -13460.764     -13460.764     -13550.259     -13550.259      346.35293      346.35293      31914.111      31914.111      2718.5873      2718.5873    
Loop time of 601.387 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 600.8      | 600.8      | 600.8      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11094    | 0.11094    | 0.11094    |   0.0 |  0.02
Output  | 0.00021332 | 0.00021332 | 0.00021332 |   0.0 |  0.00
Modify  | 0.41213    | 0.41213    | 0.41213    |   0.0 |  0.07
Other   |            | 0.06621    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4490 ave        4490 max        4490 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       270052 ave      270052 max      270052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270052
Ave neighs/atom = 135.026
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.145935734608, Press = 1.32351473405071
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13460.764     -13460.764     -13550.259     -13550.259      346.35293      346.35293      31914.111      31914.111      2718.5873      2718.5873    
     39000  -13458.985     -13458.985     -13545.361     -13545.361      334.28628      334.28628      31917.117      31917.117      3049.185       3049.185     
Loop time of 597.706 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.12     | 597.12     | 597.12     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11027    | 0.11027    | 0.11027    |   0.0 |  0.02
Output  | 0.00020662 | 0.00020662 | 0.00020662 |   0.0 |  0.00
Modify  | 0.40803    | 0.40803    | 0.40803    |   0.0 |  0.07
Other   |            | 0.06637    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4472 ave        4472 max        4472 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269970 ave      269970 max      269970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269970
Ave neighs/atom = 134.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.129558296919, Press = 1.68351855659238
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13458.985     -13458.985     -13545.361     -13545.361      334.28628      334.28628      31917.117      31917.117      3049.185       3049.185     
     40000  -13464.176     -13464.176     -13547.705     -13547.705      323.26407      323.26407      31921.863      31921.863      2323.9858      2323.9858    
Loop time of 596.347 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.77     | 595.77     | 595.77     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10956    | 0.10956    | 0.10956    |   0.0 |  0.02
Output  | 0.00021025 | 0.00021025 | 0.00021025 |   0.0 |  0.00
Modify  | 0.40685    | 0.40685    | 0.40685    |   0.0 |  0.07
Other   |            | 0.0656     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4483 ave        4483 max        4483 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269616 ave      269616 max      269616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269616
Ave neighs/atom = 134.808
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.178170688054, Press = 1.0839718336838
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13464.176     -13464.176     -13547.705     -13547.705      323.26407      323.26407      31921.863      31921.863      2323.9858      2323.9858    
     41000  -13459.47      -13459.47      -13545.86      -13545.86       334.33879      334.33879      31943.859      31943.859      740.00393      740.00393    
Loop time of 598.547 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.96     | 597.96     | 597.96     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11106    | 0.11106    | 0.11106    |   0.0 |  0.02
Output  | 0.0001648  | 0.0001648  | 0.0001648  |   0.0 |  0.00
Modify  | 0.40845    | 0.40845    | 0.40845    |   0.0 |  0.07
Other   |            | 0.06617    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4494 ave        4494 max        4494 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269780 ave      269780 max      269780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269780
Ave neighs/atom = 134.89
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.20733004652, Press = 0.340498077988697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13459.47      -13459.47      -13545.86      -13545.86       334.33879      334.33879      31943.859      31943.859      740.00393      740.00393    
     42000  -13459.195     -13459.195     -13546.847     -13546.847      339.21898      339.21898      31955.318      31955.318      149.14322      149.14322    
Loop time of 595.369 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 594.79     | 594.79     | 594.79     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10826    | 0.10826    | 0.10826    |   0.0 |  0.02
Output  | 0.00016655 | 0.00016655 | 0.00016655 |   0.0 |  0.00
Modify  | 0.40508    | 0.40508    | 0.40508    |   0.0 |  0.07
Other   |            | 0.06534    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4408 ave        4408 max        4408 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       269498 ave      269498 max      269498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0