# 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 4.0419338792562485*${_u_distance}
variable latticeconst_converted equal 4.0419338792562485*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04193387925625
Lattice spacing in x,y,z = 4.0419339 4.0419339 4.0419339
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.419339 40.419339 40.419339)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (40.419339 40.419339 40.419339)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeLee_2010_FeAl__MO_332211522050_002
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_332211522050_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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.143 | 4.143 | 4.143 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13318.83      -13318.83      -13480.701     -13480.701      313.15         313.15         66034.001      66034.001      2618.3099      2618.3099    
      1000  -13128.104     -13128.104     -13296.721     -13296.721      326.20236      326.20236      67780.536      67780.536      232.89891      232.89891    
Loop time of 191.09 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.452 ns/day, 53.081 hours/ns, 5.233 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.18     | 190.18     | 190.18     |   0.0 | 99.52
Neigh   | 0.038183   | 0.038183   | 0.038183   |   0.0 |  0.02
Comm    | 0.10881    | 0.10881    | 0.10881    |   0.0 |  0.06
Output  | 0.00023914 | 0.00023914 | 0.00023914 |   0.0 |  0.00
Modify  | 0.67216    | 0.67216    | 0.67216    |   0.0 |  0.35
Other   |            | 0.092      |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4042 ave        4042 max        4042 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214018 ave      214018 max      214018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214018
Ave neighs/atom = 53.5045
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13128.104     -13128.104     -13296.721     -13296.721      326.20236      326.20236      67780.536      67780.536      232.89891      232.89891    
      2000  -13151.672     -13151.672     -13309.726     -13309.726      305.76561      305.76561      67763.672      67763.672     -713.98092     -713.98092    
Loop time of 202.216 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.171 hours/ns, 4.945 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    | 201.33     | 201.33     | 201.33     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11132    | 0.11132    | 0.11132    |   0.0 |  0.06
Output  | 0.00022735 | 0.00022735 | 0.00022735 |   0.0 |  0.00
Modify  | 0.67816    | 0.67816    | 0.67816    |   0.0 |  0.34
Other   |            | 0.09476    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4037 ave        4037 max        4037 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       213994 ave      213994 max      213994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213994
Ave neighs/atom = 53.4985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13151.672     -13151.672     -13309.726     -13309.726      305.76561      305.76561      67763.672      67763.672     -713.98092     -713.98092    
      3000  -13135.46      -13135.46      -13299.386     -13299.386      317.12582      317.12582      67789.878      67789.878     -222.76587     -222.76587    
Loop time of 202.491 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.247 hours/ns, 4.938 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    | 201.61     | 201.61     | 201.61     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11093    | 0.11093    | 0.11093    |   0.0 |  0.05
Output  | 0.00026948 | 0.00026948 | 0.00026948 |   0.0 |  0.00
Modify  | 0.67529    | 0.67529    | 0.67529    |   0.0 |  0.33
Other   |            | 0.09417    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4057 ave        4057 max        4057 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214424 ave      214424 max      214424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214424
Ave neighs/atom = 53.606
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13135.46      -13135.46      -13299.386     -13299.386      317.12582      317.12582      67789.878      67789.878     -222.76587     -222.76587    
      4000  -13148.457     -13148.457     -13306.537     -13306.537      305.81689      305.81689      67659.626      67659.626      679.06628      679.06628    
Loop time of 201.094 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.859 hours/ns, 4.973 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    | 200.22     | 200.22     | 200.22     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10863    | 0.10863    | 0.10863    |   0.0 |  0.05
Output  | 0.00023774 | 0.00023774 | 0.00023774 |   0.0 |  0.00
Modify  | 0.66682    | 0.66682    | 0.66682    |   0.0 |  0.33
Other   |            | 0.09432    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4020 ave        4020 max        4020 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214116 ave      214116 max      214116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214116
Ave neighs/atom = 53.529
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13148.457     -13148.457     -13306.537     -13306.537      305.81689      305.81689      67659.626      67659.626      679.06628      679.06628    
      5000  -13137.537     -13137.537     -13302.58      -13302.58       319.28715      319.28715      67706.071      67706.071      672.62406      672.62406    
Loop time of 203.814 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.615 hours/ns, 4.906 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    | 202.93     | 202.93     | 202.93     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10939    | 0.10939    | 0.10939    |   0.0 |  0.05
Output  | 0.00018782 | 0.00018782 | 0.00018782 |   0.0 |  0.00
Modify  | 0.6847     | 0.6847     | 0.6847     |   0.0 |  0.34
Other   |            | 0.09472    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4011 ave        4011 max        4011 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214328 ave      214328 max      214328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214328
Ave neighs/atom = 53.582
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 317.27945552556, Press = -100.325538592985
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13137.537     -13137.537     -13302.58      -13302.58       319.28715      319.28715      67706.071      67706.071      672.62406      672.62406    
      6000  -13146.507     -13146.507     -13306.705     -13306.705      309.91341      309.91341      67743.632      67743.632      19.75166       19.75166     
Loop time of 203.052 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.403 hours/ns, 4.925 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    | 202.15     | 202.15     | 202.15     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10984    | 0.10984    | 0.10984    |   0.0 |  0.05
Output  | 0.00030986 | 0.00030986 | 0.00030986 |   0.0 |  0.00
Modify  | 0.69802    | 0.69802    | 0.69802    |   0.0 |  0.34
Other   |            | 0.09377    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4056 ave        4056 max        4056 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214268 ave      214268 max      214268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214268
Ave neighs/atom = 53.567
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.120640358383, Press = -41.3245118139941
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13146.507     -13146.507     -13306.705     -13306.705      309.91341      309.91341      67743.632      67743.632      19.75166       19.75166     
      7000  -13140.914     -13140.914     -13300.75      -13300.75       309.21321      309.21321      67846.318      67846.318     -1049.7886     -1049.7886    
Loop time of 202.322 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.201 hours/ns, 4.943 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    | 201.42     | 201.42     | 201.42     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1097     | 0.1097     | 0.1097     |   0.0 |  0.05
Output  | 0.00018592 | 0.00018592 | 0.00018592 |   0.0 |  0.00
Modify  | 0.69816    | 0.69816    | 0.69816    |   0.0 |  0.35
Other   |            | 0.09286    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4025 ave        4025 max        4025 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214252 ave      214252 max      214252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214252
Ave neighs/atom = 53.563
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.340733103633, Press = -5.98784096448325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13140.914     -13140.914     -13300.75      -13300.75       309.21321      309.21321      67846.318      67846.318     -1049.7886     -1049.7886    
      8000  -13142.553     -13142.553     -13305.187     -13305.187      314.62535      314.62535      67785.412      67785.412     -452.27221     -452.27221    
Loop time of 200.899 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.805 hours/ns, 4.978 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    | 200        | 200        | 200        |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10956    | 0.10956    | 0.10956    |   0.0 |  0.05
Output  | 0.00025047 | 0.00025047 | 0.00025047 |   0.0 |  0.00
Modify  | 0.69459    | 0.69459    | 0.69459    |   0.0 |  0.35
Other   |            | 0.09376    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4037 ave        4037 max        4037 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214088 ave      214088 max      214088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214088
Ave neighs/atom = 53.522
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.155008499973, Press = 9.64142357378576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13142.553     -13142.553     -13305.187     -13305.187      314.62535      314.62535      67785.412      67785.412     -452.27221     -452.27221    
      9000  -13144.37      -13144.37      -13306.386     -13306.386      313.43141      313.43141      67669.808      67669.808      800.25613      800.25613    
Loop time of 201.967 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.102 hours/ns, 4.951 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    | 201.06     | 201.06     | 201.06     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10949    | 0.10949    | 0.10949    |   0.0 |  0.05
Output  | 0.00018597 | 0.00018597 | 0.00018597 |   0.0 |  0.00
Modify  | 0.70124    | 0.70124    | 0.70124    |   0.0 |  0.35
Other   |            | 0.09342    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4003 ave        4003 max        4003 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214232 ave      214232 max      214232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214232
Ave neighs/atom = 53.558
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.61818764751, Press = 1.71095859443624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13144.37      -13144.37      -13306.386     -13306.386      313.43141      313.43141      67669.808      67669.808      800.25613      800.25613    
     10000  -13144.762     -13144.762     -13306.42      -13306.42       312.73826      312.73826      67702.348      67702.348      240.93957      240.93957    
Loop time of 201.082 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.856 hours/ns, 4.973 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    | 200.18     | 200.18     | 200.18     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10971    | 0.10971    | 0.10971    |   0.0 |  0.05
Output  | 0.00018672 | 0.00018672 | 0.00018672 |   0.0 |  0.00
Modify  | 0.6949     | 0.6949     | 0.6949     |   0.0 |  0.35
Other   |            | 0.09389    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4024 ave        4024 max        4024 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214380 ave      214380 max      214380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214380
Ave neighs/atom = 53.595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.731003962057, Press = -5.75907144489672
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13144.762     -13144.762     -13306.42      -13306.42       312.73826      312.73826      67702.348      67702.348      240.93957      240.93957    
     11000  -13139.974     -13139.974     -13302.876     -13302.876      315.14557      315.14557      67832.976      67832.976     -823.5014      -823.5014     
Loop time of 203.712 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.587 hours/ns, 4.909 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    | 202.8      | 202.8      | 202.8      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11051    | 0.11051    | 0.11051    |   0.0 |  0.05
Output  | 0.00018817 | 0.00018817 | 0.00018817 |   0.0 |  0.00
Modify  | 0.70548    | 0.70548    | 0.70548    |   0.0 |  0.35
Other   |            | 0.0937     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4069 ave        4069 max        4069 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214404 ave      214404 max      214404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214404
Ave neighs/atom = 53.601
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.778771437016, Press = -6.22290390013623
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13139.974     -13139.974     -13302.876     -13302.876      315.14557      315.14557      67832.976      67832.976     -823.5014      -823.5014     
     12000  -13145.497     -13145.497     -13304.979     -13304.979      308.52855      308.52855      67788.784      67788.784     -596.27444     -596.27444    
Loop time of 200.12 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.589 hours/ns, 4.997 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    | 199.22     | 199.22     | 199.22     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10918    | 0.10918    | 0.10918    |   0.0 |  0.05
Output  | 0.00018639 | 0.00018639 | 0.00018639 |   0.0 |  0.00
Modify  | 0.69327    | 0.69327    | 0.69327    |   0.0 |  0.35
Other   |            | 0.09343    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4021 ave        4021 max        4021 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214116 ave      214116 max      214116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214116
Ave neighs/atom = 53.529
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.798973461777, Press = 3.60263070392736
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13145.497     -13145.497     -13304.979     -13304.979      308.52855      308.52855      67788.784      67788.784     -596.27444     -596.27444    
     13000  -13139.016     -13139.016     -13300.662     -13300.662      312.71679      312.71679      67700.412      67700.412      862.4883       862.4883     
Loop time of 201.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.880 hours/ns, 4.971 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    | 200.27     | 200.27     | 200.27     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10939    | 0.10939    | 0.10939    |   0.0 |  0.05
Output  | 0.00018753 | 0.00018753 | 0.00018753 |   0.0 |  0.00
Modify  | 0.69189    | 0.69189    | 0.69189    |   0.0 |  0.34
Other   |            | 0.09334    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4042 ave        4042 max        4042 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214212 ave      214212 max      214212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214212
Ave neighs/atom = 53.553
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.940420398873, Press = 0.369369874844101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13139.016     -13139.016     -13300.662     -13300.662      312.71679      312.71679      67700.412      67700.412      862.4883       862.4883     
     14000  -13143.947     -13143.947     -13307.019     -13307.019      315.47474      315.47474      67735.473      67735.473     -191.93586     -191.93586    
Loop time of 202.092 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.137 hours/ns, 4.948 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    | 201.19     | 201.19     | 201.19     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11014    | 0.11014    | 0.11014    |   0.0 |  0.05
Output  | 0.00038331 | 0.00038331 | 0.00038331 |   0.0 |  0.00
Modify  | 0.7012     | 0.7012     | 0.7012     |   0.0 |  0.35
Other   |            | 0.09504    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4023 ave        4023 max        4023 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214236 ave      214236 max      214236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214236
Ave neighs/atom = 53.559
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.958637448193, Press = -1.90934003035978
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13143.947     -13143.947     -13307.019     -13307.019      315.47474      315.47474      67735.473      67735.473     -191.93586     -191.93586    
     15000  -13143.153     -13143.153     -13305.272     -13305.272      313.63079      313.63079      67750.092      67750.092     -103.55459     -103.55459    
Loop time of 202.662 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.295 hours/ns, 4.934 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    | 201.76     | 201.76     | 201.76     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1103     | 0.1103     | 0.1103     |   0.0 |  0.05
Output  | 0.00030487 | 0.00030487 | 0.00030487 |   0.0 |  0.00
Modify  | 0.69951    | 0.69951    | 0.69951    |   0.0 |  0.35
Other   |            | 0.09363    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4047 ave        4047 max        4047 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214378 ave      214378 max      214378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214378
Ave neighs/atom = 53.5945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.987586958857, Press = 0.7709829420507
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13143.153     -13143.153     -13305.272     -13305.272      313.63079      313.63079      67750.092      67750.092     -103.55459     -103.55459    
     16000  -13141.469     -13141.469     -13303.922     -13303.922      314.27773      314.27773      67667.647      67667.647      814.81077      814.81077    
Loop time of 201.088 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.858 hours/ns, 4.973 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    | 200.19     | 200.19     | 200.19     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11095    | 0.11095    | 0.11095    |   0.0 |  0.06
Output  | 0.0003129  | 0.0003129  | 0.0003129  |   0.0 |  0.00
Modify  | 0.69083    | 0.69083    | 0.69083    |   0.0 |  0.34
Other   |            | 0.09336    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4102 ave        4102 max        4102 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214348 ave      214348 max      214348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214348
Ave neighs/atom = 53.587
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.757083080165, Press = -0.0639066739105581
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13141.469     -13141.469     -13303.922     -13303.922      314.27773      314.27773      67667.647      67667.647      814.81077      814.81077    
     17000  -13145.421     -13145.421     -13306.263     -13306.263      311.1603       311.1603       67695.256      67695.256      295.67201      295.67201    
Loop time of 202.483 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.245 hours/ns, 4.939 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    | 201.58     | 201.58     | 201.58     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11029    | 0.11029    | 0.11029    |   0.0 |  0.05
Output  | 0.00018814 | 0.00018814 | 0.00018814 |   0.0 |  0.00
Modify  | 0.70091    | 0.70091    | 0.70091    |   0.0 |  0.35
Other   |            | 0.09318    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4026 ave        4026 max        4026 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214302 ave      214302 max      214302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214302
Ave neighs/atom = 53.5755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.658694050772, Press = -5.16766527165428
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13145.421     -13145.421     -13306.263     -13306.263      311.1603       311.1603       67695.256      67695.256      295.67201      295.67201    
     18000  -13141.976     -13141.976     -13300.353     -13300.353      306.38949      306.38949      67837.809      67837.809     -995.83957     -995.83957    
Loop time of 201.747 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.041 hours/ns, 4.957 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    | 200.85     | 200.85     | 200.85     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11006    | 0.11006    | 0.11006    |   0.0 |  0.05
Output  | 0.00018765 | 0.00018765 | 0.00018765 |   0.0 |  0.00
Modify  | 0.69559    | 0.69559    | 0.69559    |   0.0 |  0.34
Other   |            | 0.09368    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4042 ave        4042 max        4042 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214370 ave      214370 max      214370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214370
Ave neighs/atom = 53.5925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.719721408064, Press = -0.862363114032676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13141.976     -13141.976     -13300.353     -13300.353      306.38949      306.38949      67837.809      67837.809     -995.83957     -995.83957    
     19000  -13144.738     -13144.738     -13307.836     -13307.836      315.52403      315.52403      67759.467      67759.467     -311.13559     -311.13559    
Loop time of 201.157 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.877 hours/ns, 4.971 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    | 200.26     | 200.26     | 200.26     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10971    | 0.10971    | 0.10971    |   0.0 |  0.05
Output  | 0.00018795 | 0.00018795 | 0.00018795 |   0.0 |  0.00
Modify  | 0.68887    | 0.68887    | 0.68887    |   0.0 |  0.34
Other   |            | 0.09313    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4022 ave        4022 max        4022 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214164 ave      214164 max      214164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214164
Ave neighs/atom = 53.541
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.664211306238, Press = 0.535136880373869
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13144.738     -13144.738     -13307.836     -13307.836      315.52403      315.52403      67759.467      67759.467     -311.13559     -311.13559    
     20000  -13144.062     -13144.062     -13305.287     -13305.287      311.90168      311.90168      67737.183      67737.183      244.43573      244.43573    
Loop time of 202.645 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.290 hours/ns, 4.935 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    | 201.74     | 201.74     | 201.74     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11052    | 0.11052    | 0.11052    |   0.0 |  0.05
Output  | 0.00018802 | 0.00018802 | 0.00018802 |   0.0 |  0.00
Modify  | 0.70013    | 0.70013    | 0.70013    |   0.0 |  0.35
Other   |            | 0.09455    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4050 ave        4050 max        4050 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214400 ave      214400 max      214400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214400
Ave neighs/atom = 53.6
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.703236572055, Press = -0.470961962144264
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13144.062     -13144.062     -13305.287     -13305.287      311.90168      311.90168      67737.183      67737.183      244.43573      244.43573    
     21000  -13144.595     -13144.595     -13307.532     -13307.532      315.21225      315.21225      67700.878      67700.878      229.04938      229.04938    
Loop time of 201.015 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.837 hours/ns, 4.975 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    | 200.12     | 200.12     | 200.12     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10793    | 0.10793    | 0.10793    |   0.0 |  0.05
Output  | 0.00024346 | 0.00024346 | 0.00024346 |   0.0 |  0.00
Modify  | 0.6939     | 0.6939     | 0.6939     |   0.0 |  0.35
Other   |            | 0.09279    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4030 ave        4030 max        4030 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214368 ave      214368 max      214368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214368
Ave neighs/atom = 53.592
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.738299530781, Press = -1.21543722467142
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13144.595     -13144.595     -13307.532     -13307.532      315.21225      315.21225      67700.878      67700.878      229.04938      229.04938    
     22000  -13134.777     -13134.777     -13300.496     -13300.496      320.59615      320.59615      67878.666      67878.666     -973.31555     -973.31555    
Loop time of 201.514 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.976 hours/ns, 4.962 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    | 200.61     | 200.61     | 200.61     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10933    | 0.10933    | 0.10933    |   0.0 |  0.05
Output  | 0.0001857  | 0.0001857  | 0.0001857  |   0.0 |  0.00
Modify  | 0.6972     | 0.6972     | 0.6972     |   0.0 |  0.35
Other   |            | 0.09399    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4036 ave        4036 max        4036 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214442 ave      214442 max      214442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214442
Ave neighs/atom = 53.6105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.782352944336, Press = -1.57931474656651
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13134.777     -13134.777     -13300.496     -13300.496      320.59615      320.59615      67878.666      67878.666     -973.31555     -973.31555    
     23000  -13143.795     -13143.795     -13300.556     -13300.556      303.26426      303.26426      67772.243      67772.243      170.59654      170.59654    
Loop time of 201.531 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.981 hours/ns, 4.962 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    | 200.63     | 200.63     | 200.63     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10886    | 0.10886    | 0.10886    |   0.0 |  0.05
Output  | 0.00018597 | 0.00018597 | 0.00018597 |   0.0 |  0.00
Modify  | 0.69941    | 0.69941    | 0.69941    |   0.0 |  0.35
Other   |            | 0.09321    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4037 ave        4037 max        4037 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214058 ave      214058 max      214058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214058
Ave neighs/atom = 53.5145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.799489234562, Press = 0.859516924320457
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13143.795     -13143.795     -13300.556     -13300.556      303.26426      303.26426      67772.243      67772.243      170.59654      170.59654    
     24000  -13138.645     -13138.645     -13302.157     -13302.157      316.32364      316.32364      67708.637      67708.637      575.72901      575.72901    
Loop time of 202.37 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.214 hours/ns, 4.941 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    | 201.46     | 201.46     | 201.46     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11014    | 0.11014    | 0.11014    |   0.0 |  0.05
Output  | 0.00018776 | 0.00018776 | 0.00018776 |   0.0 |  0.00
Modify  | 0.69975    | 0.69975    | 0.69975    |   0.0 |  0.35
Other   |            | 0.09462    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4063 ave        4063 max        4063 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214132 ave      214132 max      214132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214132
Ave neighs/atom = 53.533
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.858393110115, Press = 1.0525104571231
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13138.645     -13138.645     -13302.157     -13302.157      316.32364      316.32364      67708.637      67708.637      575.72901      575.72901    
     25000  -13140.102     -13140.102     -13302.691     -13302.691      314.53895      314.53895      67673.205      67673.205      933.86209      933.86209    
Loop time of 202.099 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.139 hours/ns, 4.948 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    | 201.2      | 201.2      | 201.2      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10916    | 0.10916    | 0.10916    |   0.0 |  0.05
Output  | 0.00022966 | 0.00022966 | 0.00022966 |   0.0 |  0.00
Modify  | 0.6985     | 0.6985     | 0.6985     |   0.0 |  0.35
Other   |            | 0.09452    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4066 ave        4066 max        4066 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214214 ave      214214 max      214214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214214
Ave neighs/atom = 53.5535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.794579388334, Press = -0.507076755425085
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13140.102     -13140.102     -13302.691     -13302.691      314.53895      314.53895      67673.205      67673.205      933.86209      933.86209    
     26000  -13147.856     -13147.856     -13305.082     -13305.082      304.16412      304.16412      67715.881      67715.881      276.58902      276.58902    
Loop time of 202.924 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.368 hours/ns, 4.928 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    | 202.02     | 202.02     | 202.02     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10969    | 0.10969    | 0.10969    |   0.0 |  0.05
Output  | 0.00018552 | 0.00018552 | 0.00018552 |   0.0 |  0.00
Modify  | 0.70138    | 0.70138    | 0.70138    |   0.0 |  0.35
Other   |            | 0.09381    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4067 ave        4067 max        4067 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214372 ave      214372 max      214372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214372
Ave neighs/atom = 53.593
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.697181756001, Press = -1.66566707581511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13147.856     -13147.856     -13305.082     -13305.082      304.16412      304.16412      67715.881      67715.881      276.58902      276.58902    
     27000  -13140.318     -13140.318     -13303.989     -13303.989      316.63399      316.63399      67770.58       67770.58      -353.23237     -353.23237    
Loop time of 204.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.673 hours/ns, 4.901 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    | 203.11     | 203.11     | 203.11     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11031    | 0.11031    | 0.11031    |   0.0 |  0.05
Output  | 0.00018643 | 0.00018643 | 0.00018643 |   0.0 |  0.00
Modify  | 0.70658    | 0.70658    | 0.70658    |   0.0 |  0.35
Other   |            | 0.09366    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4032 ave        4032 max        4032 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214358 ave      214358 max      214358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214358
Ave neighs/atom = 53.5895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.610133549461, Press = -0.125774535090693
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13140.318     -13140.318     -13303.989     -13303.989      316.63399      316.63399      67770.58       67770.58      -353.23237     -353.23237    
     28000  -13147.778     -13147.778     -13308.014     -13308.014      309.98714      309.98714      67687.816      67687.816      373.53335      373.53335    
Loop time of 201.502 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.973 hours/ns, 4.963 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    | 200.6      | 200.6      | 200.6      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10928    | 0.10928    | 0.10928    |   0.0 |  0.05
Output  | 0.00018792 | 0.00018792 | 0.00018792 |   0.0 |  0.00
Modify  | 0.69734    | 0.69734    | 0.69734    |   0.0 |  0.35
Other   |            | 0.09362    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4035 ave        4035 max        4035 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214272 ave      214272 max      214272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214272
Ave neighs/atom = 53.568
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.552066861784, Press = -0.356403600194039
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13147.778     -13147.778     -13308.014     -13308.014      309.98714      309.98714      67687.816      67687.816      373.53335      373.53335    
     29000  -13142.362     -13142.362     -13305.117     -13305.117      314.86109      314.86109      67621.399      67621.399      1511.6227      1511.6227    
Loop time of 201.155 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.876 hours/ns, 4.971 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    | 200.26     | 200.26     | 200.26     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10936    | 0.10936    | 0.10936    |   0.0 |  0.05
Output  | 0.00018974 | 0.00018974 | 0.00018974 |   0.0 |  0.00
Modify  | 0.69029    | 0.69029    | 0.69029    |   0.0 |  0.34
Other   |            | 0.09285    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4033 ave        4033 max        4033 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214400 ave      214400 max      214400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214400
Ave neighs/atom = 53.6
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.562573633792, Press = -0.047843136133751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13142.362     -13142.362     -13305.117     -13305.117      314.86109      314.86109      67621.399      67621.399      1511.6227      1511.6227    
     30000  -13143.756     -13143.756     -13307.099     -13307.099      315.99896      315.99896      67738.886      67738.886     -224.29586     -224.29586    
Loop time of 201.962 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.101 hours/ns, 4.951 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    | 201.06     | 201.06     | 201.06     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10831    | 0.10831    | 0.10831    |   0.0 |  0.05
Output  | 0.00018661 | 0.00018661 | 0.00018661 |   0.0 |  0.00
Modify  | 0.69916    | 0.69916    | 0.69916    |   0.0 |  0.35
Other   |            | 0.09335    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4004 ave        4004 max        4004 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214452 ave      214452 max      214452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214452
Ave neighs/atom = 53.613
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.58189732197, Press = -2.5843364841546
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13143.756     -13143.756     -13307.099     -13307.099      315.99896      315.99896      67738.886      67738.886     -224.29586     -224.29586    
     31000  -13137.273     -13137.273     -13300.846     -13300.846      316.44237      316.44237      67863.444      67863.444     -1268.0238     -1268.0238    
Loop time of 201.502 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.973 hours/ns, 4.963 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    | 200.6      | 200.6      | 200.6      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10972    | 0.10972    | 0.10972    |   0.0 |  0.05
Output  | 0.00022615 | 0.00022615 | 0.00022615 |   0.0 |  0.00
Modify  | 0.69614    | 0.69614    | 0.69614    |   0.0 |  0.35
Other   |            | 0.09335    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4081 ave        4081 max        4081 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214232 ave      214232 max      214232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214232
Ave neighs/atom = 53.558
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.648998630826, Press = -0.638828112278018
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13137.273     -13137.273     -13300.846     -13300.846      316.44237      316.44237      67863.444      67863.444     -1268.0238     -1268.0238    
     32000  -13140.224     -13140.224     -13303.756     -13303.756      316.36492      316.36492      67765.724      67765.724     -369.3209      -369.3209     
Loop time of 202.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.188 hours/ns, 4.944 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    | 201.37     | 201.37     | 201.37     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11063    | 0.11063    | 0.11063    |   0.0 |  0.05
Output  | 0.00018663 | 0.00018663 | 0.00018663 |   0.0 |  0.00
Modify  | 0.69976    | 0.69976    | 0.69976    |   0.0 |  0.35
Other   |            | 0.09453    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4053 ave        4053 max        4053 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214068 ave      214068 max      214068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214068
Ave neighs/atom = 53.517
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.630475566878, Press = 0.898327596226557
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13140.224     -13140.224     -13303.756     -13303.756      316.36492      316.36492      67765.724      67765.724     -369.3209      -369.3209     
     33000  -13147.274     -13147.274     -13307.486     -13307.486      309.94091      309.94091      67622.478      67622.478      1179.0702      1179.0702    
Loop time of 202.501 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.250 hours/ns, 4.938 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    | 201.6      | 201.6      | 201.6      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10925    | 0.10925    | 0.10925    |   0.0 |  0.05
Output  | 0.00018848 | 0.00018848 | 0.00018848 |   0.0 |  0.00
Modify  | 0.70096    | 0.70096    | 0.70096    |   0.0 |  0.35
Other   |            | 0.09432    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4040 ave        4040 max        4040 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214160 ave      214160 max      214160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214160
Ave neighs/atom = 53.54
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.585656554205, Press = 0.0599492559929396
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13147.274     -13147.274     -13307.486     -13307.486      309.94091      309.94091      67622.478      67622.478      1179.0702      1179.0702    
     34000  -13143.985     -13143.985     -13303.927     -13303.927      309.42008      309.42008      67763.926      67763.926     -333.81819     -333.81819    
Loop time of 201.576 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.993 hours/ns, 4.961 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    | 200.67     | 200.67     | 200.67     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11042    | 0.11042    | 0.11042    |   0.0 |  0.05
Output  | 0.0002303  | 0.0002303  | 0.0002303  |   0.0 |  0.00
Modify  | 0.69757    | 0.69757    | 0.69757    |   0.0 |  0.35
Other   |            | 0.09379    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4092 ave        4092 max        4092 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214344 ave      214344 max      214344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214344
Ave neighs/atom = 53.586
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.594862420423, Press = -1.09443905473663
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13143.985     -13143.985     -13303.927     -13303.927      309.42008      309.42008      67763.926      67763.926     -333.81819     -333.81819    
     35000  -13139.798     -13139.798     -13302.428     -13302.428      314.61827      314.61827      67826.593      67826.593     -748.77749     -748.77749    
Loop time of 201.928 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.091 hours/ns, 4.952 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    | 201.03     | 201.03     | 201.03     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10891    | 0.10891    | 0.10891    |   0.0 |  0.05
Output  | 0.0001881  | 0.0001881  | 0.0001881  |   0.0 |  0.00
Modify  | 0.69548    | 0.69548    | 0.69548    |   0.0 |  0.34
Other   |            | 0.0939     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4020 ave        4020 max        4020 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214292 ave      214292 max      214292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214292
Ave neighs/atom = 53.573
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.648561216927, Press = -0.399032757846283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13139.798     -13139.798     -13302.428     -13302.428      314.61827      314.61827      67826.593      67826.593     -748.77749     -748.77749    
     36000  -13140.115     -13140.115     -13303.57      -13303.57       316.21519      316.21519      67788.491      67788.491     -344.24165     -344.24165    
Loop time of 200.834 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.787 hours/ns, 4.979 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    | 199.94     | 199.94     | 199.94     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10832    | 0.10832    | 0.10832    |   0.0 |  0.05
Output  | 0.00018635 | 0.00018635 | 0.00018635 |   0.0 |  0.00
Modify  | 0.69221    | 0.69221    | 0.69221    |   0.0 |  0.34
Other   |            | 0.0935     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4037 ave        4037 max        4037 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214220 ave      214220 max      214220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214220
Ave neighs/atom = 53.555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.642051102193, Press = 1.33975600661393
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13140.115     -13140.115     -13303.57      -13303.57       316.21519      316.21519      67788.491      67788.491     -344.24165     -344.24165    
     37000  -13143.541     -13143.541     -13307.535     -13307.535      317.25912      317.25912      67650.642      67650.642      1036.3714      1036.3714    
Loop time of 201.501 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.972 hours/ns, 4.963 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    | 200.6      | 200.6      | 200.6      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10952    | 0.10952    | 0.10952    |   0.0 |  0.05
Output  | 0.00023437 | 0.00023437 | 0.00023437 |   0.0 |  0.00
Modify  | 0.69387    | 0.69387    | 0.69387    |   0.0 |  0.34
Other   |            | 0.09331    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4030 ave        4030 max        4030 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214130 ave      214130 max      214130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214130
Ave neighs/atom = 53.5325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.667399212581, Press = 0.000962886633266251
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13143.541     -13143.541     -13307.535     -13307.535      317.25912      317.25912      67650.642      67650.642      1036.3714      1036.3714    
     38000  -13136.522     -13136.522     -13298.846     -13298.846      314.02729      314.02729      67809.805      67809.805     -509.03771     -509.03771    
Loop time of 201.608 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 56.002 hours/ns, 4.960 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    | 200.7      | 200.7      | 200.7      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11009    | 0.11009    | 0.11009    |   0.0 |  0.05
Output  | 0.0001852  | 0.0001852  | 0.0001852  |   0.0 |  0.00
Modify  | 0.70085    | 0.70085    | 0.70085    |   0.0 |  0.35
Other   |            | 0.09484    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4091 ave        4091 max        4091 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214454 ave      214454 max      214454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214454
Ave neighs/atom = 53.6135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.696198257636, Press = -0.855954884656924
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13136.522     -13136.522     -13298.846     -13298.846      314.02729      314.02729      67809.805      67809.805     -509.03771     -509.03771    
     39000  -13144.419     -13144.419     -13306.327     -13306.327      313.22242      313.22242      67813.43       67813.43      -839.90244     -839.90244    
Loop time of 202.289 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.191 hours/ns, 4.943 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    | 201.38     | 201.38     | 201.38     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11008    | 0.11008    | 0.11008    |   0.0 |  0.05
Output  | 0.00018666 | 0.00018666 | 0.00018666 |   0.0 |  0.00
Modify  | 0.701      | 0.701      | 0.701      |   0.0 |  0.35
Other   |            | 0.09317    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4074 ave        4074 max        4074 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214036 ave      214036 max      214036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214036
Ave neighs/atom = 53.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.699692517631, Press = 0.0453469414080335
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13144.419     -13144.419     -13306.327     -13306.327      313.22242      313.22242      67813.43       67813.43      -839.90244     -839.90244    
     40000  -13140.661     -13140.661     -13300.58      -13300.58       309.37469      309.37469      67752.805      67752.805      42.705068      42.705068    
Loop time of 201.324 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.923 hours/ns, 4.967 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    | 200.43     | 200.43     | 200.43     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10832    | 0.10832    | 0.10832    |   0.0 |  0.05
Output  | 0.0001864  | 0.0001864  | 0.0001864  |   0.0 |  0.00
Modify  | 0.69288    | 0.69288    | 0.69288    |   0.0 |  0.34
Other   |            | 0.09445    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4001 ave        4001 max        4001 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214150 ave      214150 max      214150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214150
Ave neighs/atom = 53.5375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.703720230527, Press = 0.624396551143504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13140.661     -13140.661     -13300.58      -13300.58       309.37469      309.37469      67752.805      67752.805      42.705068      42.705068    
     41000  -13143.996     -13143.996     -13304.467     -13304.467      310.44338      310.44338      67681.823      67681.823      735.65873      735.65873    
Loop time of 201.221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.895 hours/ns, 4.970 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    | 200.32     | 200.32     | 200.32     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11047    | 0.11047    | 0.11047    |   0.0 |  0.05
Output  | 0.00030017 | 0.00030017 | 0.00030017 |   0.0 |  0.00
Modify  | 0.69661    | 0.69661    | 0.69661    |   0.0 |  0.35
Other   |            | 0.09304    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4029 ave        4029 max        4029 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214192 ave      214192 max      214192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214192
Ave neighs/atom = 53.548
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.681664012869, Press = 0.298685198193283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13143.996     -13143.996     -13304.467     -13304.467      310.44338      310.44338      67681.823      67681.823      735.65873      735.65873    
     42000  -13138.669     -13138.669     -13303.853     -13303.853      319.56004      319.56004      67710.708      67710.708      377.96595      377.96595    
Loop time of 202.182 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.162 hours/ns, 4.946 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    | 201.28     | 201.28     | 201.28     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1091     | 0.1091     | 0.1091     |   0.0 |  0.05
Output  | 0.00018778 | 0.00018778 | 0.00018778 |   0.0 |  0.00
Modify  | 0.69384    | 0.69384    | 0.69384    |   0.0 |  0.34
Other   |            | 0.09416    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4065 ave        4065 max        4065 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214384 ave      214384 max      214384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214384
Ave neighs/atom = 53.596
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.660174214358, Press = -0.523047561011674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13138.669     -13138.669     -13303.853     -13303.853      319.56004      319.56004      67710.708      67710.708      377.96595      377.96595    
     43000  -13142.323     -13142.323     -13301.251     -13301.251      307.45558      307.45558      67819.146      67819.146     -809.67667     -809.67667    
Loop time of 202.097 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.138 hours/ns, 4.948 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    | 201.19     | 201.19     | 201.19     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11005    | 0.11005    | 0.11005    |   0.0 |  0.05
Output  | 0.00018875 | 0.00018875 | 0.00018875 |   0.0 |  0.00
Modify  | 0.70046    | 0.70046    | 0.70046    |   0.0 |  0.35
Other   |            | 0.09411    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4017 ave        4017 max        4017 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214246 ave      214246 max      214246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214246
Ave neighs/atom = 53.5615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.621157992648, Press = -1.10772117601902
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13142.323     -13142.323     -13301.251     -13301.251      307.45558      307.45558      67819.146      67819.146     -809.67667     -809.67667    
     44000  -13139.759     -13139.759     -13303.082     -13303.082      315.95987      315.95987      67807.584      67807.584     -674.25017     -674.25017    
Loop time of 200.629 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.730 hours/ns, 4.984 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    | 199.73     | 199.73     | 199.73     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1158     | 0.1158     | 0.1158     |   0.0 |  0.06
Output  | 0.00023475 | 0.00023475 | 0.00023475 |   0.0 |  0.00
Modify  | 0.69167    | 0.69167    | 0.69167    |   0.0 |  0.34
Other   |            | 0.09388    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4039 ave        4039 max        4039 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214094 ave      214094 max      214094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214094
Ave neighs/atom = 53.5235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.572445552236, Press = 0.17071191897587
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13139.759     -13139.759     -13303.082     -13303.082      315.95987      315.95987      67807.584      67807.584     -674.25017     -674.25017    
     45000  -13144.542     -13144.542     -13305.2       -13305.2        310.80441      310.80441      67707.028      67707.028      467.28752      467.28752    
Loop time of 200.841 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.789 hours/ns, 4.979 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    | 199.95     | 199.95     | 199.95     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10831    | 0.10831    | 0.10831    |   0.0 |  0.05
Output  | 0.00019957 | 0.00019957 | 0.00019957 |   0.0 |  0.00
Modify  | 0.69018    | 0.69018    | 0.69018    |   0.0 |  0.34
Other   |            | 0.0934     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4026 ave        4026 max        4026 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214206 ave      214206 max      214206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214206
Ave neighs/atom = 53.5515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.559705202602, Press = 0.462532765090802
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13144.542     -13144.542     -13305.2       -13305.2        310.80441      310.80441      67707.028      67707.028      467.28752      467.28752    
     46000  -13141.567     -13141.567     -13304.724     -13304.724      315.63732      315.63732      67718.848      67718.848      233.13831      233.13831    
Loop time of 201.829 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.064 hours/ns, 4.955 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    | 200.93     | 200.93     | 200.93     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1105     | 0.1105     | 0.1105     |   0.0 |  0.05
Output  | 0.00019288 | 0.00019288 | 0.00019288 |   0.0 |  0.00
Modify  | 0.6961     | 0.6961     | 0.6961     |   0.0 |  0.34
Other   |            | 0.09431    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4085 ave        4085 max        4085 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214274 ave      214274 max      214274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214274
Ave neighs/atom = 53.5685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.579959310358, Press = 0.773034541866665
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13141.567     -13141.567     -13304.724     -13304.724      315.63732      315.63732      67718.848      67718.848      233.13831      233.13831    
     47000  -13140.252     -13140.252     -13304.551     -13304.551      317.84738      317.84738      67629.869      67629.869      1338.9635      1338.9635    
Loop time of 201.623 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 56.006 hours/ns, 4.960 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    | 200.72     | 200.72     | 200.72     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10951    | 0.10951    | 0.10951    |   0.0 |  0.05
Output  | 0.00018571 | 0.00018571 | 0.00018571 |   0.0 |  0.00
Modify  | 0.69512    | 0.69512    | 0.69512    |   0.0 |  0.34
Other   |            | 0.09346    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4060 ave        4060 max        4060 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214286 ave      214286 max      214286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214286
Ave neighs/atom = 53.5715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.575010180272, Press = 0.256256018829887
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13140.252     -13140.252     -13304.551     -13304.551      317.84738      317.84738      67629.869      67629.869      1338.9635      1338.9635    
     48000  -13141.574     -13141.574     -13306.621     -13306.621      319.2959       319.2959       67775.279      67775.279     -363.30684     -363.30684    
Loop time of 200.892 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.803 hours/ns, 4.978 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    | 200        | 200        | 200        |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10749    | 0.10749    | 0.10749    |   0.0 |  0.05
Output  | 0.00018688 | 0.00018688 | 0.00018688 |   0.0 |  0.00
Modify  | 0.68859    | 0.68859    | 0.68859    |   0.0 |  0.34
Other   |            | 0.0934     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3980 ave        3980 max        3980 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214248 ave      214248 max      214248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214248
Ave neighs/atom = 53.562
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.607847363918, Press = -0.817024392358921
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13141.574     -13141.574     -13306.621     -13306.621      319.2959       319.2959       67775.279      67775.279     -363.30684     -363.30684    
     49000  -13144.276     -13144.276     -13305.662     -13305.662      312.21258      312.21258      67822.686      67822.686     -1062.7636     -1062.7636    
Loop time of 201.369 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.936 hours/ns, 4.966 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    | 200.47     | 200.47     | 200.47     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11025    | 0.11025    | 0.11025    |   0.0 |  0.05
Output  | 0.00023913 | 0.00023913 | 0.00023913 |   0.0 |  0.00
Modify  | 0.69722    | 0.69722    | 0.69722    |   0.0 |  0.35
Other   |            | 0.09434    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4110 ave        4110 max        4110 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214264 ave      214264 max      214264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214264
Ave neighs/atom = 53.566
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.62787953483, Press = 0.246633834668791
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13144.276     -13144.276     -13305.662     -13305.662      312.21258      312.21258      67822.686      67822.686     -1062.7636     -1062.7636    
     50000  -13141.229     -13141.229     -13299.964     -13299.964      307.08473      307.08473      67711.112      67711.112      594.66181      594.66181    
Loop time of 203.684 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.579 hours/ns, 4.910 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    | 202.77     | 202.77     | 202.77     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11034    | 0.11034    | 0.11034    |   0.0 |  0.05
Output  | 0.00018908 | 0.00018908 | 0.00018908 |   0.0 |  0.00
Modify  | 0.7109     | 0.7109     | 0.7109     |   0.0 |  0.35
Other   |            | 0.09456    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4057 ave        4057 max        4057 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214176 ave      214176 max      214176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214176
Ave neighs/atom = 53.544
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.63234419032, Press = -0.15697801113369
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13141.229     -13141.229     -13299.964     -13299.964      307.08473      307.08473      67711.112      67711.112      594.66181      594.66181    
     51000  -13142.723     -13142.723     -13305.27      -13305.27       314.4581       314.4581       67757.285      67757.285     -342.13911     -342.13911    
Loop time of 201.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.990 hours/ns, 4.961 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    | 200.67     | 200.67     | 200.67     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10862    | 0.10862    | 0.10862    |   0.0 |  0.05
Output  | 0.00018627 | 0.00018627 | 0.00018627 |   0.0 |  0.00
Modify  | 0.69283    | 0.69283    | 0.69283    |   0.0 |  0.34
Other   |            | 0.09454    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4034 ave        4034 max        4034 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214168 ave      214168 max      214168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214168
Ave neighs/atom = 53.542
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.614615419796, Press = -0.0308258873431773
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.146 | 4.146 | 4.146 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13142.723     -13142.723     -13305.27      -13305.27       314.4581       314.4581       67757.285      67757.285     -342.13911     -342.13911    
     52000  -13137.885     -13137.885     -13299.742     -13299.742      313.12278      313.12278      67769.625      67769.625     -82.076377     -82.076377    
Loop time of 204.244 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.735 hours/ns, 4.896 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    | 203.33     | 203.33     | 203.33     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11244    | 0.11244    | 0.11244    |   0.0 |  0.06
Output  | 0.00045747 | 0.00045747 | 0.00045747 |   0.0 |  0.00
Modify  | 0.70937    | 0.70937    | 0.70937    |   0.0 |  0.35
Other   |            | 0.09595    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214198 ave      214198 max      214198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214198
Ave neighs/atom = 53.5495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.638043826253, Press = 0.14089087793837
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13137.885     -13137.885     -13299.742     -13299.742      313.12278      313.12278      67769.625      67769.625     -82.076377     -82.076377    
     53000  -13142.573     -13142.573     -13304.89      -13304.89       314.01462      314.01462      67714.377      67714.377      247.71937      247.71937    
Loop time of 203.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.650 hours/ns, 4.903 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    | 203.03     | 203.03     | 203.03     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10919    | 0.10919    | 0.10919    |   0.0 |  0.05
Output  | 0.00018804 | 0.00018804 | 0.00018804 |   0.0 |  0.00
Modify  | 0.70699    | 0.70699    | 0.70699    |   0.0 |  0.35
Other   |            | 0.09431    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3994 ave        3994 max        3994 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214124 ave      214124 max      214124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214124
Ave neighs/atom = 53.531
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.648017570334, Press = -0.271139087001721
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13142.573     -13142.573     -13304.89      -13304.89       314.01462      314.01462      67714.377      67714.377      247.71937      247.71937    
     54000  -13137.488     -13137.488     -13299.694     -13299.694      313.79681      313.79681      67819.359      67819.359     -711.64807     -711.64807    
Loop time of 203.283 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.468 hours/ns, 4.919 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    | 202.37     | 202.37     | 202.37     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10979    | 0.10979    | 0.10979    |   0.0 |  0.05
Output  | 0.00018887 | 0.00018887 | 0.00018887 |   0.0 |  0.00
Modify  | 0.70481    | 0.70481    | 0.70481    |   0.0 |  0.35
Other   |            | 0.09534    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4058 ave        4058 max        4058 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214258 ave      214258 max      214258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214258
Ave neighs/atom = 53.5645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.677282610144, Press = -0.672297636795039
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13137.488     -13137.488     -13299.694     -13299.694      313.79681      313.79681      67819.359      67819.359     -711.64807     -711.64807    
     55000  -13145.037     -13145.037     -13304.936     -13304.936      309.33415      309.33415      67837.32       67837.32      -1199.8403     -1199.8403    
Loop time of 205.398 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.055 hours/ns, 4.869 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    | 204.48     | 204.48     | 204.48     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11054    | 0.11054    | 0.11054    |   0.0 |  0.05
Output  | 0.00018729 | 0.00018729 | 0.00018729 |   0.0 |  0.00
Modify  | 0.71649    | 0.71649    | 0.71649    |   0.0 |  0.35
Other   |            | 0.09477    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4068 ave        4068 max        4068 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214028 ave      214028 max      214028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214028
Ave neighs/atom = 53.507
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.685120658643, Press = 0.122320147074182
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13145.037     -13145.037     -13304.936     -13304.936      309.33415      309.33415      67837.32       67837.32      -1199.8403     -1199.8403    
     56000  -13135.76      -13135.76      -13302.116     -13302.116      321.82693      321.82693      67736.164      67736.164      406.62412      406.62412    
Loop time of 202.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.385 hours/ns, 4.926 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    | 202.08     | 202.08     | 202.08     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1092     | 0.1092     | 0.1092     |   0.0 |  0.05
Output  | 0.00018561 | 0.00018561 | 0.00018561 |   0.0 |  0.00
Modify  | 0.70175    | 0.70175    | 0.70175    |   0.0 |  0.35
Other   |            | 0.0946     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4005 ave        4005 max        4005 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214232 ave      214232 max      214232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214232
Ave neighs/atom = 53.558
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.707551035026, Press = 0.641003562750562
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13135.76      -13135.76      -13302.116     -13302.116      321.82693      321.82693      67736.164      67736.164      406.62412      406.62412    
     57000  -13143.814     -13143.814     -13305.974     -13305.974      313.70995      313.70995      67673.828      67673.828      699.06747      699.06747    
Loop time of 203.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.561 hours/ns, 4.911 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    | 202.71     | 202.71     | 202.71     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11074    | 0.11074    | 0.11074    |   0.0 |  0.05
Output  | 0.00018799 | 0.00018799 | 0.00018799 |   0.0 |  0.00
Modify  | 0.70742    | 0.70742    | 0.70742    |   0.0 |  0.35
Other   |            | 0.09502    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4080 ave        4080 max        4080 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214142 ave      214142 max      214142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214142
Ave neighs/atom = 53.5355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.714676627525, Press = -0.287917121982624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13143.814     -13143.814     -13305.974     -13305.974      313.70995      313.70995      67673.828      67673.828      699.06747      699.06747    
     58000  -13140.016     -13140.016     -13302.319     -13302.319      313.98703      313.98703      67774.837      67774.837     -268.45199     -268.45199    
Loop time of 203.479 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.522 hours/ns, 4.915 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    | 202.56     | 202.56     | 202.56     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11007    | 0.11007    | 0.11007    |   0.0 |  0.05
Output  | 0.00018749 | 0.00018749 | 0.00018749 |   0.0 |  0.00
Modify  | 0.70979    | 0.70979    | 0.70979    |   0.0 |  0.35
Other   |            | 0.09513    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4041 ave        4041 max        4041 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214244 ave      214244 max      214244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214244
Ave neighs/atom = 53.561
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.73171262064, Press = -0.623198042097014
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13140.016     -13140.016     -13302.319     -13302.319      313.98703      313.98703      67774.837      67774.837     -268.45199     -268.45199    
     59000  -13141.17      -13141.17      -13302.58      -13302.58       312.2583       312.2583       67882.194      67882.194     -1475.5217     -1475.5217    
Loop time of 201.795 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.054 hours/ns, 4.956 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    | 200.9      | 200.9      | 200.9      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10742    | 0.10742    | 0.10742    |   0.0 |  0.05
Output  | 0.00018752 | 0.00018752 | 0.00018752 |   0.0 |  0.00
Modify  | 0.69682    | 0.69682    | 0.69682    |   0.0 |  0.35
Other   |            | 0.09385    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4002 ave        4002 max        4002 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214136 ave      214136 max      214136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214136
Ave neighs/atom = 53.534
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.708771223179, Press = 0.0709895547049512
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13141.17      -13141.17      -13302.58      -13302.58       312.2583       312.2583       67882.194      67882.194     -1475.5217     -1475.5217    
     60000  -13147.263     -13147.263     -13307.154     -13307.154      309.32048      309.32048      67687.31       67687.31       559.46301      559.46301    
Loop time of 202.729 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.314 hours/ns, 4.933 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    | 201.83     | 201.83     | 201.83     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10862    | 0.10862    | 0.10862    |   0.0 |  0.05
Output  | 0.00029304 | 0.00029304 | 0.00029304 |   0.0 |  0.00
Modify  | 0.69826    | 0.69826    | 0.69826    |   0.0 |  0.34
Other   |            | 0.09449    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4028 ave        4028 max        4028 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214184 ave      214184 max      214184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214184
Ave neighs/atom = 53.546
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.672631092112, Press = 0.833944235348895
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13147.263     -13147.263     -13307.154     -13307.154      309.32048      309.32048      67687.31       67687.31       559.46301      559.46301    
     61000  -13142.827     -13142.827     -13302.746     -13302.746      309.37479      309.37479      67683.667      67683.667      719.49159      719.49159    
Loop time of 205.574 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.104 hours/ns, 4.864 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    | 204.65     | 204.65     | 204.65     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10972    | 0.10972    | 0.10972    |   0.0 |  0.05
Output  | 0.0001873  | 0.0001873  | 0.0001873  |   0.0 |  0.00
Modify  | 0.71748    | 0.71748    | 0.71748    |   0.0 |  0.35
Other   |            | 0.09553    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3996 ave        3996 max        3996 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214380 ave      214380 max      214380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214380
Ave neighs/atom = 53.595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.624086669427, Press = -0.00757517913561215
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13142.827     -13142.827     -13302.746     -13302.746      309.37479      309.37479      67683.667      67683.667      719.49159      719.49159    
     62000  -13145.887     -13145.887     -13308.015     -13308.015      313.64725      313.64725      67688.078      67688.078      434.54322      434.54322    
Loop time of 201.861 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.073 hours/ns, 4.954 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    | 200.96     | 200.96     | 200.96     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10878    | 0.10878    | 0.10878    |   0.0 |  0.05
Output  | 0.00018681 | 0.00018681 | 0.00018681 |   0.0 |  0.00
Modify  | 0.70157    | 0.70157    | 0.70157    |   0.0 |  0.35
Other   |            | 0.09453    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4089 ave        4089 max        4089 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214268 ave      214268 max      214268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214268
Ave neighs/atom = 53.567
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.602430940085, Press = -0.224407202615195
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13145.887     -13145.887     -13308.015     -13308.015      313.64725      313.64725      67688.078      67688.078      434.54322      434.54322    
     63000  -13139.942     -13139.942     -13304.416     -13304.416      318.18588      318.18588      67784.086      67784.086     -416.12346     -416.12346    
Loop time of 202.467 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.241 hours/ns, 4.939 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    | 201.56     | 201.56     | 201.56     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11008    | 0.11008    | 0.11008    |   0.0 |  0.05
Output  | 0.00018684 | 0.00018684 | 0.00018684 |   0.0 |  0.00
Modify  | 0.70132    | 0.70132    | 0.70132    |   0.0 |  0.35
Other   |            | 0.09456    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4051 ave        4051 max        4051 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214426 ave      214426 max      214426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214426
Ave neighs/atom = 53.6065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.564915286817, Press = -0.358119615839428
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13139.942     -13139.942     -13304.416     -13304.416      318.18588      318.18588      67784.086      67784.086     -416.12346     -416.12346    
     64000  -13144.289     -13144.289     -13305.578     -13305.578      312.02542      312.02542      67736.006      67736.006      81.10351       81.10351     
Loop time of 203.665 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.574 hours/ns, 4.910 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    | 202.75     | 202.75     | 202.75     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10858    | 0.10858    | 0.10858    |   0.0 |  0.05
Output  | 0.00018618 | 0.00018618 | 0.00018618 |   0.0 |  0.00
Modify  | 0.70834    | 0.70834    | 0.70834    |   0.0 |  0.35
Other   |            | 0.09426    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3999 ave        3999 max        3999 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214208 ave      214208 max      214208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214208
Ave neighs/atom = 53.552
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.552249418205, Press = 0.022919375337207
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13144.289     -13144.289     -13305.578     -13305.578      312.02542      312.02542      67736.006      67736.006      81.10351       81.10351     
     65000  -13141.021     -13141.021     -13301.484     -13301.484      310.42645      310.42645      67688.487      67688.487      846.94635      846.94635    
Loop time of 202.404 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.223 hours/ns, 4.941 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    | 201.5      | 201.5      | 201.5      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10886    | 0.10886    | 0.10886    |   0.0 |  0.05
Output  | 0.00018603 | 0.00018603 | 0.00018603 |   0.0 |  0.00
Modify  | 0.70075    | 0.70075    | 0.70075    |   0.0 |  0.35
Other   |            | 0.0946     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4032 ave        4032 max        4032 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214238 ave      214238 max      214238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214238
Ave neighs/atom = 53.5595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.542990238903, Press = 0.0357141100673709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -13141.021     -13141.021     -13301.484     -13301.484      310.42645      310.42645      67688.487      67688.487      846.94635      846.94635    
     66000  -13145.82      -13145.82      -13307.314     -13307.314      312.42035      312.42035      67727.67       67727.67       25.652024      25.652024    
Loop time of 203.594 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.554 hours/ns, 4.912 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    | 202.68     | 202.68     | 202.68     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10904    | 0.10904    | 0.10904    |   0.0 |  0.05
Output  | 0.00018797 | 0.00018797 | 0.00018797 |   0.0 |  0.00
Modify  | 0.7095     | 0.7095     | 0.7095     |   0.0 |  0.35
Other   |            | 0.09516    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4020 ave        4020 max        4020 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214248 ave      214248 max      214248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214248
Ave neighs/atom = 53.562
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.544780504288, Press = -0.163586969362598
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -13145.82      -13145.82      -13307.314     -13307.314      312.42035      312.42035      67727.67       67727.67       25.652024      25.652024    
     67000  -13142.367     -13142.367     -13307.611     -13307.611      319.67578      319.67578      67683.069      67683.069      563.48945      563.48945    
Loop time of 202.849 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.347 hours/ns, 4.930 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    | 201.94     | 201.94     | 201.94     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10897    | 0.10897    | 0.10897    |   0.0 |  0.05
Output  | 0.00019116 | 0.00019116 | 0.00019116 |   0.0 |  0.00
Modify  | 0.70221    | 0.70221    | 0.70221    |   0.0 |  0.35
Other   |            | 0.09449    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3999 ave        3999 max        3999 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214398 ave      214398 max      214398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214398
Ave neighs/atom = 53.5995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.538439769549, Press = -0.0653896926052288
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -13142.367     -13142.367     -13307.611     -13307.611      319.67578      319.67578      67683.069      67683.069      563.48945      563.48945    
     68000  -13141.425     -13141.425     -13303.75      -13303.75       314.02991      314.02991      67734.11       67734.11       31.549638      31.549638    
Loop time of 204.863 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.906 hours/ns, 4.881 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    | 203.94     | 203.94     | 203.94     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11145    | 0.11145    | 0.11145    |   0.0 |  0.05
Output  | 0.00018735 | 0.00018735 | 0.00018735 |   0.0 |  0.00
Modify  | 0.71348    | 0.71348    | 0.71348    |   0.0 |  0.35
Other   |            | 0.09606    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4070 ave        4070 max        4070 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214442 ave      214442 max      214442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214442
Ave neighs/atom = 53.6105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.541090118091, Press = -0.594645754665786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13141.425     -13141.425     -13303.75      -13303.75       314.02991      314.02991      67734.11       67734.11       31.549638      31.549638    
     69000  -13135.758     -13135.758     -13301.997     -13301.997      321.60003      321.60003      67878.534      67878.534     -1274.9632     -1274.9632    
Loop time of 204.743 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.873 hours/ns, 4.884 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    | 203.82     | 203.82     | 203.82     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11082    | 0.11082    | 0.11082    |   0.0 |  0.05
Output  | 0.00019039 | 0.00019039 | 0.00019039 |   0.0 |  0.00
Modify  | 0.71268    | 0.71268    | 0.71268    |   0.0 |  0.35
Other   |            | 0.09516    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4014 ave        4014 max        4014 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214286 ave      214286 max      214286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214286
Ave neighs/atom = 53.5715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.542214866146, Press = -0.10069522222298
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -13135.758     -13135.758     -13301.997     -13301.997      321.60003      321.60003      67878.534      67878.534     -1274.9632     -1274.9632    
     70000  -13143.754     -13143.754     -13304.815     -13304.815      311.58336      311.58336      67757.106      67757.106     -292.11514     -292.11514    
Loop time of 204.908 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.919 hours/ns, 4.880 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    | 204        | 204        | 204        |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10887    | 0.10887    | 0.10887    |   0.0 |  0.05
Output  | 0.00018729 | 0.00018729 | 0.00018729 |   0.0 |  0.00
Modify  | 0.70383    | 0.70383    | 0.70383    |   0.0 |  0.34
Other   |            | 0.09473    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4037 ave        4037 max        4037 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214080 ave      214080 max      214080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214080
Ave neighs/atom = 53.52
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.565461904782, Press = 0.605903076000724
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -13143.754     -13143.754     -13304.815     -13304.815      311.58336      311.58336      67757.106      67757.106     -292.11514     -292.11514    
     71000  -13137.315     -13137.315     -13303.534     -13303.534      321.56172      321.56172      67706.459      67706.459      623.05954      623.05954    
Loop time of 207.17 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.547 hours/ns, 4.827 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    | 206.24     | 206.24     | 206.24     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11065    | 0.11065    | 0.11065    |   0.0 |  0.05
Output  | 0.0001866  | 0.0001866  | 0.0001866  |   0.0 |  0.00
Modify  | 0.72529    | 0.72529    | 0.72529    |   0.0 |  0.35
Other   |            | 0.09588    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4017 ave        4017 max        4017 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214318 ave      214318 max      214318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214318
Ave neighs/atom = 53.5795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.577407574466, Press = 0.187450089187139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -13137.315     -13137.315     -13303.534     -13303.534      321.56172      321.56172      67706.459      67706.459      623.05954      623.05954    
     72000  -13142.234     -13142.234     -13301.701     -13301.701      308.49947      308.49947      67705.661      67705.661      530.23419      530.23419    
Loop time of 206.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.292 hours/ns, 4.848 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    | 205.33     | 205.33     | 205.33     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10975    | 0.10975    | 0.10975    |   0.0 |  0.05
Output  | 0.00018907 | 0.00018907 | 0.00018907 |   0.0 |  0.00
Modify  | 0.71842    | 0.71842    | 0.71842    |   0.0 |  0.35
Other   |            | 0.09496    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4010 ave        4010 max        4010 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214202 ave      214202 max      214202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214202
Ave neighs/atom = 53.5505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.569276262216, Press = -0.314699186893829
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -13142.234     -13142.234     -13301.701     -13301.701      308.49947      308.49947      67705.661      67705.661      530.23419      530.23419    
     73000  -13143.206     -13143.206     -13305.004     -13305.004      313.00825      313.00825      67803.172      67803.172     -702.35593     -702.35593    
Loop time of 204.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.790 hours/ns, 4.891 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    | 203.53     | 203.53     | 203.53     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10953    | 0.10953    | 0.10953    |   0.0 |  0.05
Output  | 0.00018605 | 0.00018605 | 0.00018605 |   0.0 |  0.00
Modify  | 0.71318    | 0.71318    | 0.71318    |   0.0 |  0.35
Other   |            | 0.09513    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4060 ave        4060 max        4060 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214278 ave      214278 max      214278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214278
Ave neighs/atom = 53.5695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.560984945905, Press = -0.245716470122623
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -13143.206     -13143.206     -13305.004     -13305.004      313.00825      313.00825      67803.172      67803.172     -702.35593     -702.35593    
     74000  -13142.116     -13142.116     -13306.84      -13306.84       318.6694       318.6694       67783.573      67783.573     -499.50785     -499.50785    
Loop time of 205.614 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.115 hours/ns, 4.863 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    | 204.69     | 204.69     | 204.69     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10908    | 0.10908    | 0.10908    |   0.0 |  0.05
Output  | 0.0001865  | 0.0001865  | 0.0001865  |   0.0 |  0.00
Modify  | 0.71481    | 0.71481    | 0.71481    |   0.0 |  0.35
Other   |            | 0.09617    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4035 ave        4035 max        4035 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214268 ave      214268 max      214268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214268
Ave neighs/atom = 53.567
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.559510442014, Press = 0.386099918500123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -13142.116     -13142.116     -13306.84      -13306.84       318.6694       318.6694       67783.573      67783.573     -499.50785     -499.50785    
     75000  -13142.787     -13142.787     -13304.595     -13304.595      313.02718      313.02718      67663.309      67663.309      904.84583      904.84583    
Loop time of 203.975 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.660 hours/ns, 4.903 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    | 203.06     | 203.06     | 203.06     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11047    | 0.11047    | 0.11047    |   0.0 |  0.05
Output  | 0.00018977 | 0.00018977 | 0.00018977 |   0.0 |  0.00
Modify  | 0.70901    | 0.70901    | 0.70901    |   0.0 |  0.35
Other   |            | 0.0947     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4026 ave        4026 max        4026 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214324 ave      214324 max      214324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214324
Ave neighs/atom = 53.581
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.550248015175, Press = 0.470687643274644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -13142.787     -13142.787     -13304.595     -13304.595      313.02718      313.02718      67663.309      67663.309      904.84583      904.84583    
     76000  -13141.308     -13141.308     -13303.71      -13303.71       314.17839      314.17839      67669.28       67669.28       779.94435      779.94435    
Loop time of 203.645 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.568 hours/ns, 4.911 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    | 202.74     | 202.74     | 202.74     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10869    | 0.10869    | 0.10869    |   0.0 |  0.05
Output  | 0.00025335 | 0.00025335 | 0.00025335 |   0.0 |  0.00
Modify  | 0.70498    | 0.70498    | 0.70498    |   0.0 |  0.35
Other   |            | 0.09503    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4030 ave        4030 max        4030 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214366 ave      214366 max      214366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214366
Ave neighs/atom = 53.5915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.520954398402, Press = -0.23652619527041
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -13141.308     -13141.308     -13303.71      -13303.71       314.17839      314.17839      67669.28       67669.28       779.94435      779.94435    
     77000  -13143.523     -13143.523     -13304.045     -13304.045      310.54146      310.54146      67771.431      67771.431     -337.08299     -337.08299    
Loop time of 205.528 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.091 hours/ns, 4.866 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    | 204.61     | 204.61     | 204.61     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10989    | 0.10989    | 0.10989    |   0.0 |  0.05
Output  | 0.00018593 | 0.00018593 | 0.00018593 |   0.0 |  0.00
Modify  | 0.7144     | 0.7144     | 0.7144     |   0.0 |  0.35
Other   |            | 0.09527    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4037 ave        4037 max        4037 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214200 ave      214200 max      214200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214200
Ave neighs/atom = 53.55
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.50267806382, Press = -0.174478467178378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -13143.523     -13143.523     -13304.045     -13304.045      310.54146      310.54146      67771.431      67771.431     -337.08299     -337.08299    
     78000  -13143.066     -13143.066     -13305.193     -13305.193      313.64657      313.64657      67746.774      67746.774     -105.84176     -105.84176    
Loop time of 203.077 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.410 hours/ns, 4.924 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    | 202.17     | 202.17     | 202.17     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10778    | 0.10778    | 0.10778    |   0.0 |  0.05
Output  | 0.00024044 | 0.00024044 | 0.00024044 |   0.0 |  0.00
Modify  | 0.70196    | 0.70196    | 0.70196    |   0.0 |  0.35
Other   |            | 0.09431    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4029 ave        4029 max        4029 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214234 ave      214234 max      214234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214234
Ave neighs/atom = 53.5585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.48730112779, Press = 0.169287815005982
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -13143.066     -13143.066     -13305.193     -13305.193      313.64657      313.64657      67746.774      67746.774     -105.84176     -105.84176    
     79000  -13139.556     -13139.556     -13304.95      -13304.95       319.96581      319.96581      67675.232      67675.232      985.27728      985.27728    
Loop time of 204.074 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.687 hours/ns, 4.900 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    | 203.16     | 203.16     | 203.16     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10888    | 0.10888    | 0.10888    |   0.0 |  0.05
Output  | 0.00018711 | 0.00018711 | 0.00018711 |   0.0 |  0.00
Modify  | 0.70499    | 0.70499    | 0.70499    |   0.0 |  0.35
Other   |            | 0.09569    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4023 ave        4023 max        4023 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214346 ave      214346 max      214346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214346
Ave neighs/atom = 53.5865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.506150563725, Press = 0.461765593905891
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -13139.556     -13139.556     -13304.95      -13304.95       319.96581      319.96581      67675.232      67675.232      985.27728      985.27728    
     80000  -13145.502     -13145.502     -13303.332     -13303.332      305.33354      305.33354      67601.504      67601.504      1835.3035      1835.3035    
Loop time of 202.156 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.154 hours/ns, 4.947 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    | 201.25     | 201.25     | 201.25     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10871    | 0.10871    | 0.10871    |   0.0 |  0.05
Output  | 0.00018924 | 0.00018924 | 0.00018924 |   0.0 |  0.00
Modify  | 0.69871    | 0.69871    | 0.69871    |   0.0 |  0.35
Other   |            | 0.09467    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4048 ave        4048 max        4048 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214312 ave      214312 max      214312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214312
Ave neighs/atom = 53.578
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.501991499777, Press = -0.303326660062268
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -13145.502     -13145.502     -13303.332     -13303.332      305.33354      305.33354      67601.504      67601.504      1835.3035      1835.3035    
     81000  -13143.183     -13143.183     -13304.745     -13304.745      312.55305      312.55305      67781.721      67781.721     -607.41959     -607.41959    
Loop time of 201.587 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.996 hours/ns, 4.961 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    | 200.69     | 200.69     | 200.69     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10947    | 0.10947    | 0.10947    |   0.0 |  0.05
Output  | 0.00018477 | 0.00018477 | 0.00018477 |   0.0 |  0.00
Modify  | 0.69643    | 0.69643    | 0.69643    |   0.0 |  0.35
Other   |            | 0.09531    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4095 ave        4095 max        4095 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214248 ave      214248 max      214248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214248
Ave neighs/atom = 53.562
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.494966191596, Press = -0.27880337521135
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -13143.183     -13143.183     -13304.745     -13304.745      312.55305      312.55305      67781.721      67781.721     -607.41959     -607.41959    
     82000  -13143.96      -13143.96      -13307.395     -13307.395      316.17583      316.17583      67768.698      67768.698     -528.83642     -528.83642    
Loop time of 204.072 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.687 hours/ns, 4.900 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    | 203.16     | 203.16     | 203.16     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10907    | 0.10907    | 0.10907    |   0.0 |  0.05
Output  | 0.00018946 | 0.00018946 | 0.00018946 |   0.0 |  0.00
Modify  | 0.71231    | 0.71231    | 0.71231    |   0.0 |  0.35
Other   |            | 0.09545    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4023 ave        4023 max        4023 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214268 ave      214268 max      214268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214268
Ave neighs/atom = 53.567
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.462656649491, Press = 0.0159416183608601
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -13143.96      -13143.96      -13307.395     -13307.395      316.17583      316.17583      67768.698      67768.698     -528.83642     -528.83642    
     83000  -13139.647     -13139.647     -13304.574     -13304.574      319.06264      319.06264      67770.818      67770.818     -230.20568     -230.20568    
Loop time of 202.557 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.266 hours/ns, 4.937 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    | 201.65     | 201.65     | 201.65     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10838    | 0.10838    | 0.10838    |   0.0 |  0.05
Output  | 0.00018644 | 0.00018644 | 0.00018644 |   0.0 |  0.00
Modify  | 0.70183    | 0.70183    | 0.70183    |   0.0 |  0.35
Other   |            | 0.09529    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4036 ave        4036 max        4036 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214350 ave      214350 max      214350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214350
Ave neighs/atom = 53.5875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.437625637322, Press = 0.173282355274784
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -13139.647     -13139.647     -13304.574     -13304.574      319.06264      319.06264      67770.818      67770.818     -230.20568     -230.20568    
     84000  -13144.022     -13144.022     -13307.472     -13307.472      316.2064       316.2064       67728.755      67728.755      14.434659      14.434659    
Loop time of 205.097 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.971 hours/ns, 4.876 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    | 204.18     | 204.18     | 204.18     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11019    | 0.11019    | 0.11019    |   0.0 |  0.05
Output  | 0.00019391 | 0.00019391 | 0.00019391 |   0.0 |  0.00
Modify  | 0.71344    | 0.71344    | 0.71344    |   0.0 |  0.35
Other   |            | 0.09579    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4032 ave        4032 max        4032 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214256 ave      214256 max      214256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214256
Ave neighs/atom = 53.564
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.423076238279, Press = 0.0956258905950314
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -13144.022     -13144.022     -13307.472     -13307.472      316.2064       316.2064       67728.755      67728.755      14.434659      14.434659    
     85000  -13148.06      -13148.06      -13307.505     -13307.505      308.45674      308.45674      67638.974      67638.974      842.13315      842.13315    
Loop time of 204.253 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.737 hours/ns, 4.896 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    | 203.34     | 203.34     | 203.34     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10867    | 0.10867    | 0.10867    |   0.0 |  0.05
Output  | 0.00019109 | 0.00019109 | 0.00019109 |   0.0 |  0.00
Modify  | 0.70644    | 0.70644    | 0.70644    |   0.0 |  0.35
Other   |            | 0.09499    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4002 ave        4002 max        4002 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214412 ave      214412 max      214412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214412
Ave neighs/atom = 53.603
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.41872285357, Press = 0.0181084647292266
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -13148.06      -13148.06      -13307.505     -13307.505      308.45674      308.45674      67638.974      67638.974      842.13315      842.13315    
     86000  -13142.002     -13142.002     -13301.904     -13301.904      309.34068      309.34068      67719.965      67719.965      178.36643      178.36643    
Loop time of 202.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.327 hours/ns, 4.932 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    | 201.86     | 201.86     | 201.86     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11001    | 0.11001    | 0.11001    |   0.0 |  0.05
Output  | 0.00018616 | 0.00018616 | 0.00018616 |   0.0 |  0.00
Modify  | 0.70824    | 0.70824    | 0.70824    |   0.0 |  0.35
Other   |            | 0.09531    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214528 ave      214528 max      214528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214528
Ave neighs/atom = 53.632
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.392436519565, Press = -0.376549270409314
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -13142.002     -13142.002     -13301.904     -13301.904      309.34068      309.34068      67719.965      67719.965      178.36643      178.36643    
     87000  -13144.569     -13144.569     -13305.407     -13305.407      311.15165      311.15165      67850.4        67850.4       -1293.0559     -1293.0559    
Loop time of 203.006 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.391 hours/ns, 4.926 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    | 202.1      | 202.1      | 202.1      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10782    | 0.10782    | 0.10782    |   0.0 |  0.05
Output  | 0.00018474 | 0.00018474 | 0.00018474 |   0.0 |  0.00
Modify  | 0.70508    | 0.70508    | 0.70508    |   0.0 |  0.35
Other   |            | 0.09547    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4023 ave        4023 max        4023 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214256 ave      214256 max      214256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214256
Ave neighs/atom = 53.564
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.391813658591, Press = -0.0673624531105825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -13144.569     -13144.569     -13305.407     -13305.407      311.15165      311.15165      67850.4        67850.4       -1293.0559     -1293.0559    
     88000  -13145.236     -13145.236     -13306.208     -13306.208      311.41115      311.41115      67743.058      67743.058     -101.64181     -101.64181    
Loop time of 200.86 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.794 hours/ns, 4.979 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    | 199.96     | 199.96     | 199.96     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10782    | 0.10782    | 0.10782    |   0.0 |  0.05
Output  | 0.00018976 | 0.00018976 | 0.00018976 |   0.0 |  0.00
Modify  | 0.6975     | 0.6975     | 0.6975     |   0.0 |  0.35
Other   |            | 0.09467    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4011 ave        4011 max        4011 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214258 ave      214258 max      214258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214258
Ave neighs/atom = 53.5645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.364391986765, Press = 0.457095638163899
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -13145.236     -13145.236     -13306.208     -13306.208      311.41115      311.41115      67743.058      67743.058     -101.64181     -101.64181    
     89000  -13139.958     -13139.958     -13302.536     -13302.536      314.5181       314.5181       67685.542      67685.542      736.01232      736.01232    
Loop time of 203.751 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.598 hours/ns, 4.908 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    | 202.84     | 202.84     | 202.84     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11036    | 0.11036    | 0.11036    |   0.0 |  0.05
Output  | 0.00019204 | 0.00019204 | 0.00019204 |   0.0 |  0.00
Modify  | 0.70977    | 0.70977    | 0.70977    |   0.0 |  0.35
Other   |            | 0.09595    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4077 ave        4077 max        4077 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       214372 ave      214372 max      214372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0