# 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.031088903546333*${_u_distance}
variable latticeconst_converted equal 3.031088903546333*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.03108890354633
Lattice spacing in x,y,z = 3.0310889 3.0310889 3.0310889
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (30.310889 30.310889 30.310889)
  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 (30.310889 30.310889 30.310889)
  create_atoms CPU = 0.004 seconds

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

kim_interactions V

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

kim interactions V
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtV__MO_912978207512_002
pair_coeff * * V
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 50.9415

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 27848.129123109 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_912978207512_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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -10513.917     -10513.917     -10600         -10600          333.15         333.15         27848.129      27848.129      3301.7316      3301.7316    
      1000  -10419.039     -10419.039     -10513.294     -10513.294      364.77647      364.77647      28027.658      28027.658      2348.4054      2348.4054    
Loop time of 175.427 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.730 hours/ns, 5.700 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    | 174.9      | 174.9      | 174.9      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09918    | 0.09918    | 0.09918    |   0.0 |  0.06
Output  | 0.00022556 | 0.00022556 | 0.00022556 |   0.0 |  0.00
Modify  | 0.36905    | 0.36905    | 0.36905    |   0.0 |  0.21
Other   |            | 0.0628     |            |       |  0.04

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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 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 = 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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10419.039     -10419.039     -10513.294     -10513.294      364.77647      364.77647      28027.658      28027.658      2348.4054      2348.4054    
      2000  -10424.62      -10424.62      -10506.748     -10506.748      317.84267      317.84267      28034.466      28034.466      2071.0491      2071.0491    
Loop time of 196.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.559 hours/ns, 5.091 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.82     | 195.82     | 195.82     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10709    | 0.10709    | 0.10709    |   0.0 |  0.05
Output  | 0.0002615  | 0.0002615  | 0.0002615  |   0.0 |  0.00
Modify  | 0.41905    | 0.41905    | 0.41905    |   0.0 |  0.21
Other   |            | 0.06659    |            |       |  0.03

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

Total # of neighbors = 135450
Ave neighs/atom = 67.725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10424.62      -10424.62      -10506.748     -10506.748      317.84267      317.84267      28034.466      28034.466      2071.0491      2071.0491    
      3000  -10422.723     -10422.723     -10508.993     -10508.993      333.87291      333.87291      28057.549      28057.549      510.34591      510.34591    
Loop time of 175.678 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.800 hours/ns, 5.692 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    | 175.16     | 175.16     | 175.16     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097089   | 0.097089   | 0.097089   |   0.0 |  0.06
Output  | 0.00023362 | 0.00023362 | 0.00023362 |   0.0 |  0.00
Modify  | 0.35491    | 0.35491    | 0.35491    |   0.0 |  0.20
Other   |            | 0.06164    |            |       |  0.04

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:       136048 ave      136048 max      136048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 136048
Ave neighs/atom = 68.024
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10422.723     -10422.723     -10508.993     -10508.993      333.87291      333.87291      28057.549      28057.549      510.34591      510.34591    
      4000  -10422.385     -10422.385     -10511.355     -10511.355      344.32414      344.32414      28061.179      28061.179      850.04033      850.04033    
Loop time of 169.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.061 hours/ns, 5.903 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.93     | 168.93     | 168.93     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094206   | 0.094206   | 0.094206   |   0.0 |  0.06
Output  | 0.00024509 | 0.00024509 | 0.00024509 |   0.0 |  0.00
Modify  | 0.33603    | 0.33603    | 0.33603    |   0.0 |  0.20
Other   |            | 0.05951    |            |       |  0.04

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:       135870 ave      135870 max      135870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135870
Ave neighs/atom = 67.935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10422.385     -10422.385     -10511.355     -10511.355      344.32414      344.32414      28061.179      28061.179      850.04033      850.04033    
      5000  -10421.429     -10421.429     -10509.801     -10509.801      342.00981      342.00981      28089.007      28089.007     -1149.2631     -1149.2631    
Loop time of 169.387 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.052 hours/ns, 5.904 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.9      | 168.9      | 168.9      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094034   | 0.094034   | 0.094034   |   0.0 |  0.06
Output  | 0.00016863 | 0.00016863 | 0.00016863 |   0.0 |  0.00
Modify  | 0.33766    | 0.33766    | 0.33766    |   0.0 |  0.20
Other   |            | 0.05948    |            |       |  0.04

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:       135338 ave      135338 max      135338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135338
Ave neighs/atom = 67.669
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 330.89698731467, Press = -1278.20838239965
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10421.429     -10421.429     -10509.801     -10509.801      342.00981      342.00981      28089.007      28089.007     -1149.2631     -1149.2631    
      6000  -10422.951     -10422.951     -10507.778     -10507.778      328.29063      328.29063      28126.209      28126.209     -3099.7191     -3099.7191    
Loop time of 169.47 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.075 hours/ns, 5.901 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.96     | 168.96     | 168.96     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095596   | 0.095596   | 0.095596   |   0.0 |  0.06
Output  | 0.00020651 | 0.00020651 | 0.00020651 |   0.0 |  0.00
Modify  | 0.35757    | 0.35757    | 0.35757    |   0.0 |  0.21
Other   |            | 0.05912    |            |       |  0.03

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

Total # of neighbors = 135412
Ave neighs/atom = 67.706
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.199193769561, Press = -113.648003494326
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10422.951     -10422.951     -10507.778     -10507.778      328.29063      328.29063      28126.209      28126.209     -3099.7191     -3099.7191    
      7000  -10422.239     -10422.239     -10506.024     -10506.024      324.25467      324.25467      28112.668      28112.668     -2003.401      -2003.401     
Loop time of 169.256 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.016 hours/ns, 5.908 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.74     | 168.74     | 168.74     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095516   | 0.095516   | 0.095516   |   0.0 |  0.06
Output  | 0.00017051 | 0.00017051 | 0.00017051 |   0.0 |  0.00
Modify  | 0.35785    | 0.35785    | 0.35785    |   0.0 |  0.21
Other   |            | 0.05905    |            |       |  0.03

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

Total # of neighbors = 135514
Ave neighs/atom = 67.757
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.650145077671, Press = -28.6120331880886
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10422.239     -10422.239     -10506.024     -10506.024      324.25467      324.25467      28112.668      28112.668     -2003.401      -2003.401     
      8000  -10424.797     -10424.797     -10511.919     -10511.919      337.17213      337.17213      28096.039      28096.039     -1554.2333     -1554.2333    
Loop time of 169.537 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.094 hours/ns, 5.898 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.03     | 169.03     | 169.03     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095008   | 0.095008   | 0.095008   |   0.0 |  0.06
Output  | 0.00017004 | 0.00017004 | 0.00017004 |   0.0 |  0.00
Modify  | 0.35764    | 0.35764    | 0.35764    |   0.0 |  0.21
Other   |            | 0.05902    |            |       |  0.03

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

Total # of neighbors = 135878
Ave neighs/atom = 67.939
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.024562358377, Press = -6.32373721377551
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10424.797     -10424.797     -10511.919     -10511.919      337.17213      337.17213      28096.039      28096.039     -1554.2333     -1554.2333    
      9000  -10422.388     -10422.388     -10508.621     -10508.621      333.7302       333.7302       28089.31       28089.31      -955.67253     -955.67253    
Loop time of 187.422 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.461 ns/day, 52.062 hours/ns, 5.336 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 186.84     | 186.84     | 186.84     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10408    | 0.10408    | 0.10408    |   0.0 |  0.06
Output  | 0.00023547 | 0.00023547 | 0.00023547 |   0.0 |  0.00
Modify  | 0.41474    | 0.41474    | 0.41474    |   0.0 |  0.22
Other   |            | 0.06483    |            |       |  0.03

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

Total # of neighbors = 135214
Ave neighs/atom = 67.607
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.218607084607, Press = -2.70578325608107
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10422.388     -10422.388     -10508.621     -10508.621      333.7302       333.7302       28089.31       28089.31      -955.67253     -955.67253    
     10000  -10423.057     -10423.057     -10509.09      -10509.09       332.95862      332.95862      28073.95       28073.95      -6.5569152     -6.5569152    
Loop time of 196.541 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.595 hours/ns, 5.088 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.92     | 195.92     | 195.92     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10859    | 0.10859    | 0.10859    |   0.0 |  0.06
Output  | 0.00022935 | 0.00022935 | 0.00022935 |   0.0 |  0.00
Modify  | 0.44253    | 0.44253    | 0.44253    |   0.0 |  0.23
Other   |            | 0.06659    |            |       |  0.03

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

Total # of neighbors = 135674
Ave neighs/atom = 67.837
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.941659696417, Press = -1.04946521870254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10423.057     -10423.057     -10509.09      -10509.09       332.95862      332.95862      28073.95       28073.95      -6.5569152     -6.5569152    
     11000  -10421.007     -10421.007     -10507.158     -10507.158      333.41658      333.41658      28057.955      28057.955      879.15938      879.15938    
Loop time of 196.96 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.711 hours/ns, 5.077 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    | 196.35     | 196.35     | 196.35     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10737    | 0.10737    | 0.10737    |   0.0 |  0.05
Output  | 0.00028249 | 0.00028249 | 0.00028249 |   0.0 |  0.00
Modify  | 0.43355    | 0.43355    | 0.43355    |   0.0 |  0.22
Other   |            | 0.06514    |            |       |  0.03

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

Total # of neighbors = 135602
Ave neighs/atom = 67.801
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.828641844174, Press = 6.80709460696839
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10421.007     -10421.007     -10507.158     -10507.158      333.41658      333.41658      28057.955      28057.955      879.15938      879.15938    
     12000  -10425.642     -10425.642     -10510.412     -10510.412      328.06794      328.06794      28028.672      28028.672      2062.9458      2062.9458    
Loop time of 197.361 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.823 hours/ns, 5.067 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.76     | 196.76     | 196.76     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10674    | 0.10674    | 0.10674    |   0.0 |  0.05
Output  | 0.00022997 | 0.00022997 | 0.00022997 |   0.0 |  0.00
Modify  | 0.4317     | 0.4317     | 0.4317     |   0.0 |  0.22
Other   |            | 0.06542    |            |       |  0.03

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

Total # of neighbors = 135812
Ave neighs/atom = 67.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 = 332.922792055593, Press = 4.28053080714684
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10425.642     -10425.642     -10510.412     -10510.412      328.06794      328.06794      28028.672      28028.672      2062.9458      2062.9458    
     13000  -10419.893     -10419.893     -10504.169     -10504.169      326.15979      326.15979      28028.933      28028.933      2683.0363      2683.0363    
Loop time of 197.656 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.904 hours/ns, 5.059 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.06     | 197.06     | 197.06     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10578    | 0.10578    | 0.10578    |   0.0 |  0.05
Output  | 0.00017091 | 0.00017091 | 0.00017091 |   0.0 |  0.00
Modify  | 0.42324    | 0.42324    | 0.42324    |   0.0 |  0.21
Other   |            | 0.06447    |            |       |  0.03

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

Total # of neighbors = 135806
Ave neighs/atom = 67.903
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.779638312044, Press = 0.261370909053177
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10419.893     -10419.893     -10504.169     -10504.169      326.15979      326.15979      28028.933      28028.933      2683.0363      2683.0363    
     14000  -10422.6       -10422.6       -10511.009     -10511.009      342.15044      342.15044      28034.021      28034.021      1753.1979      1753.1979    
Loop time of 198.228 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.063 hours/ns, 5.045 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.61     | 197.61     | 197.61     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10838    | 0.10838    | 0.10838    |   0.0 |  0.05
Output  | 0.00021757 | 0.00021757 | 0.00021757 |   0.0 |  0.00
Modify  | 0.4435     | 0.4435     | 0.4435     |   0.0 |  0.22
Other   |            | 0.06632    |            |       |  0.03

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

Total # of neighbors = 136334
Ave neighs/atom = 68.167
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.764592402659, Press = -2.50029958647886
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10422.6       -10422.6       -10511.009     -10511.009      342.15044      342.15044      28034.021      28034.021      1753.1979      1753.1979    
     15000  -10414.833     -10414.833     -10504.459     -10504.459      346.86258      346.86258      28049.386      28049.386      1795.4882      1795.4882    
Loop time of 175.04 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.622 hours/ns, 5.713 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    | 174.5      | 174.5      | 174.5      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098193   | 0.098193   | 0.098193   |   0.0 |  0.06
Output  | 0.00016801 | 0.00016801 | 0.00016801 |   0.0 |  0.00
Modify  | 0.37721    | 0.37721    | 0.37721    |   0.0 |  0.22
Other   |            | 0.06212    |            |       |  0.04

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:       135688 ave      135688 max      135688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135688
Ave neighs/atom = 67.844
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.040009771542, Press = -4.60305801986993
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10414.833     -10414.833     -10504.459     -10504.459      346.86258      346.86258      28049.386      28049.386      1795.4882      1795.4882    
     16000  -10425.395     -10425.395     -10508.436     -10508.436      321.37835      321.37835      28036.634      28036.634      1655.8023      1655.8023    
Loop time of 181.291 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.477 ns/day, 50.359 hours/ns, 5.516 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 180.74     | 180.74     | 180.74     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10034    | 0.10034    | 0.10034    |   0.0 |  0.06
Output  | 0.00023181 | 0.00023181 | 0.00023181 |   0.0 |  0.00
Modify  | 0.38848    | 0.38848    | 0.38848    |   0.0 |  0.21
Other   |            | 0.06302    |            |       |  0.03

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

Total # of neighbors = 135910
Ave neighs/atom = 67.955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.317843996433, Press = -5.39887987434677
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10425.395     -10425.395     -10508.436     -10508.436      321.37835      321.37835      28036.634      28036.634      1655.8023      1655.8023    
     17000  -10421.9       -10421.9       -10506.829     -10506.829      328.68077      328.68077      28056.261      28056.261      783.35806      783.35806    
Loop time of 196.883 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.690 hours/ns, 5.079 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    | 196.27     | 196.27     | 196.27     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10716    | 0.10716    | 0.10716    |   0.0 |  0.05
Output  | 0.0001718  | 0.0001718  | 0.0001718  |   0.0 |  0.00
Modify  | 0.435      | 0.435      | 0.435      |   0.0 |  0.22
Other   |            | 0.06596    |            |       |  0.03

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

Total # of neighbors = 136082
Ave neighs/atom = 68.041
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.181907264868, Press = -6.24300802991282
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10421.9       -10421.9       -10506.829     -10506.829      328.68077      328.68077      28056.261      28056.261      783.35806      783.35806    
     18000  -10421.297     -10421.297     -10507.535     -10507.535      333.75085      333.75085      28070.878      28070.878      138.82446      138.82446    
Loop time of 197.562 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.878 hours/ns, 5.062 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    | 196.94     | 196.94     | 196.94     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10889    | 0.10889    | 0.10889    |   0.0 |  0.06
Output  | 0.00021246 | 0.00021246 | 0.00021246 |   0.0 |  0.00
Modify  | 0.44921    | 0.44921    | 0.44921    |   0.0 |  0.23
Other   |            | 0.06727    |            |       |  0.03

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

Total # of neighbors = 136064
Ave neighs/atom = 68.032
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.011852685223, Press = -7.53300570767483
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10421.297     -10421.297     -10507.535     -10507.535      333.75085      333.75085      28070.878      28070.878      138.82446      138.82446    
     19000  -10425.665     -10425.665     -10510.998     -10510.998      330.24843      330.24843      28091.132      28091.132     -1419.064      -1419.064     
Loop time of 196.498 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.583 hours/ns, 5.089 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.88     | 195.88     | 195.88     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10768    | 0.10768    | 0.10768    |   0.0 |  0.05
Output  | 0.00016836 | 0.00016836 | 0.00016836 |   0.0 |  0.00
Modify  | 0.43977    | 0.43977    | 0.43977    |   0.0 |  0.22
Other   |            | 0.06619    |            |       |  0.03

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

Total # of neighbors = 135686
Ave neighs/atom = 67.843
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.009219606502, Press = -9.16769000024065
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10425.665     -10425.665     -10510.998     -10510.998      330.24843      330.24843      28091.132      28091.132     -1419.064      -1419.064     
     20000  -10425.44      -10425.44      -10508.221     -10508.221      320.37119      320.37119      28104.106      28104.106     -1965.6854     -1965.6854    
Loop time of 197.034 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.732 hours/ns, 5.075 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    | 196.42     | 196.42     | 196.42     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10828    | 0.10828    | 0.10828    |   0.0 |  0.05
Output  | 0.00017109 | 0.00017109 | 0.00017109 |   0.0 |  0.00
Modify  | 0.44024    | 0.44024    | 0.44024    |   0.0 |  0.22
Other   |            | 0.06671    |            |       |  0.03

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

Total # of neighbors = 135304
Ave neighs/atom = 67.652
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.896535798172, Press = -6.10897104806237
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10425.44      -10425.44      -10508.221     -10508.221      320.37119      320.37119      28104.106      28104.106     -1965.6854     -1965.6854    
     21000  -10420.574     -10420.574     -10506.034     -10506.034      330.739        330.739        28091.215      28091.215     -956.77775     -956.77775    
Loop time of 197.552 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.875 hours/ns, 5.062 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.94     | 196.94     | 196.94     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1083     | 0.1083     | 0.1083     |   0.0 |  0.05
Output  | 0.00016931 | 0.00016931 | 0.00016931 |   0.0 |  0.00
Modify  | 0.43566    | 0.43566    | 0.43566    |   0.0 |  0.22
Other   |            | 0.06588    |            |       |  0.03

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

Total # of neighbors = 135528
Ave neighs/atom = 67.764
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.942045850336, Press = -2.89059898144422
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10420.574     -10420.574     -10506.034     -10506.034      330.739        330.739        28091.215      28091.215     -956.77775     -956.77775    
     22000  -10422.547     -10422.547     -10509.476     -10509.476      336.426        336.426        28081.962      28081.962     -754.82375     -754.82375    
Loop time of 197.077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.744 hours/ns, 5.074 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    | 196.46     | 196.46     | 196.46     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10835    | 0.10835    | 0.10835    |   0.0 |  0.05
Output  | 0.00026544 | 0.00026544 | 0.00026544 |   0.0 |  0.00
Modify  | 0.44123    | 0.44123    | 0.44123    |   0.0 |  0.22
Other   |            | 0.06697    |            |       |  0.03

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

Total # of neighbors = 135766
Ave neighs/atom = 67.883
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.182966957682, Press = -2.53671435865556
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10422.547     -10422.547     -10509.476     -10509.476      336.426        336.426        28081.962      28081.962     -754.82375     -754.82375    
     23000  -10420.046     -10420.046     -10506.967     -10506.967      336.39254      336.39254      28081.476      28081.476     -521.38325     -521.38325    
Loop time of 196.541 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.595 hours/ns, 5.088 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.93     | 195.93     | 195.93     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10832    | 0.10832    | 0.10832    |   0.0 |  0.06
Output  | 0.00021866 | 0.00021866 | 0.00021866 |   0.0 |  0.00
Modify  | 0.4386     | 0.4386     | 0.4386     |   0.0 |  0.22
Other   |            | 0.06753    |            |       |  0.03

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

Total # of neighbors = 135684
Ave neighs/atom = 67.842
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.201914404864, Press = -2.30970595406535
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -10420.046     -10420.046     -10506.967     -10506.967      336.39254      336.39254      28081.476      28081.476     -521.38325     -521.38325    
     24000  -10422.336     -10422.336     -10507.922     -10507.922      331.22531      331.22531      28083.916      28083.916     -639.85038     -639.85038    
Loop time of 196.843 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.678 hours/ns, 5.080 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.22     | 196.22     | 196.22     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10807    | 0.10807    | 0.10807    |   0.0 |  0.05
Output  | 0.000279   | 0.000279   | 0.000279   |   0.0 |  0.00
Modify  | 0.44341    | 0.44341    | 0.44341    |   0.0 |  0.23
Other   |            | 0.06753    |            |       |  0.03

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

Total # of neighbors = 135848
Ave neighs/atom = 67.924
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.39200868346, Press = -1.91522935126476
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -10422.336     -10422.336     -10507.922     -10507.922      331.22531      331.22531      28083.916      28083.916     -639.85038     -639.85038    
     25000  -10422.016     -10422.016     -10506.831     -10506.831      328.24384      328.24384      28082.958      28082.958     -531.02039     -531.02039    
Loop time of 196.574 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.604 hours/ns, 5.087 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.95     | 195.95     | 195.95     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10815    | 0.10815    | 0.10815    |   0.0 |  0.06
Output  | 0.0001713  | 0.0001713  | 0.0001713  |   0.0 |  0.00
Modify  | 0.44325    | 0.44325    | 0.44325    |   0.0 |  0.23
Other   |            | 0.06757    |            |       |  0.03

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

Total # of neighbors = 135550
Ave neighs/atom = 67.775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.340353590559, Press = -0.913068356498378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -10422.016     -10422.016     -10506.831     -10506.831      328.24384      328.24384      28082.958      28082.958     -531.02039     -531.02039    
     26000  -10421.168     -10421.168     -10506.931     -10506.931      331.91456      331.91456      28076.424      28076.424     -129.51226     -129.51226    
Loop time of 196.415 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.560 hours/ns, 5.091 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.8      | 195.8      | 195.8      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10732    | 0.10732    | 0.10732    |   0.0 |  0.05
Output  | 0.00017041 | 0.00017041 | 0.00017041 |   0.0 |  0.00
Modify  | 0.44237    | 0.44237    | 0.44237    |   0.0 |  0.23
Other   |            | 0.06681    |            |       |  0.03

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

Total # of neighbors = 135690
Ave neighs/atom = 67.845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.399734220347, Press = -0.0738491719389593
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -10421.168     -10421.168     -10506.931     -10506.931      331.91456      331.91456      28076.424      28076.424     -129.51226     -129.51226    
     27000  -10420.952     -10420.952     -10507.877     -10507.877      336.40779      336.40779      28058.939      28058.939      837.93566      837.93566    
Loop time of 195.95 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.441 ns/day, 54.431 hours/ns, 5.103 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.34     | 195.34     | 195.34     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10692    | 0.10692    | 0.10692    |   0.0 |  0.05
Output  | 0.00020775 | 0.00020775 | 0.00020775 |   0.0 |  0.00
Modify  | 0.44052    | 0.44052    | 0.44052    |   0.0 |  0.22
Other   |            | 0.06636    |            |       |  0.03

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

Total # of neighbors = 135616
Ave neighs/atom = 67.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.339355052745, Press = 1.05162805864986
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -10420.952     -10420.952     -10507.877     -10507.877      336.40779      336.40779      28058.939      28058.939      837.93566      837.93566    
     28000  -10424.209     -10424.209     -10508.49      -10508.49       326.17338      326.17338      28018.864      28018.864      2751.8087      2751.8087    
Loop time of 196.624 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.618 hours/ns, 5.086 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    | 196.01     | 196.01     | 196.01     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10767    | 0.10767    | 0.10767    |   0.0 |  0.05
Output  | 0.00016955 | 0.00016955 | 0.00016955 |   0.0 |  0.00
Modify  | 0.44212    | 0.44212    | 0.44212    |   0.0 |  0.22
Other   |            | 0.06647    |            |       |  0.03

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

Total # of neighbors = 135808
Ave neighs/atom = 67.904
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.398488309509, Press = 1.22992255434217
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -10424.209     -10424.209     -10508.49      -10508.49       326.17338      326.17338      28018.864      28018.864      2751.8087      2751.8087    
     29000  -10418.134     -10418.134     -10507.399     -10507.399      345.46246      345.46246      28041.921      28041.921      1893.9757      1893.9757    
Loop time of 197.008 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.725 hours/ns, 5.076 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.39     | 196.39     | 196.39     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10761    | 0.10761    | 0.10761    |   0.0 |  0.05
Output  | 0.00016904 | 0.00016904 | 0.00016904 |   0.0 |  0.00
Modify  | 0.44742    | 0.44742    | 0.44742    |   0.0 |  0.23
Other   |            | 0.06602    |            |       |  0.03

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

Total # of neighbors = 136012
Ave neighs/atom = 68.006
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.510552803346, Press = -1.00854841733898
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -10418.134     -10418.134     -10507.399     -10507.399      345.46246      345.46246      28041.921      28041.921      1893.9757      1893.9757    
     30000  -10423.563     -10423.563     -10510.285     -10510.285      335.62382      335.62382      28051.317      28051.317      968.58495      968.58495    
Loop time of 196.487 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.580 hours/ns, 5.089 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.87     | 195.87     | 195.87     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10798    | 0.10798    | 0.10798    |   0.0 |  0.05
Output  | 0.00022279 | 0.00022279 | 0.00022279 |   0.0 |  0.00
Modify  | 0.4464     | 0.4464     | 0.4464     |   0.0 |  0.23
Other   |            | 0.06626    |            |       |  0.03

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

Total # of neighbors = 136074
Ave neighs/atom = 68.037
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.565836871796, Press = -1.7682703623924
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -10423.563     -10423.563     -10510.285     -10510.285      335.62382      335.62382      28051.317      28051.317      968.58495      968.58495    
     31000  -10425.283     -10425.283     -10508.697     -10508.697      322.82108      322.82108      28045.967      28045.967      1382.3835      1382.3835    
Loop time of 195.662 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.442 ns/day, 54.351 hours/ns, 5.111 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.05     | 195.05     | 195.05     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10694    | 0.10694    | 0.10694    |   0.0 |  0.05
Output  | 0.00021547 | 0.00021547 | 0.00021547 |   0.0 |  0.00
Modify  | 0.44357    | 0.44357    | 0.44357    |   0.0 |  0.23
Other   |            | 0.0658     |            |       |  0.03

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

Total # of neighbors = 135846
Ave neighs/atom = 67.923
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.619433907916, Press = -2.29514912372753
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -10425.283     -10425.283     -10508.697     -10508.697      322.82108      322.82108      28045.967      28045.967      1382.3835      1382.3835    
     32000  -10421.641     -10421.641     -10507.668     -10507.668      332.9346       332.9346       28048.855      28048.855      1197.3367      1197.3367    
Loop time of 195.957 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.441 ns/day, 54.433 hours/ns, 5.103 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.34     | 195.34     | 195.34     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10746    | 0.10746    | 0.10746    |   0.0 |  0.05
Output  | 0.00021673 | 0.00021673 | 0.00021673 |   0.0 |  0.00
Modify  | 0.44517    | 0.44517    | 0.44517    |   0.0 |  0.23
Other   |            | 0.06561    |            |       |  0.03

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

Total # of neighbors = 135666
Ave neighs/atom = 67.833
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.525392789013, Press = -3.25119496868133
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -10421.641     -10421.641     -10507.668     -10507.668      332.9346       332.9346       28048.855      28048.855      1197.3367      1197.3367    
     33000  -10427.597     -10427.597     -10512.248     -10512.248      327.60746      327.60746      28052.713      28052.713      584.33239      584.33239    
Loop time of 195.866 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.441 ns/day, 54.407 hours/ns, 5.106 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.25     | 195.25     | 195.25     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10661    | 0.10661    | 0.10661    |   0.0 |  0.05
Output  | 0.00025553 | 0.00025553 | 0.00025553 |   0.0 |  0.00
Modify  | 0.4422     | 0.4422     | 0.4422     |   0.0 |  0.23
Other   |            | 0.06587    |            |       |  0.03

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

Total # of neighbors = 136002
Ave neighs/atom = 68.001
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.46744519932, Press = -5.02896905534863
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -10427.597     -10427.597     -10512.248     -10512.248      327.60746      327.60746      28052.713      28052.713      584.33239      584.33239    
     34000  -10421.761     -10421.761     -10508.177     -10508.177      334.43859      334.43859      28086.81       28086.81      -766.09334     -766.09334    
Loop time of 195.911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.441 ns/day, 54.420 hours/ns, 5.104 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.3      | 195.3      | 195.3      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10689    | 0.10689    | 0.10689    |   0.0 |  0.05
Output  | 0.00016996 | 0.00016996 | 0.00016996 |   0.0 |  0.00
Modify  | 0.43876    | 0.43876    | 0.43876    |   0.0 |  0.22
Other   |            | 0.0659     |            |       |  0.03

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

Total # of neighbors = 135462
Ave neighs/atom = 67.731
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.37329391175, Press = -4.24149123040911
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -10421.761     -10421.761     -10508.177     -10508.177      334.43859      334.43859      28086.81       28086.81      -766.09334     -766.09334    
     35000  -10426.376     -10426.376     -10511.186     -10511.186      328.22411      328.22411      28079.119      28079.119     -653.82012     -653.82012    
Loop time of 196.32 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.533 hours/ns, 5.094 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.7      | 195.7      | 195.7      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10827    | 0.10827    | 0.10827    |   0.0 |  0.06
Output  | 0.00026649 | 0.00026649 | 0.00026649 |   0.0 |  0.00
Modify  | 0.44332    | 0.44332    | 0.44332    |   0.0 |  0.23
Other   |            | 0.06707    |            |       |  0.03

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

Total # of neighbors = 135518
Ave neighs/atom = 67.759
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.305444859598, Press = -1.99956547374466
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -10426.376     -10426.376     -10511.186     -10511.186      328.22411      328.22411      28079.119      28079.119     -653.82012     -653.82012    
     36000  -10423.16      -10423.16      -10508.966     -10508.966      332.07661      332.07661      28086.527      28086.527     -908.95169     -908.95169    
Loop time of 185.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.465 ns/day, 51.565 hours/ns, 5.387 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 185.06     | 185.06     | 185.06     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10189    | 0.10189    | 0.10189    |   0.0 |  0.05
Output  | 0.00016909 | 0.00016909 | 0.00016909 |   0.0 |  0.00
Modify  | 0.41241    | 0.41241    | 0.41241    |   0.0 |  0.22
Other   |            | 0.06428    |            |       |  0.03

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

Total # of neighbors = 135250
Ave neighs/atom = 67.625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.330929943952, Press = -1.30917609892697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -10423.16      -10423.16      -10508.966     -10508.966      332.07661      332.07661      28086.527      28086.527     -908.95169     -908.95169    
     37000  -10425.1       -10425.1       -10510.558     -10510.558      330.73038      330.73038      28090.093      28090.093     -1374.3237     -1374.3237    
Loop time of 183.374 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.471 ns/day, 50.937 hours/ns, 5.453 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 182.81     | 182.81     | 182.81     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10053    | 0.10053    | 0.10053    |   0.0 |  0.05
Output  | 0.00016807 | 0.00016807 | 0.00016807 |   0.0 |  0.00
Modify  | 0.402      | 0.402      | 0.402      |   0.0 |  0.22
Other   |            | 0.06346    |            |       |  0.03

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

Total # of neighbors = 135464
Ave neighs/atom = 67.732
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.413493017043, Press = -1.06592154104479
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -10425.1       -10425.1       -10510.558     -10510.558      330.73038      330.73038      28090.093      28090.093     -1374.3237     -1374.3237    
     38000  -10417.933     -10417.933     -10506.483     -10506.483      342.69825      342.69825      28116.14       28116.14      -2124.9998     -2124.9998    
Loop time of 168.398 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.513 ns/day, 46.777 hours/ns, 5.938 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 167.89     | 167.89     | 167.89     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093345   | 0.093345   | 0.093345   |   0.0 |  0.06
Output  | 0.00044603 | 0.00044603 | 0.00044603 |   0.0 |  0.00
Modify  | 0.35551    | 0.35551    | 0.35551    |   0.0 |  0.21
Other   |            | 0.05982    |            |       |  0.04

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:       135444 ave      135444 max      135444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135444
Ave neighs/atom = 67.722
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.446501221129, Press = 0.358649771528909
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -10417.933     -10417.933     -10506.483     -10506.483      342.69825      342.69825      28116.14       28116.14      -2124.9998     -2124.9998    
     39000  -10423.411     -10423.411     -10508.341     -10508.341      328.6889       328.6889       28084.057      28084.057     -572.19434     -572.19434    
Loop time of 168.387 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.513 ns/day, 46.774 hours/ns, 5.939 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 167.88     | 167.88     | 167.88     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093502   | 0.093502   | 0.093502   |   0.0 |  0.06
Output  | 0.00016906 | 0.00016906 | 0.00016906 |   0.0 |  0.00
Modify  | 0.35561    | 0.35561    | 0.35561    |   0.0 |  0.21
Other   |            | 0.06026    |            |       |  0.04

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:       135442 ave      135442 max      135442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135442
Ave neighs/atom = 67.721
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.532325533433, Press = 1.03330551286991
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -10423.411     -10423.411     -10508.341     -10508.341      328.6889       328.6889       28084.057      28084.057     -572.19434     -572.19434    
     40000  -10418.655     -10418.655     -10509.068     -10509.068      349.90785      349.90785      28067.407      28067.407      236.54274      236.54274    
Loop time of 168.517 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.513 ns/day, 46.810 hours/ns, 5.934 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.01     | 168.01     | 168.01     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093249   | 0.093249   | 0.093249   |   0.0 |  0.06
Output  | 0.00016963 | 0.00016963 | 0.00016963 |   0.0 |  0.00
Modify  | 0.35578    | 0.35578    | 0.35578    |   0.0 |  0.21
Other   |            | 0.0604     |            |       |  0.04

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:       135400 ave      135400 max      135400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135400
Ave neighs/atom = 67.7
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.546033509495, Press = 0.777225872691017
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -10418.655     -10418.655     -10509.068     -10509.068      349.90785      349.90785      28067.407      28067.407      236.54274      236.54274    
     41000  -10423.74      -10423.74      -10512.09      -10512.09       341.92581      341.92581      28054.072      28054.072      537.66821      537.66821    
Loop time of 168.442 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.513 ns/day, 46.789 hours/ns, 5.937 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 167.93     | 167.93     | 167.93     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09261    | 0.09261    | 0.09261    |   0.0 |  0.05
Output  | 0.00021005 | 0.00021005 | 0.00021005 |   0.0 |  0.00
Modify  | 0.35549    | 0.35549    | 0.35549    |   0.0 |  0.21
Other   |            | 0.06028    |            |       |  0.04

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:       135530 ave      135530 max      135530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135530
Ave neighs/atom = 67.765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.55088540388, Press = 0.379517493652237
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -10423.74      -10423.74      -10512.09      -10512.09       341.92581      341.92581      28054.072      28054.072      537.66821      537.66821    
     42000  -10425.209     -10425.209     -10509.073     -10509.073      324.56222      324.56222      28041.927      28041.927      1520.7216      1520.7216    
Loop time of 171.478 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.504 ns/day, 47.633 hours/ns, 5.832 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.96     | 170.96     | 170.96     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094774   | 0.094774   | 0.094774   |   0.0 |  0.06
Output  | 0.00017144 | 0.00017144 | 0.00017144 |   0.0 |  0.00
Modify  | 0.36505    | 0.36505    | 0.36505    |   0.0 |  0.21
Other   |            | 0.06092    |            |       |  0.04

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:       135606 ave      135606 max      135606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135606
Ave neighs/atom = 67.803
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.523714461008, Press = -0.226012283379854
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -10425.209     -10425.209     -10509.073     -10509.073      324.56222      324.56222      28041.927      28041.927      1520.7216      1520.7216    
     43000  -10421.801     -10421.801     -10508.203     -10508.203      334.38606      334.38606      28026.45       28026.45       2369.0641      2369.0641    
Loop time of 179.92 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.480 ns/day, 49.978 hours/ns, 5.558 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 179.37     | 179.37     | 179.37     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098469   | 0.098469   | 0.098469   |   0.0 |  0.05
Output  | 0.00017338 | 0.00017338 | 0.00017338 |   0.0 |  0.00
Modify  | 0.39125    | 0.39125    | 0.39125    |   0.0 |  0.22
Other   |            | 0.06233    |            |       |  0.03

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

Total # of neighbors = 135890
Ave neighs/atom = 67.945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.448165513032, Press = -0.575630121458925
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -10421.801     -10421.801     -10508.203     -10508.203      334.38606      334.38606      28026.45       28026.45       2369.0641      2369.0641    
     44000  -10425.152     -10425.152     -10510.681     -10510.681      331.00752      331.00752      27994.587      27994.587      3925.5764      3925.5764    
Loop time of 170.151 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.508 ns/day, 47.264 hours/ns, 5.877 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.64     | 169.64     | 169.64     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094245   | 0.094245   | 0.094245   |   0.0 |  0.06
Output  | 0.00017042 | 0.00017042 | 0.00017042 |   0.0 |  0.00
Modify  | 0.35716    | 0.35716    | 0.35716    |   0.0 |  0.21
Other   |            | 0.05913    |            |       |  0.03

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

Total # of neighbors = 136200
Ave neighs/atom = 68.1
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.420555357672, Press = -1.43088081892247
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -10425.152     -10425.152     -10510.681     -10510.681      331.00752      331.00752      27994.587      27994.587      3925.5764      3925.5764    
     45000  -10420.785     -10420.785     -10506.871     -10506.871      333.16033      333.16033      28013.973      28013.973      3282.3529      3282.3529    
Loop time of 169.711 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.142 hours/ns, 5.892 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.2      | 169.2      | 169.2      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09436    | 0.09436    | 0.09436    |   0.0 |  0.06
Output  | 0.00017001 | 0.00017001 | 0.00017001 |   0.0 |  0.00
Modify  | 0.3574     | 0.3574     | 0.3574     |   0.0 |  0.21
Other   |            | 0.0591     |            |       |  0.03

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

Total # of neighbors = 135890
Ave neighs/atom = 67.945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.419432014598, Press = -2.70786189520975
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -10420.785     -10420.785     -10506.871     -10506.871      333.16033      333.16033      28013.973      28013.973      3282.3529      3282.3529    
     46000  -10423.868     -10423.868     -10511.729     -10511.729      340.03151      340.03151      28051.319      28051.319      661.74971      661.74971    
Loop time of 179.303 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.482 ns/day, 49.806 hours/ns, 5.577 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.76     | 178.76     | 178.76     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098205   | 0.098205   | 0.098205   |   0.0 |  0.05
Output  | 0.00022551 | 0.00022551 | 0.00022551 |   0.0 |  0.00
Modify  | 0.38706    | 0.38706    | 0.38706    |   0.0 |  0.22
Other   |            | 0.06129    |            |       |  0.03

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

Total # of neighbors = 136158
Ave neighs/atom = 68.079
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.464061877578, Press = -1.81582328696641
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -10423.868     -10423.868     -10511.729     -10511.729      340.03151      340.03151      28051.319      28051.319      661.74971      661.74971    
     47000  -10421.152     -10421.152     -10508.883     -10508.883      339.52883      339.52883      28067.99       28067.99       201.0459       201.0459     
Loop time of 196.031 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.441 ns/day, 54.453 hours/ns, 5.101 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.42     | 195.42     | 195.42     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10583    | 0.10583    | 0.10583    |   0.0 |  0.05
Output  | 0.00022801 | 0.00022801 | 0.00022801 |   0.0 |  0.00
Modify  | 0.44079    | 0.44079    | 0.44079    |   0.0 |  0.22
Other   |            | 0.06573    |            |       |  0.03

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

Total # of neighbors = 135630
Ave neighs/atom = 67.815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.453208336665, Press = -1.74477845916484
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -10421.152     -10421.152     -10508.883     -10508.883      339.52883      339.52883      28067.99       28067.99       201.0459       201.0459     
     48000  -10424.175     -10424.175     -10509.985     -10509.985      332.09451      332.09451      28078.562      28078.562     -469.97772     -469.97772    
Loop time of 178.947 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.483 ns/day, 49.708 hours/ns, 5.588 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    | 178.4      | 178.4      | 178.4      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097643   | 0.097643   | 0.097643   |   0.0 |  0.05
Output  | 0.00017047 | 0.00017047 | 0.00017047 |   0.0 |  0.00
Modify  | 0.38771    | 0.38771    | 0.38771    |   0.0 |  0.22
Other   |            | 0.06155    |            |       |  0.03

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

Total # of neighbors = 135652
Ave neighs/atom = 67.826
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.429186377042, Press = -2.02418545178704
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -10424.175     -10424.175     -10509.985     -10509.985      332.09451      332.09451      28078.562      28078.562     -469.97772     -469.97772    
     49000  -10419.274     -10419.274     -10507.16      -10507.16       340.12926      340.12926      28108.347      28108.347     -1869.813      -1869.813     
Loop time of 190.637 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.453 ns/day, 52.955 hours/ns, 5.246 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.06     | 190.06     | 190.06     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10304    | 0.10304    | 0.10304    |   0.0 |  0.05
Output  | 0.00018037 | 0.00018037 | 0.00018037 |   0.0 |  0.00
Modify  | 0.41072    | 0.41072    | 0.41072    |   0.0 |  0.22
Other   |            | 0.06373    |            |       |  0.03

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

Total # of neighbors = 135308
Ave neighs/atom = 67.654
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.379935839324, Press = -2.24413601864398
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -10419.274     -10419.274     -10507.16      -10507.16       340.12926      340.12926      28108.347      28108.347     -1869.813      -1869.813     
     50000  -10422.944     -10422.944     -10508.809     -10508.809      332.3047       332.3047       28132.891      28132.891     -3520.8692     -3520.8692    
Loop time of 194.121 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.445 ns/day, 53.923 hours/ns, 5.151 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    | 193.52     | 193.52     | 193.52     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10594    | 0.10594    | 0.10594    |   0.0 |  0.05
Output  | 0.000169   | 0.000169   | 0.000169   |   0.0 |  0.00
Modify  | 0.43268    | 0.43268    | 0.43268    |   0.0 |  0.22
Other   |            | 0.06568    |            |       |  0.03

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

Total # of neighbors = 135462
Ave neighs/atom = 67.731
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.40137043703, Press = -1.61758999973592
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -10422.944     -10422.944     -10508.809     -10508.809      332.3047       332.3047       28132.891      28132.891     -3520.8692     -3520.8692    
     51000  -10418.991     -10418.991     -10507.971     -10507.971      344.36185      344.36185      28118.605      28118.605     -2542.9582     -2542.9582    
Loop time of 194.568 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.444 ns/day, 54.047 hours/ns, 5.140 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.96     | 193.96     | 193.96     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1069     | 0.1069     | 0.1069     |   0.0 |  0.05
Output  | 0.00016828 | 0.00016828 | 0.00016828 |   0.0 |  0.00
Modify  | 0.43943    | 0.43943    | 0.43943    |   0.0 |  0.23
Other   |            | 0.06492    |            |       |  0.03

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

Total # of neighbors = 135158
Ave neighs/atom = 67.579
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.472577452148, Press = -0.69466565566731
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -10418.991     -10418.991     -10507.971     -10507.971      344.36185      344.36185      28118.605      28118.605     -2542.9582     -2542.9582    
     52000  -10422.134     -10422.134     -10508.323     -10508.323      333.56029      333.56029      28092.128      28092.128     -1204.6611     -1204.6611    
Loop time of 179.927 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.480 ns/day, 49.980 hours/ns, 5.558 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    | 179.38     | 179.38     | 179.38     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098746   | 0.098746   | 0.098746   |   0.0 |  0.05
Output  | 0.00023044 | 0.00023044 | 0.00023044 |   0.0 |  0.00
Modify  | 0.38969    | 0.38969    | 0.38969    |   0.0 |  0.22
Other   |            | 0.06158    |            |       |  0.03

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

Total # of neighbors = 135474
Ave neighs/atom = 67.737
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.475477745506, Press = -0.235646341157684
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -10422.134     -10422.134     -10508.323     -10508.323      333.56029      333.56029      28092.128      28092.128     -1204.6611     -1204.6611    
     53000  -10427.63      -10427.63      -10510.308     -10510.308      319.97389      319.97389      28071.024      28071.024     -411.97084     -411.97084    
Loop time of 197.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.760 hours/ns, 5.073 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.54     | 196.54     | 196.54     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1048     | 0.1048     | 0.1048     |   0.0 |  0.05
Output  | 0.00021114 | 0.00021114 | 0.00021114 |   0.0 |  0.00
Modify  | 0.42978    | 0.42978    | 0.42978    |   0.0 |  0.22
Other   |            | 0.06478    |            |       |  0.03

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

Total # of neighbors = 135504
Ave neighs/atom = 67.752
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.456031654227, Press = -0.0649866971883368
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -10427.63      -10427.63      -10510.308     -10510.308      319.97389      319.97389      28071.024      28071.024     -411.97084     -411.97084    
     54000  -10422.126     -10422.126     -10509.313     -10509.313      337.41989      337.41989      28064.62       28064.62       207.65059      207.65059    
Loop time of 197.602 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.889 hours/ns, 5.061 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.01     | 197.01     | 197.01     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10482    | 0.10482    | 0.10482    |   0.0 |  0.05
Output  | 0.0001694  | 0.0001694  | 0.0001694  |   0.0 |  0.00
Modify  | 0.4279     | 0.4279     | 0.4279     |   0.0 |  0.22
Other   |            | 0.064      |            |       |  0.03

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

Total # of neighbors = 135478
Ave neighs/atom = 67.739
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.389755508226, Press = 0.302214954479423
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -10422.126     -10422.126     -10509.313     -10509.313      337.41989      337.41989      28064.62       28064.62       207.65059      207.65059    
     55000  -10423.436     -10423.436     -10509.467     -10509.467      332.94716      332.94716      28012.324      28012.324      3168.3125      3168.3125    
Loop time of 193.021 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.448 ns/day, 53.617 hours/ns, 5.181 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    | 192.42     | 192.42     | 192.42     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10458    | 0.10458    | 0.10458    |   0.0 |  0.05
Output  | 0.00027844 | 0.00027844 | 0.00027844 |   0.0 |  0.00
Modify  | 0.4297     | 0.4297     | 0.4297     |   0.0 |  0.22
Other   |            | 0.06497    |            |       |  0.03

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

Total # of neighbors = 135656
Ave neighs/atom = 67.828
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.375634742804, Press = 1.27638331531542
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -10423.436     -10423.436     -10509.467     -10509.467      332.94716      332.94716      28012.324      28012.324      3168.3125      3168.3125    
     56000  -10416.893     -10416.893     -10507.93      -10507.93       352.32188      352.32188      28023.585      28023.585      3013.2574      3013.2574    
Loop time of 196.341 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.539 hours/ns, 5.093 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.72     | 195.72     | 195.72     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10782    | 0.10782    | 0.10782    |   0.0 |  0.05
Output  | 0.00021268 | 0.00021268 | 0.00021268 |   0.0 |  0.00
Modify  | 0.44464    | 0.44464    | 0.44464    |   0.0 |  0.23
Other   |            | 0.06567    |            |       |  0.03

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

Total # of neighbors = 135976
Ave neighs/atom = 67.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.40429779333, Press = 0.181427664153462
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -10416.893     -10416.893     -10507.93      -10507.93       352.32188      352.32188      28023.585      28023.585      3013.2574      3013.2574    
     57000  -10424.994     -10424.994     -10510.723     -10510.723      331.7813       331.7813       28036.244      28036.244      1809.138       1809.138     
Loop time of 196.381 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.550 hours/ns, 5.092 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.77     | 195.77     | 195.77     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10582    | 0.10582    | 0.10582    |   0.0 |  0.05
Output  | 0.00021179 | 0.00021179 | 0.00021179 |   0.0 |  0.00
Modify  | 0.44131    | 0.44131    | 0.44131    |   0.0 |  0.22
Other   |            | 0.06473    |            |       |  0.03

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

Total # of neighbors = 135896
Ave neighs/atom = 67.948
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.439721283475, Press = -0.493737899829826
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -10424.994     -10424.994     -10510.723     -10510.723      331.7813       331.7813       28036.244      28036.244      1809.138       1809.138     
     58000  -10419.909     -10419.909     -10507.034     -10507.034      337.18036      337.18036      28050.403      28050.403      1409.2585      1409.2585    
Loop time of 185.104 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.467 ns/day, 51.418 hours/ns, 5.402 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    | 184.54     | 184.54     | 184.54     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10085    | 0.10085    | 0.10085    |   0.0 |  0.05
Output  | 0.00022541 | 0.00022541 | 0.00022541 |   0.0 |  0.00
Modify  | 0.40433    | 0.40433    | 0.40433    |   0.0 |  0.22
Other   |            | 0.06267    |            |       |  0.03

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

Total # of neighbors = 135688
Ave neighs/atom = 67.844
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.459989789635, Press = -0.801993801795456
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -10419.909     -10419.909     -10507.034     -10507.034      337.18036      337.18036      28050.403      28050.403      1409.2585      1409.2585    
     59000  -10424.013     -10424.013     -10508.466     -10508.466      326.84113      326.84113      28048.719      28048.719      1166.623       1166.623     
Loop time of 197.309 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.808 hours/ns, 5.068 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.7      | 196.7      | 196.7      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10486    | 0.10486    | 0.10486    |   0.0 |  0.05
Output  | 0.0001714  | 0.0001714  | 0.0001714  |   0.0 |  0.00
Modify  | 0.43693    | 0.43693    | 0.43693    |   0.0 |  0.22
Other   |            | 0.06482    |            |       |  0.03

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

Total # of neighbors = 135830
Ave neighs/atom = 67.915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.490795552119, Press = -1.07465948854091
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -10424.013     -10424.013     -10508.466     -10508.466      326.84113      326.84113      28048.719      28048.719      1166.623       1166.623     
     60000  -10426.205     -10426.205     -10509.421     -10509.421      322.05613      322.05613      28055.709      28055.709      636.79679      636.79679    
Loop time of 197.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.836 hours/ns, 5.066 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.79     | 196.79     | 196.79     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10771    | 0.10771    | 0.10771    |   0.0 |  0.05
Output  | 0.00017163 | 0.00017163 | 0.00017163 |   0.0 |  0.00
Modify  | 0.44518    | 0.44518    | 0.44518    |   0.0 |  0.23
Other   |            | 0.06598    |            |       |  0.03

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

Total # of neighbors = 135704
Ave neighs/atom = 67.852
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.492502882143, Press = -2.62553697220844
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -10426.205     -10426.205     -10509.421     -10509.421      322.05613      322.05613      28055.709      28055.709      636.79679      636.79679    
     61000  -10420.953     -10420.953     -10509.339     -10509.339      342.06343      342.06343      28093.321      28093.321     -1205.1461     -1205.1461    
Loop time of 197.653 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.904 hours/ns, 5.059 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.05     | 197.05     | 197.05     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10645    | 0.10645    | 0.10645    |   0.0 |  0.05
Output  | 0.00017022 | 0.00017022 | 0.00017022 |   0.0 |  0.00
Modify  | 0.43516    | 0.43516    | 0.43516    |   0.0 |  0.22
Other   |            | 0.06571    |            |       |  0.03

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

Total # of neighbors = 135884
Ave neighs/atom = 67.942
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.458850581314, Press = -1.93187744549109
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -10420.953     -10420.953     -10509.339     -10509.339      342.06343      342.06343      28093.321      28093.321     -1205.1461     -1205.1461    
     62000  -10426.596     -10426.596     -10509.216     -10509.216      319.74837      319.74837      28090.051      28090.051     -1172.8049     -1172.8049    
Loop time of 188.124 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.459 ns/day, 52.257 hours/ns, 5.316 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    | 187.54     | 187.54     | 187.54     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10328    | 0.10328    | 0.10328    |   0.0 |  0.05
Output  | 0.00016917 | 0.00016917 | 0.00016917 |   0.0 |  0.00
Modify  | 0.4191     | 0.4191     | 0.4191     |   0.0 |  0.22
Other   |            | 0.06381    |            |       |  0.03

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

Total # of neighbors = 135314
Ave neighs/atom = 67.657
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.443350139183, Press = -0.984371361914757
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -10426.596     -10426.596     -10509.216     -10509.216      319.74837      319.74837      28090.051      28090.051     -1172.8049     -1172.8049    
     63000  -10423.054     -10423.054     -10508.583     -10508.583      331.00482      331.00482      28101.674      28101.674     -1704.8347     -1704.8347    
Loop time of 187.809 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.460 ns/day, 52.169 hours/ns, 5.325 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    | 187.23     | 187.23     | 187.23     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10399    | 0.10399    | 0.10399    |   0.0 |  0.06
Output  | 0.00026289 | 0.00026289 | 0.00026289 |   0.0 |  0.00
Modify  | 0.41638    | 0.41638    | 0.41638    |   0.0 |  0.22
Other   |            | 0.06347    |            |       |  0.03

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

Total # of neighbors = 135452
Ave neighs/atom = 67.726
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.393028217356, Press = -0.565573607410187
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -10423.054     -10423.054     -10508.583     -10508.583      331.00482      331.00482      28101.674      28101.674     -1704.8347     -1704.8347    
     64000  -10416.732     -10416.732     -10504.067     -10504.067      337.99802      337.99802      28109.26       28109.26      -1514.3371     -1514.3371    
Loop time of 195.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.441 ns/day, 54.407 hours/ns, 5.106 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    | 195.24     | 195.24     | 195.24     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10828    | 0.10828    | 0.10828    |   0.0 |  0.06
Output  | 0.00017021 | 0.00017021 | 0.00017021 |   0.0 |  0.00
Modify  | 0.44911    | 0.44911    | 0.44911    |   0.0 |  0.23
Other   |            | 0.06677    |            |       |  0.03

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

Total # of neighbors = 135272
Ave neighs/atom = 67.636
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.440122984417, Press = -0.395904050055103
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -10416.732     -10416.732     -10504.067     -10504.067      337.99802      337.99802      28109.26       28109.26      -1514.3371     -1514.3371    
     65000  -10425.067     -10425.067     -10510.649     -10510.649      331.20925      331.20925      28111.576      28111.576     -2525.2406     -2525.2406    
Loop time of 195.613 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.442 ns/day, 54.337 hours/ns, 5.112 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195        | 195        | 195        |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10824    | 0.10824    | 0.10824    |   0.0 |  0.06
Output  | 0.00017226 | 0.00017226 | 0.00017226 |   0.0 |  0.00
Modify  | 0.44178    | 0.44178    | 0.44178    |   0.0 |  0.23
Other   |            | 0.06662    |            |       |  0.03

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

Total # of neighbors = 135722
Ave neighs/atom = 67.861
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.451649097174, Press = 0.182446226624661
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -10425.067     -10425.067     -10510.649     -10510.649      331.20925      331.20925      28111.576      28111.576     -2525.2406     -2525.2406    
     66000  -10420.37      -10420.37      -10507.761     -10507.761      338.21497      338.21497      28116.872      28116.872     -2429.156      -2429.156     
Loop time of 195.559 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.442 ns/day, 54.322 hours/ns, 5.114 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.94     | 194.94     | 194.94     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10882    | 0.10882    | 0.10882    |   0.0 |  0.06
Output  | 0.00017167 | 0.00017167 | 0.00017167 |   0.0 |  0.00
Modify  | 0.44442    | 0.44442    | 0.44442    |   0.0 |  0.23
Other   |            | 0.06642    |            |       |  0.03

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

Total # of neighbors = 135130
Ave neighs/atom = 67.565
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.453461146593, Press = 1.21553546215498
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -10420.37      -10420.37      -10507.761     -10507.761      338.21497      338.21497      28116.872      28116.872     -2429.156      -2429.156     
     67000  -10425.198     -10425.198     -10510.39      -10510.39       329.7034       329.7034       28075.102      28075.102     -416.95931     -416.95931    
Loop time of 195.756 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.441 ns/day, 54.377 hours/ns, 5.108 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.14     | 195.14     | 195.14     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10874    | 0.10874    | 0.10874    |   0.0 |  0.06
Output  | 0.00017223 | 0.00017223 | 0.00017223 |   0.0 |  0.00
Modify  | 0.44475    | 0.44475    | 0.44475    |   0.0 |  0.23
Other   |            | 0.06661    |            |       |  0.03

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

Total # of neighbors = 135456
Ave neighs/atom = 67.728
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.466332720048, Press = 0.713287412692582
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -10425.198     -10425.198     -10510.39      -10510.39       329.7034       329.7034       28075.102      28075.102     -416.95931     -416.95931    
     68000  -10419.392     -10419.392     -10508.485     -10508.485      344.79977      344.79977      28064.653      28064.653      499.67041      499.67041    
Loop time of 197.205 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.779 hours/ns, 5.071 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.59     | 196.59     | 196.59     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10758    | 0.10758    | 0.10758    |   0.0 |  0.05
Output  | 0.00022427 | 0.00022427 | 0.00022427 |   0.0 |  0.00
Modify  | 0.43681    | 0.43681    | 0.43681    |   0.0 |  0.22
Other   |            | 0.06618    |            |       |  0.03

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

Total # of neighbors = 135412
Ave neighs/atom = 67.706
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.42689208288, Press = 0.424696107667424
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -10419.392     -10419.392     -10508.485     -10508.485      344.79977      344.79977      28064.653      28064.653      499.67041      499.67041    
     69000  -10426.277     -10426.277     -10511.522     -10511.522      329.90408      329.90408      28041.56       28041.56       1224.1176      1224.1176    
Loop time of 197.606 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.890 hours/ns, 5.061 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.98     | 196.98     | 196.98     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10875    | 0.10875    | 0.10875    |   0.0 |  0.06
Output  | 0.00048951 | 0.00048951 | 0.00048951 |   0.0 |  0.00
Modify  | 0.44752    | 0.44752    | 0.44752    |   0.0 |  0.23
Other   |            | 0.0672     |            |       |  0.03

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

Total # of neighbors = 135632
Ave neighs/atom = 67.816
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.408450924052, Press = 0.309523465044469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -10426.277     -10426.277     -10511.522     -10511.522      329.90408      329.90408      28041.56       28041.56       1224.1176      1224.1176    
     70000  -10421.797     -10421.797     -10506.327     -10506.327      327.13927      327.13927      28012.553      28012.553      3386.4039      3386.4039    
Loop time of 184.713 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.468 ns/day, 51.309 hours/ns, 5.414 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 184.14     | 184.14     | 184.14     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10217    | 0.10217    | 0.10217    |   0.0 |  0.06
Output  | 0.00017011 | 0.00017011 | 0.00017011 |   0.0 |  0.00
Modify  | 0.40995    | 0.40995    | 0.40995    |   0.0 |  0.22
Other   |            | 0.06336    |            |       |  0.03

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

Total # of neighbors = 135508
Ave neighs/atom = 67.754
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.352126387701, Press = 0.168477981959523
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -10421.797     -10421.797     -10506.327     -10506.327      327.13927      327.13927      28012.553      28012.553      3386.4039      3386.4039    
     71000  -10425.39      -10425.39      -10511.768     -10511.768      334.29021      334.29021      27976.481      27976.481      4803.3629      4803.3629    
Loop time of 169.259 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.016 hours/ns, 5.908 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.75     | 168.75     | 168.75     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093634   | 0.093634   | 0.093634   |   0.0 |  0.06
Output  | 0.00016906 | 0.00016906 | 0.00016906 |   0.0 |  0.00
Modify  | 0.35707    | 0.35707    | 0.35707    |   0.0 |  0.21
Other   |            | 0.05943    |            |       |  0.04

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:       136024 ave      136024 max      136024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 136024
Ave neighs/atom = 68.012
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.32805056955, Press = -0.629783727059891
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -10425.39      -10425.39      -10511.768     -10511.768      334.29021      334.29021      27976.481      27976.481      4803.3629      4803.3629    
     72000  -10420.824     -10420.824     -10507.49      -10507.49       335.4084       335.4084       28045.486      28045.486      1640.8986      1640.8986    
Loop time of 169.287 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.024 hours/ns, 5.907 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.78     | 168.78     | 168.78     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093443   | 0.093443   | 0.093443   |   0.0 |  0.06
Output  | 0.00021202 | 0.00021202 | 0.00021202 |   0.0 |  0.00
Modify  | 0.35833    | 0.35833    | 0.35833    |   0.0 |  0.21
Other   |            | 0.05916    |            |       |  0.03

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

Total # of neighbors = 136190
Ave neighs/atom = 68.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.301120653314, Press = -0.554806195250536
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -10420.824     -10420.824     -10507.49      -10507.49       335.4084       335.4084       28045.486      28045.486      1640.8986      1640.8986    
     73000  -10423.621     -10423.621     -10509.905     -10509.905      333.92842      333.92842      28061.825      28061.825      322.03138      322.03138    
Loop time of 168.658 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.849 hours/ns, 5.929 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.15     | 168.15     | 168.15     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093398   | 0.093398   | 0.093398   |   0.0 |  0.06
Output  | 0.00016939 | 0.00016939 | 0.00016939 |   0.0 |  0.00
Modify  | 0.35735    | 0.35735    | 0.35735    |   0.0 |  0.21
Other   |            | 0.05949    |            |       |  0.04

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:       135770 ave      135770 max      135770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135770
Ave neighs/atom = 67.885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.288123280803, Press = -0.589616819466736
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -10423.621     -10423.621     -10509.905     -10509.905      333.92842      333.92842      28061.825      28061.825      322.03138      322.03138    
     74000  -10420.239     -10420.239     -10509.763     -10509.763      346.4683       346.4683       28079.58       28079.58      -481.97883     -481.97883    
Loop time of 193.638 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.446 ns/day, 53.788 hours/ns, 5.164 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    | 193.04     | 193.04     | 193.04     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10563    | 0.10563    | 0.10563    |   0.0 |  0.05
Output  | 0.00017072 | 0.00017072 | 0.00017072 |   0.0 |  0.00
Modify  | 0.4273     | 0.4273     | 0.4273     |   0.0 |  0.22
Other   |            | 0.06423    |            |       |  0.03

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

Total # of neighbors = 135610
Ave neighs/atom = 67.805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.329150793447, Press = -0.787212985076996
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -10420.239     -10420.239     -10509.763     -10509.763      346.4683       346.4683       28079.58       28079.58      -481.97883     -481.97883    
     75000  -10424.903     -10424.903     -10508.765     -10508.765      324.55484      324.55484      28092.073      28092.073     -1212.8089     -1212.8089    
Loop time of 196.611 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.614 hours/ns, 5.086 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.99     | 195.99     | 195.99     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10827    | 0.10827    | 0.10827    |   0.0 |  0.06
Output  | 0.00017024 | 0.00017024 | 0.00017024 |   0.0 |  0.00
Modify  | 0.44589    | 0.44589    | 0.44589    |   0.0 |  0.23
Other   |            | 0.06642    |            |       |  0.03

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

Total # of neighbors = 135386
Ave neighs/atom = 67.693
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.321364564888, Press = -1.076454232849
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -10424.903     -10424.903     -10508.765     -10508.765      324.55484      324.55484      28092.073      28092.073     -1212.8089     -1212.8089    
     76000  -10422.941     -10422.941     -10508.45      -10508.45       330.92779      330.92779      28132.082      28132.082     -3281.9894     -3281.9894    
Loop time of 196.819 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.672 hours/ns, 5.081 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.2      | 196.2      | 196.2      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10858    | 0.10858    | 0.10858    |   0.0 |  0.06
Output  | 0.0002133  | 0.0002133  | 0.0002133  |   0.0 |  0.00
Modify  | 0.44613    | 0.44613    | 0.44613    |   0.0 |  0.23
Other   |            | 0.0668     |            |       |  0.03

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

Total # of neighbors = 135374
Ave neighs/atom = 67.687
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.302091969805, Press = -1.21211932565536
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -10422.941     -10422.941     -10508.45      -10508.45       330.92779      330.92779      28132.082      28132.082     -3281.9894     -3281.9894    
     77000  -10422.805     -10422.805     -10507.742     -10507.742      328.71556      328.71556      28099.461      28099.461     -1586.8121     -1586.8121    
Loop time of 196.971 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.714 hours/ns, 5.077 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.35     | 196.35     | 196.35     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1076     | 0.1076     | 0.1076     |   0.0 |  0.05
Output  | 0.00017047 | 0.00017047 | 0.00017047 |   0.0 |  0.00
Modify  | 0.44471    | 0.44471    | 0.44471    |   0.0 |  0.23
Other   |            | 0.06633    |            |       |  0.03

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

Total # of neighbors = 135258
Ave neighs/atom = 67.629
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.259171681848, Press = -0.302866903619603
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -10422.805     -10422.805     -10507.742     -10507.742      328.71556      328.71556      28099.461      28099.461     -1586.8121     -1586.8121    
     78000  -10421.79      -10421.79      -10507.1       -10507.1        330.15866      330.15866      28088.972      28088.972     -867.80078     -867.80078    
Loop time of 193.342 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.447 ns/day, 53.706 hours/ns, 5.172 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 192.73     | 192.73     | 192.73     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10694    | 0.10694    | 0.10694    |   0.0 |  0.06
Output  | 0.00021749 | 0.00021749 | 0.00021749 |   0.0 |  0.00
Modify  | 0.43752    | 0.43752    | 0.43752    |   0.0 |  0.23
Other   |            | 0.06536    |            |       |  0.03

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

Total # of neighbors = 135634
Ave neighs/atom = 67.817
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
28070.4990722213

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0