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

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

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

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23173.504770342 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_492310898779_001#item-citation

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

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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8499.0841   -8499.0841   -8579.9993   -8579.9993       313.15       313.15    23173.505    23173.505    3729.5713    3729.5713 
    1000    -8414.666    -8414.666   -8495.0818   -8495.0818    311.21765    311.21765    23390.947    23390.947     99.10361     99.10361 
Loop time of 167.481 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.516 ns/day, 46.522 hours/ns, 5.971 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 166.9      | 166.9      | 166.9      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10722    | 0.10722    | 0.10722    |   0.0 |  0.06
Output  | 0.00019845 | 0.00019845 | 0.00019845 |   0.0 |  0.00
Modify  | 0.40754    | 0.40754    | 0.40754    |   0.0 |  0.24
Other   |            | 0.06438    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000    -8414.666    -8414.666   -8495.0818   -8495.0818    311.21765    311.21765    23390.947    23390.947     99.10361     99.10361 
    2000   -8414.4602   -8414.4602   -8492.9907   -8492.9907    303.92115    303.92115    23420.848    23420.848   -1786.7996   -1786.7996 
Loop time of 160.705 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.538 ns/day, 44.640 hours/ns, 6.223 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 160.19     | 160.19     | 160.19     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09981    | 0.09981    | 0.09981    |   0.0 |  0.06
Output  | 0.00019118 | 0.00019118 | 0.00019118 |   0.0 |  0.00
Modify  | 0.3562     | 0.3562     | 0.3562     |   0.0 |  0.22
Other   |            | 0.05887    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128430.0 ave      128430 max      128430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128430
Ave neighs/atom = 64.215000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8414.4602   -8414.4602   -8492.9907   -8492.9907    303.92115    303.92115    23420.848    23420.848   -1786.7996   -1786.7996 
    3000   -8415.6733   -8415.6733   -8498.8689   -8498.8689    321.97556    321.97556    23373.446    23373.446     998.9267     998.9267 
Loop time of 153.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.560 hours/ns, 6.527 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.73     | 152.73     | 152.73     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097063   | 0.097063   | 0.097063   |   0.0 |  0.06
Output  | 0.00019146 | 0.00019146 | 0.00019146 |   0.0 |  0.00
Modify  | 0.33605    | 0.33605    | 0.33605    |   0.0 |  0.22
Other   |            | 0.05803    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128342.0 ave      128342 max      128342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128342
Ave neighs/atom = 64.171000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8415.6733   -8415.6733   -8498.8689   -8498.8689    321.97556    321.97556    23373.446    23373.446     998.9267     998.9267 
    4000   -8413.8598   -8413.8598     -8494.52     -8494.52    312.16331    312.16331    23390.573    23390.573     397.4364     397.4364 
Loop time of 153.807 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.724 hours/ns, 6.502 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 153.31     | 153.31     | 153.31     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097036   | 0.097036   | 0.097036   |   0.0 |  0.06
Output  | 0.00019143 | 0.00019143 | 0.00019143 |   0.0 |  0.00
Modify  | 0.33737    | 0.33737    | 0.33737    |   0.0 |  0.22
Other   |            | 0.05788    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128300.0 ave      128300 max      128300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128300
Ave neighs/atom = 64.150000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8413.8598   -8413.8598     -8494.52     -8494.52    312.16331    312.16331    23390.573    23390.573     397.4364     397.4364 
    5000   -8416.4852   -8416.4852   -8496.7668   -8496.7668    310.69801    310.69801    23431.312    23431.312   -2779.7968   -2779.7968 
Loop time of 153.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.554 hours/ns, 6.528 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.7      | 152.7      | 152.7      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096198   | 0.096198   | 0.096198   |   0.0 |  0.06
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.3374     | 0.3374     | 0.3374     |   0.0 |  0.22
Other   |            | 0.05826    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128400.0 ave      128400 max      128400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128400
Ave neighs/atom = 64.200000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 310.785433632231, Press = -5.36940492042756
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8416.4852   -8416.4852   -8496.7668   -8496.7668    310.69801    310.69801    23431.312    23431.312   -2779.7968   -2779.7968 
    6000   -8414.8082   -8414.8082   -8493.4235   -8493.4235    304.24923    304.24923    23394.819    23394.819    60.876569    60.876569 
Loop time of 155.388 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.556 ns/day, 43.163 hours/ns, 6.435 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 154.87     | 154.87     | 154.87     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097441   | 0.097441   | 0.097441   |   0.0 |  0.06
Output  | 0.00015433 | 0.00015433 | 0.00015433 |   0.0 |  0.00
Modify  | 0.36034    | 0.36034    | 0.36034    |   0.0 |  0.23
Other   |            | 0.0581     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128278.0 ave      128278 max      128278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128278
Ave neighs/atom = 64.139000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.105952058403, Press = 107.873941465611
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8414.8082   -8414.8082   -8493.4235   -8493.4235    304.24923    304.24923    23394.819    23394.819    60.876569    60.876569 
    7000   -8415.3422   -8415.3422    -8494.176    -8494.176    305.09494    305.09494     23358.51     23358.51    2629.3683    2629.3683 
Loop time of 152.534 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.371 hours/ns, 6.556 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.03     | 152.03     | 152.03     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096213   | 0.096213   | 0.096213   |   0.0 |  0.06
Output  | 0.0001497  | 0.0001497  | 0.0001497  |   0.0 |  0.00
Modify  | 0.35377    | 0.35377    | 0.35377    |   0.0 |  0.23
Other   |            | 0.05878    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128468.0 ave      128468 max      128468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128468
Ave neighs/atom = 64.234000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.678154554085, Press = 8.48527908464337
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8415.3422   -8415.3422    -8494.176    -8494.176    305.09494    305.09494     23358.51     23358.51    2629.3683    2629.3683 
    8000   -8415.7112   -8415.7112   -8496.3532   -8496.3532     312.0926     312.0926    23396.483    23396.483   -311.80506   -311.80506 
Loop time of 152.329 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.314 hours/ns, 6.565 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.82     | 151.82     | 151.82     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096051   | 0.096051   | 0.096051   |   0.0 |  0.06
Output  | 0.00015674 | 0.00015674 | 0.00015674 |   0.0 |  0.00
Modify  | 0.35243    | 0.35243    | 0.35243    |   0.0 |  0.23
Other   |            | 0.05896    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128370.0 ave      128370 max      128370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128370
Ave neighs/atom = 64.185000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.833782062503, Press = -2.05479080933074
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8415.7112   -8415.7112   -8496.3532   -8496.3532     312.0926     312.0926    23396.483    23396.483   -311.80506   -311.80506 
    9000   -8417.9303   -8417.9303   -8498.1934   -8498.1934    310.62647    310.62647    23389.398    23389.398   -57.119286   -57.119286 
Loop time of 152.596 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.388 hours/ns, 6.553 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.09     | 152.09     | 152.09     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095473   | 0.095473   | 0.095473   |   0.0 |  0.06
Output  | 0.000151   | 0.000151   | 0.000151   |   0.0 |  0.00
Modify  | 0.35263    | 0.35263    | 0.35263    |   0.0 |  0.23
Other   |            | 0.05874    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128328.0 ave      128328 max      128328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128328
Ave neighs/atom = 64.164000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.291495116297, Press = 6.49887886161882
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8417.9303   -8417.9303   -8498.1934   -8498.1934    310.62647    310.62647    23389.398    23389.398   -57.119286   -57.119286 
   10000   -8413.5074   -8413.5074   -8496.0361   -8496.0361    319.39472    319.39472    23378.476    23378.476    1147.2447    1147.2447 
Loop time of 153.019 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.505 hours/ns, 6.535 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.51     | 152.51     | 152.51     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097688   | 0.097688   | 0.097688   |   0.0 |  0.06
Output  | 0.00015331 | 0.00015331 | 0.00015331 |   0.0 |  0.00
Modify  | 0.3528     | 0.3528     | 0.3528     |   0.0 |  0.23
Other   |            | 0.05756    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128352.0 ave      128352 max      128352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128352
Ave neighs/atom = 64.176000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.953191270213, Press = 5.02678118731321
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8413.5074   -8413.5074   -8496.0361   -8496.0361    319.39472    319.39472    23378.476    23378.476    1147.2447    1147.2447 
   11000    -8418.786    -8418.786    -8498.415    -8498.415    308.17225    308.17225    23390.835    23390.835   -366.71432   -366.71432 
Loop time of 152.759 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.433 hours/ns, 6.546 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.25     | 152.25     | 152.25     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097012   | 0.097012   | 0.097012   |   0.0 |  0.06
Output  | 0.00015218 | 0.00015218 | 0.00015218 |   0.0 |  0.00
Modify  | 0.35317    | 0.35317    | 0.35317    |   0.0 |  0.23
Other   |            | 0.05714    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128388.0 ave      128388 max      128388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128388
Ave neighs/atom = 64.194000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.831448941003, Press = -8.57034997233849
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -8418.786    -8418.786    -8498.415    -8498.415    308.17225    308.17225    23390.835    23390.835   -366.71432   -366.71432 
   12000   -8413.0679   -8413.0679   -8497.1198   -8497.1198    325.28979    325.28979    23437.943    23437.943   -3148.8727   -3148.8727 
Loop time of 153.84 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.733 hours/ns, 6.500 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 153.33     | 153.33     | 153.33     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09775    | 0.09775    | 0.09775    |   0.0 |  0.06
Output  | 0.00019201 | 0.00019201 | 0.00019201 |   0.0 |  0.00
Modify  | 0.35612    | 0.35612    | 0.35612    |   0.0 |  0.23
Other   |            | 0.05714    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128304.0 ave      128304 max      128304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128304
Ave neighs/atom = 64.152000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.786307045662, Press = 2.69729925042678
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8413.0679   -8413.0679   -8497.1198   -8497.1198    325.28979    325.28979    23437.943    23437.943   -3148.8727   -3148.8727 
   13000   -8413.0286   -8413.0286   -8494.5308   -8494.5308    315.42174    315.42174    23389.432    23389.432     504.5998     504.5998 
Loop time of 152.966 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.490 hours/ns, 6.537 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.46     | 152.46     | 152.46     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09714    | 0.09714    | 0.09714    |   0.0 |  0.06
Output  | 0.00015559 | 0.00015559 | 0.00015559 |   0.0 |  0.00
Modify  | 0.35371    | 0.35371    | 0.35371    |   0.0 |  0.23
Other   |            | 0.05693    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128214.0 ave      128214 max      128214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128214
Ave neighs/atom = 64.107000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.913462858145, Press = 11.5308864779988
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8413.0286   -8413.0286   -8494.5308   -8494.5308    315.42174    315.42174    23389.432    23389.432     504.5998     504.5998 
   14000   -8415.6807   -8415.6807   -8496.0001   -8496.0001     310.8442     310.8442    23360.684    23360.684    2065.7867    2065.7867 
Loop time of 153.405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.613 hours/ns, 6.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.89     | 152.89     | 152.89     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098185   | 0.098185   | 0.098185   |   0.0 |  0.06
Output  | 0.00015319 | 0.00015319 | 0.00015319 |   0.0 |  0.00
Modify  | 0.35508    | 0.35508    | 0.35508    |   0.0 |  0.23
Other   |            | 0.05776    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128366.0 ave      128366 max      128366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128366
Ave neighs/atom = 64.183000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.394898347567, Press = 2.03210453165025
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8415.6807   -8415.6807   -8496.0001   -8496.0001     310.8442     310.8442    23360.684    23360.684    2065.7867    2065.7867 
   15000   -8411.4696   -8411.4696   -8494.0217   -8494.0217    319.48551    319.48551     23396.51     23396.51    156.92542    156.92542 
Loop time of 153.394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.609 hours/ns, 6.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.88     | 152.88     | 152.88     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097914   | 0.097914   | 0.097914   |   0.0 |  0.06
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.3562     | 0.3562     | 0.3562     |   0.0 |  0.23
Other   |            | 0.0574     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128328.0 ave      128328 max      128328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128328
Ave neighs/atom = 64.164000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.57560230423, Press = -3.84707547258511
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8411.4696   -8411.4696   -8494.0217   -8494.0217    319.48551    319.48551     23396.51     23396.51    156.92542    156.92542 
   16000   -8415.9113   -8415.9113   -8496.1429   -8496.1429    310.50474    310.50474    23421.896    23421.896   -2061.6232   -2061.6232 
Loop time of 153.779 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.716 hours/ns, 6.503 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 153.27     | 153.27     | 153.27     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098107   | 0.098107   | 0.098107   |   0.0 |  0.06
Output  | 0.00015416 | 0.00015416 | 0.00015416 |   0.0 |  0.00
Modify  | 0.35548    | 0.35548    | 0.35548    |   0.0 |  0.23
Other   |            | 0.05804    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128348.0 ave      128348 max      128348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128348
Ave neighs/atom = 64.174000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.599199063721, Press = -0.429970850892875
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8415.9113   -8415.9113   -8496.1429   -8496.1429    310.50474    310.50474    23421.896    23421.896   -2061.6232   -2061.6232 
   17000   -8414.5928   -8414.5928   -8495.1034   -8495.1034    311.58448    311.58448    23398.852    23398.852   -431.18043   -431.18043 
Loop time of 153.638 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.677 hours/ns, 6.509 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 153.13     | 153.13     | 153.13     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097605   | 0.097605   | 0.097605   |   0.0 |  0.06
Output  | 0.00015493 | 0.00015493 | 0.00015493 |   0.0 |  0.00
Modify  | 0.35523    | 0.35523    | 0.35523    |   0.0 |  0.23
Other   |            | 0.05753    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128312.0 ave      128312 max      128312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128312
Ave neighs/atom = 64.156000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.529963922053, Press = 5.81825840500063
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8414.5928   -8414.5928   -8495.1034   -8495.1034    311.58448    311.58448    23398.852    23398.852   -431.18043   -431.18043 
   18000    -8415.612    -8415.612   -8495.3223   -8495.3223    308.48696    308.48696    23355.375    23355.375    2537.0996    2537.0996 
Loop time of 153.768 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.713 hours/ns, 6.503 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 153.26     | 153.26     | 153.26     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098169   | 0.098169   | 0.098169   |   0.0 |  0.06
Output  | 0.00015358 | 0.00015358 | 0.00015358 |   0.0 |  0.00
Modify  | 0.3542     | 0.3542     | 0.3542     |   0.0 |  0.23
Other   |            | 0.0578     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128416.0 ave      128416 max      128416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128416
Ave neighs/atom = 64.208000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.35072982293, Press = 3.93618295262432
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000    -8415.612    -8415.612   -8495.3223   -8495.3223    308.48696    308.48696    23355.375    23355.375    2537.0996    2537.0996 
   19000   -8414.5528   -8414.5528   -8496.3336   -8496.3336    316.50028    316.50028    23378.585    23378.585    870.88652    870.88652 
Loop time of 153.508 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.641 hours/ns, 6.514 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 153        | 153        | 153        |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097943   | 0.097943   | 0.097943   |   0.0 |  0.06
Output  | 0.00015743 | 0.00015743 | 0.00015743 |   0.0 |  0.00
Modify  | 0.35598    | 0.35598    | 0.35598    |   0.0 |  0.23
Other   |            | 0.05713    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128346.0 ave      128346 max      128346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128346
Ave neighs/atom = 64.173000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.392577722094, Press = -3.45558617789915
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8414.5528   -8414.5528   -8496.3336   -8496.3336    316.50028    316.50028    23378.585    23378.585    870.88652    870.88652 
   20000   -8417.2421   -8417.2421   -8496.4042   -8496.4042    306.36539    306.36539    23437.325    23437.325    -3293.964    -3293.964 
Loop time of 152.939 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.483 hours/ns, 6.539 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.43     | 152.43     | 152.43     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09688    | 0.09688    | 0.09688    |   0.0 |  0.06
Output  | 0.00015416 | 0.00015416 | 0.00015416 |   0.0 |  0.00
Modify  | 0.35453    | 0.35453    | 0.35453    |   0.0 |  0.23
Other   |            | 0.05846    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128332.0 ave      128332 max      128332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128332
Ave neighs/atom = 64.166000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.457227245498, Press = -2.41111055788161
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8417.2421   -8417.2421   -8496.4042   -8496.4042    306.36539    306.36539    23437.325    23437.325    -3293.964    -3293.964 
   21000   -8413.8136   -8413.8136   -8494.0528   -8494.0528    310.53392    310.53392    23410.398    23410.398    -1060.107    -1060.107 
Loop time of 152.788 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.441 hours/ns, 6.545 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.28     | 152.28     | 152.28     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096099   | 0.096099   | 0.096099   |   0.0 |  0.06
Output  | 0.00015129 | 0.00015129 | 0.00015129 |   0.0 |  0.00
Modify  | 0.35312    | 0.35312    | 0.35312    |   0.0 |  0.23
Other   |            | 0.05915    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128248.0 ave      128248 max      128248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128248
Ave neighs/atom = 64.124000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.498140606864, Press = 5.96568117857823
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8413.8136   -8413.8136   -8494.0528   -8494.0528    310.53392    310.53392    23410.398    23410.398    -1060.107    -1060.107 
   22000    -8418.201    -8418.201   -8497.8224   -8497.8224    308.14318    308.14318     23366.02     23366.02    1429.6005    1429.6005 
Loop time of 153.591 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.664 hours/ns, 6.511 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    | 153.08     | 153.08     | 153.08     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097052   | 0.097052   | 0.097052   |   0.0 |  0.06
Output  | 0.00015335 | 0.00015335 | 0.00015335 |   0.0 |  0.00
Modify  | 0.35594    | 0.35594    | 0.35594    |   0.0 |  0.23
Other   |            | 0.05863    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128388.0 ave      128388 max      128388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128388
Ave neighs/atom = 64.194000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.519750404673, Press = 2.85650096590642
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    -8418.201    -8418.201   -8497.8224   -8497.8224    308.14318    308.14318     23366.02     23366.02    1429.6005    1429.6005 
   23000   -8414.2487   -8414.2487   -8493.5522   -8493.5522    306.91282    306.91282    23379.913    23379.913    1135.3458    1135.3458 
Loop time of 152.68 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.411 hours/ns, 6.550 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.17     | 152.17     | 152.17     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095245   | 0.095245   | 0.095245   |   0.0 |  0.06
Output  | 0.00015554 | 0.00015554 | 0.00015554 |   0.0 |  0.00
Modify  | 0.35367    | 0.35367    | 0.35367    |   0.0 |  0.23
Other   |            | 0.0587     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128348.0 ave      128348 max      128348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128348
Ave neighs/atom = 64.174000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.471703758291, Press = -0.246862946006692
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8414.2487   -8414.2487   -8493.5522   -8493.5522    306.91282    306.91282    23379.913    23379.913    1135.3458    1135.3458 
   24000   -8416.9673   -8416.9673   -8497.6407   -8497.6407    312.21442    312.21442    23392.456    23392.456   -273.73219   -273.73219 
Loop time of 153.274 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.576 hours/ns, 6.524 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.76     | 152.76     | 152.76     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097655   | 0.097655   | 0.097655   |   0.0 |  0.06
Output  | 0.00015327 | 0.00015327 | 0.00015327 |   0.0 |  0.00
Modify  | 0.35453    | 0.35453    | 0.35453    |   0.0 |  0.23
Other   |            | 0.05726    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128378.0 ave      128378 max      128378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128378
Ave neighs/atom = 64.189000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.452025118595, Press = -0.634798010819042
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8416.9673   -8416.9673   -8497.6407   -8497.6407    312.21442    312.21442    23392.456    23392.456   -273.73219   -273.73219 
   25000   -8411.4821   -8411.4821   -8491.9434   -8491.9434    311.39368    311.39368    23424.839    23424.839   -1605.3547   -1605.3547 
Loop time of 153.241 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.567 hours/ns, 6.526 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.73     | 152.73     | 152.73     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09743    | 0.09743    | 0.09743    |   0.0 |  0.06
Output  | 0.00015513 | 0.00015513 | 0.00015513 |   0.0 |  0.00
Modify  | 0.35403    | 0.35403    | 0.35403    |   0.0 |  0.23
Other   |            | 0.05768    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128326.0 ave      128326 max      128326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128326
Ave neighs/atom = 64.163000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.575285546482, Press = 1.45142270333462
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8411.4821   -8411.4821   -8491.9434   -8491.9434    311.39368    311.39368    23424.839    23424.839   -1605.3547   -1605.3547 
   26000    -8416.418    -8416.418   -8497.9428   -8497.9428    315.50929    315.50929      23379.5      23379.5     639.3075     639.3075 
Loop time of 153.29 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.581 hours/ns, 6.524 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.78     | 152.78     | 152.78     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097511   | 0.097511   | 0.097511   |   0.0 |  0.06
Output  | 0.00015589 | 0.00015589 | 0.00015589 |   0.0 |  0.00
Modify  | 0.35436    | 0.35436    | 0.35436    |   0.0 |  0.23
Other   |            | 0.05733    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128346.0 ave      128346 max      128346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128346
Ave neighs/atom = 64.173000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.743816766817, Press = 5.95132339411209
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -8416.418    -8416.418   -8497.9428   -8497.9428    315.50929    315.50929      23379.5      23379.5     639.3075     639.3075 
   27000   -8410.0466   -8410.0466   -8493.5741   -8493.5741    323.26011    323.26011    23361.367    23361.367    2625.8928    2625.8928 
Loop time of 153.246 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.568 hours/ns, 6.525 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.74     | 152.74     | 152.74     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098337   | 0.098337   | 0.098337   |   0.0 |  0.06
Output  | 0.00015655 | 0.00015655 | 0.00015655 |   0.0 |  0.00
Modify  | 0.353      | 0.353      | 0.353      |   0.0 |  0.23
Other   |            | 0.0576     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128334.0 ave      128334 max      128334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128334
Ave neighs/atom = 64.167000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.810966742849, Press = 0.794923257569587
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8410.0466   -8410.0466   -8493.5741   -8493.5741    323.26011    323.26011    23361.367    23361.367    2625.8928    2625.8928 
   28000     -8416.61     -8416.61   -8496.1765   -8496.1765    307.93052    307.93052    23391.534    23391.534   -88.667243   -88.667243 
Loop time of 153.26 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.572 hours/ns, 6.525 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.75     | 152.75     | 152.75     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097255   | 0.097255   | 0.097255   |   0.0 |  0.06
Output  | 0.00018825 | 0.00018825 | 0.00018825 |   0.0 |  0.00
Modify  | 0.35462    | 0.35462    | 0.35462    |   0.0 |  0.23
Other   |            | 0.05725    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128426.0 ave      128426 max      128426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128426
Ave neighs/atom = 64.213000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.899263465149, Press = -1.16840178614621
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000     -8416.61     -8416.61   -8496.1765   -8496.1765    307.93052    307.93052    23391.534    23391.534   -88.667243   -88.667243 
   29000   -8413.8763   -8413.8763   -8493.4589   -8493.4589    307.99258    307.99258    23416.786    23416.786    -1486.143    -1486.143 
Loop time of 153.151 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.542 hours/ns, 6.530 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.64     | 152.64     | 152.64     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097592   | 0.097592   | 0.097592   |   0.0 |  0.06
Output  | 0.00015575 | 0.00015575 | 0.00015575 |   0.0 |  0.00
Modify  | 0.35437    | 0.35437    | 0.35437    |   0.0 |  0.23
Other   |            | 0.05731    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128328.0 ave      128328 max      128328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128328
Ave neighs/atom = 64.164000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.97102326832, Press = 1.02364714065764
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8413.8763   -8413.8763   -8493.4589   -8493.4589    307.99258    307.99258    23416.786    23416.786    -1486.143    -1486.143 
   30000   -8415.1476   -8415.1476   -8496.5308   -8496.5308    314.96159    314.96159    23395.809    23395.809   -217.85617   -217.85617 
Loop time of 153.421 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.617 hours/ns, 6.518 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.91     | 152.91     | 152.91     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097821   | 0.097821   | 0.097821   |   0.0 |  0.06
Output  | 0.00037065 | 0.00037065 | 0.00037065 |   0.0 |  0.00
Modify  | 0.35366    | 0.35366    | 0.35366    |   0.0 |  0.23
Other   |            | 0.05729    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128334.0 ave      128334 max      128334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128334
Ave neighs/atom = 64.167000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.965455359292, Press = 2.95834485856268
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8415.1476   -8415.1476   -8496.5308   -8496.5308    314.96159    314.96159    23395.809    23395.809   -217.85617   -217.85617 
   31000   -8416.1281   -8416.1281   -8496.2961   -8496.2961    310.25843    310.25843    23333.903    23333.903    4032.7744    4032.7744 
Loop time of 153.44 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.622 hours/ns, 6.517 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.93     | 152.93     | 152.93     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097253   | 0.097253   | 0.097253   |   0.0 |  0.06
Output  | 0.00015363 | 0.00015363 | 0.00015363 |   0.0 |  0.00
Modify  | 0.35377    | 0.35377    | 0.35377    |   0.0 |  0.23
Other   |            | 0.05719    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128324.0 ave      128324 max      128324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128324
Ave neighs/atom = 64.162000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.009870079333, Press = 1.5291100715607
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8416.1281   -8416.1281   -8496.2961   -8496.2961    310.25843    310.25843    23333.903    23333.903    4032.7744    4032.7744 
   32000   -8413.1375   -8413.1375   -8493.8331   -8493.8331    312.30054    312.30054    23387.591    23387.591    719.16795    719.16795 
Loop time of 153.239 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.566 hours/ns, 6.526 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.73     | 152.73     | 152.73     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097409   | 0.097409   | 0.097409   |   0.0 |  0.06
Output  | 0.00015383 | 0.00015383 | 0.00015383 |   0.0 |  0.00
Modify  | 0.35359    | 0.35359    | 0.35359    |   0.0 |  0.23
Other   |            | 0.05755    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128444.0 ave      128444 max      128444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128444
Ave neighs/atom = 64.222000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.028564029337, Press = -3.15842793509052
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8413.1375   -8413.1375   -8493.8331   -8493.8331    312.30054    312.30054    23387.591    23387.591    719.16795    719.16795 
   33000   -8414.9337   -8414.9337   -8495.2359   -8495.2359    310.77769    310.77769    23425.733    23425.733   -2160.4962   -2160.4962 
Loop time of 153.383 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.606 hours/ns, 6.520 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.87     | 152.87     | 152.87     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097093   | 0.097093   | 0.097093   |   0.0 |  0.06
Output  | 0.00019777 | 0.00019777 | 0.00019777 |   0.0 |  0.00
Modify  | 0.35358    | 0.35358    | 0.35358    |   0.0 |  0.23
Other   |            | 0.05765    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128352.0 ave      128352 max      128352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128352
Ave neighs/atom = 64.176000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.056533311235, Press = 0.252453734752246
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8414.9337   -8414.9337   -8495.2359   -8495.2359    310.77769    310.77769    23425.733    23425.733   -2160.4962   -2160.4962 
   34000   -8416.3984   -8416.3984   -8497.5438   -8497.5438    314.04126    314.04126    23397.615    23397.615   -622.75673   -622.75673 
Loop time of 153.464 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.629 hours/ns, 6.516 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.96     | 152.96     | 152.96     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097252   | 0.097252   | 0.097252   |   0.0 |  0.06
Output  | 0.0001541  | 0.0001541  | 0.0001541  |   0.0 |  0.00
Modify  | 0.3545     | 0.3545     | 0.3545     |   0.0 |  0.23
Other   |            | 0.05704    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128314.0 ave      128314 max      128314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128314
Ave neighs/atom = 64.157000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.096132590269, Press = 2.02109389089463
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8416.3984   -8416.3984   -8497.5438   -8497.5438    314.04126    314.04126    23397.615    23397.615   -622.75673   -622.75673 
   35000   -8411.7335   -8411.7335   -8495.2282   -8495.2282    323.13321    323.13321    23374.092    23374.092    1490.2598    1490.2598 
Loop time of 153.461 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.628 hours/ns, 6.516 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.95     | 152.95     | 152.95     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097372   | 0.097372   | 0.097372   |   0.0 |  0.06
Output  | 0.0001522  | 0.0001522  | 0.0001522  |   0.0 |  0.00
Modify  | 0.3541     | 0.3541     | 0.3541     |   0.0 |  0.23
Other   |            | 0.05747    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128314.0 ave      128314 max      128314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128314
Ave neighs/atom = 64.157000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.137288341223, Press = 1.33676109742233
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8411.7335   -8411.7335   -8495.2282   -8495.2282    323.13321    323.13321    23374.092    23374.092    1490.2598    1490.2598 
   36000   -8415.4325   -8415.4325   -8496.9006   -8496.9006    315.28987    315.28987    23380.192    23380.192    727.61079    727.61079 
Loop time of 153.171 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.547 hours/ns, 6.529 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.66     | 152.66     | 152.66     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097384   | 0.097384   | 0.097384   |   0.0 |  0.06
Output  | 0.00015352 | 0.00015352 | 0.00015352 |   0.0 |  0.00
Modify  | 0.3534     | 0.3534     | 0.3534     |   0.0 |  0.23
Other   |            | 0.05704    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128342.0 ave      128342 max      128342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128342
Ave neighs/atom = 64.171000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.189958114323, Press = -1.34216057845555
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8415.4325   -8415.4325   -8496.9006   -8496.9006    315.28987    315.28987    23380.192    23380.192    727.61079    727.61079 
   37000   -8411.6366   -8411.6366     -8493.13     -8493.13     315.3881     315.3881    23477.003    23477.003   -5308.2329   -5308.2329 
Loop time of 153.399 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.611 hours/ns, 6.519 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.89     | 152.89     | 152.89     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09734    | 0.09734    | 0.09734    |   0.0 |  0.06
Output  | 0.00015366 | 0.00015366 | 0.00015366 |   0.0 |  0.00
Modify  | 0.35434    | 0.35434    | 0.35434    |   0.0 |  0.23
Other   |            | 0.0575     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128340.0 ave      128340 max      128340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128340
Ave neighs/atom = 64.170000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.282895389034, Press = -1.37782492956488
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8411.6366   -8411.6366     -8493.13     -8493.13     315.3881     315.3881    23477.003    23477.003   -5308.2329   -5308.2329 
   38000   -8415.8937   -8415.8937   -8497.6727   -8497.6727    316.49307    316.49307    23409.136    23409.136    -1374.975    -1374.975 
Loop time of 153.309 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.586 hours/ns, 6.523 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.8      | 152.8      | 152.8      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097653   | 0.097653   | 0.097653   |   0.0 |  0.06
Output  | 0.00015372 | 0.00015372 | 0.00015372 |   0.0 |  0.00
Modify  | 0.35441    | 0.35441    | 0.35441    |   0.0 |  0.23
Other   |            | 0.05748    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128292.0 ave      128292 max      128292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128292
Ave neighs/atom = 64.146000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.278045232459, Press = 3.19079604907336
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8415.8937   -8415.8937   -8497.6727   -8497.6727    316.49307    316.49307    23409.136    23409.136    -1374.975    -1374.975 
   39000   -8414.6619   -8414.6619   -8495.8885   -8495.8885      314.355      314.355    23363.303    23363.303    2015.7566    2015.7566 
Loop time of 153.435 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.621 hours/ns, 6.517 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.93     | 152.93     | 152.93     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097756   | 0.097756   | 0.097756   |   0.0 |  0.06
Output  | 0.00015452 | 0.00015452 | 0.00015452 |   0.0 |  0.00
Modify  | 0.35382    | 0.35382    | 0.35382    |   0.0 |  0.23
Other   |            | 0.05773    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128342.0 ave      128342 max      128342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128342
Ave neighs/atom = 64.171000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.299124593153, Press = 1.51138777171843
next a
jump SELF top
variable a loop 2000
run 1000
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8414.6619   -8414.6619   -8495.8885   -8495.8885      314.355      314.355    23363.303    23363.303    2015.7566    2015.7566 
   40000   -8410.7904   -8410.7904   -8492.8013   -8492.8013    317.39085    317.39085    23384.458    23384.458     1013.332     1013.332 
Loop time of 153.403 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.612 hours/ns, 6.519 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.89     | 152.89     | 152.89     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098039   | 0.098039   | 0.098039   |   0.0 |  0.06
Output  | 0.00015213 | 0.00015213 | 0.00015213 |   0.0 |  0.00
Modify  | 0.35389    | 0.35389    | 0.35389    |   0.0 |  0.23
Other   |            | 0.05751    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4115.00 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128394.0 ave      128394 max      128394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0