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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 4.0469995588064185*${_u_distance}
variable latticeconst_converted equal 4.0469995588064185*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04699955880642
Lattice spacing in x,y,z = 4.0469996 4.0469996 4.0469996
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 (40.469996 40.469996 40.469996)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.469996 40.469996 40.469996)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Al

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

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


mass          1 ${mass_converted}
mass          1 26.981538

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_958395190627_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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13255.791   -13255.791       -13428       -13428       333.15       333.15     66282.59     66282.59     2775.086     2775.086 
    1000   -13064.763   -13064.763   -13233.332   -13233.332    326.10862    326.10862    67909.792    67909.792   -38.377844   -38.377844 
Loop time of 291.42 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.296 ns/day, 80.950 hours/ns, 3.431 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    | 290.41     | 290.41     | 290.41     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16031    | 0.16031    | 0.16031    |   0.0 |  0.06
Output  | 0.00027983 | 0.00027983 | 0.00027983 |   0.0 |  0.00
Modify  | 0.74678    | 0.74678    | 0.74678    |   0.0 |  0.26
Other   |            | 0.102      |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      344000.0 ave      344000 max      344000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 344000
Ave neighs/atom = 86.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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13064.763   -13064.763   -13233.332   -13233.332    326.10862    326.10862    67909.792    67909.792   -38.377844   -38.377844 
    2000    -13082.34    -13082.34   -13250.733   -13250.733    325.76648    325.76648     67752.52     67752.52    204.84013    204.84013 
Loop time of 257.012 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.336 ns/day, 71.392 hours/ns, 3.891 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    | 255.99     | 255.99     | 255.99     |   0.0 | 99.60
Neigh   | 0.11259    | 0.11259    | 0.11259    |   0.0 |  0.04
Comm    | 0.15337    | 0.15337    | 0.15337    |   0.0 |  0.06
Output  | 0.00021675 | 0.00021675 | 0.00021675 |   0.0 |  0.00
Modify  | 0.66333    | 0.66333    | 0.66333    |   0.0 |  0.26
Other   |            | 0.09455    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330896.0 ave      330896 max      330896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330896
Ave neighs/atom = 82.724000
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -13082.34    -13082.34   -13250.733   -13250.733    325.76648    325.76648     67752.52     67752.52    204.84013    204.84013 
    3000   -13073.694   -13073.694   -13248.736   -13248.736    338.62924    338.62924    67780.908    67780.908    180.24421    180.24421 
Loop time of 251.927 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.343 ns/day, 69.980 hours/ns, 3.969 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    | 251.04     | 251.04     | 251.04     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14636    | 0.14636    | 0.14636    |   0.0 |  0.06
Output  | 0.00021402 | 0.00021402 | 0.00021402 |   0.0 |  0.00
Modify  | 0.64416    | 0.64416    | 0.64416    |   0.0 |  0.26
Other   |            | 0.0965     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330938.0 ave      330938 max      330938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330938
Ave neighs/atom = 82.734500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13073.694   -13073.694   -13248.736   -13248.736    338.62924    338.62924    67780.908    67780.908    180.24421    180.24421 
    4000   -13076.785   -13076.785   -13250.607   -13250.607    336.27012    336.27012    67802.786    67802.786   -247.19059   -247.19059 
Loop time of 252.01 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.343 ns/day, 70.003 hours/ns, 3.968 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    | 251.12     | 251.12     | 251.12     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14586    | 0.14586    | 0.14586    |   0.0 |  0.06
Output  | 0.00026134 | 0.00026134 | 0.00026134 |   0.0 |  0.00
Modify  | 0.64397    | 0.64397    | 0.64397    |   0.0 |  0.26
Other   |            | 0.09677    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330972.0 ave      330972 max      330972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330972
Ave neighs/atom = 82.743000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13076.785   -13076.785   -13250.607   -13250.607    336.27012    336.27012    67802.786    67802.786   -247.19059   -247.19059 
    5000   -13077.979   -13077.979    -13248.78    -13248.78    330.42621    330.42621    67811.263    67811.263   -170.47388   -170.47388 
Loop time of 250.42 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.345 ns/day, 69.561 hours/ns, 3.993 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    | 249.54     | 249.54     | 249.54     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14434    | 0.14434    | 0.14434    |   0.0 |  0.06
Output  | 0.00017739 | 0.00017739 | 0.00017739 |   0.0 |  0.00
Modify  | 0.64064    | 0.64064    | 0.64064    |   0.0 |  0.26
Other   |            | 0.09538    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330878.0 ave      330878 max      330878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330878
Ave neighs/atom = 82.719500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.012435988567, Press = 108.968661245656
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13077.979   -13077.979    -13248.78    -13248.78    330.42621    330.42621    67811.263    67811.263   -170.47388   -170.47388 
    6000   -13075.004   -13075.004   -13248.599   -13248.599    335.83174    335.83174    67797.046    67797.046   -11.831199   -11.831199 
Loop time of 252.549 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.342 ns/day, 70.153 hours/ns, 3.960 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    | 251.59     | 251.59     | 251.59     |   0.0 | 99.62
Neigh   | 0.053357   | 0.053357   | 0.053357   |   0.0 |  0.02
Comm    | 0.15104    | 0.15104    | 0.15104    |   0.0 |  0.06
Output  | 0.00021851 | 0.00021851 | 0.00021851 |   0.0 |  0.00
Modify  | 0.66517    | 0.66517    | 0.66517    |   0.0 |  0.26
Other   |            | 0.09373    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      331022.0 ave      331022 max      331022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331022
Ave neighs/atom = 82.755500
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.322686533227, Press = -9.5874187000446
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13075.004   -13075.004   -13248.599   -13248.599    335.83174    335.83174    67797.046    67797.046   -11.831199   -11.831199 
    7000   -13078.283   -13078.283   -13250.141   -13250.141    332.47034    332.47034    67809.838    67809.838   -329.12037   -329.12037 
Loop time of 260.709 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.419 hours/ns, 3.836 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    | 259.75     | 259.75     | 259.75     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14993    | 0.14993    | 0.14993    |   0.0 |  0.06
Output  | 0.00017723 | 0.00017723 | 0.00017723 |   0.0 |  0.00
Modify  | 0.70525    | 0.70525    | 0.70525    |   0.0 |  0.27
Other   |            | 0.09953    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330770.0 ave      330770 max      330770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330770
Ave neighs/atom = 82.692500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.195668138065, Press = 23.8798167502248
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13078.283   -13078.283   -13250.141   -13250.141    332.47034    332.47034    67809.838    67809.838   -329.12037   -329.12037 
    8000   -13077.049   -13077.049   -13247.789   -13247.789     330.3093     330.3093    67740.969    67740.969    613.24692    613.24692 
Loop time of 264.726 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.535 hours/ns, 3.777 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    | 263.75     | 263.75     | 263.75     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15313    | 0.15313    | 0.15313    |   0.0 |  0.06
Output  | 0.00017901 | 0.00017901 | 0.00017901 |   0.0 |  0.00
Modify  | 0.72142    | 0.72142    | 0.72142    |   0.0 |  0.27
Other   |            | 0.09916    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330820.0 ave      330820 max      330820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330820
Ave neighs/atom = 82.705000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.702791628249, Press = -13.5379281418113
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13077.049   -13077.049   -13247.789   -13247.789     330.3093     330.3093    67740.969    67740.969    613.24692    613.24692 
    9000   -13069.064   -13069.064   -13246.941   -13246.941    344.11641    344.11641    67879.192    67879.192   -710.02693   -710.02693 
Loop time of 255.298 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.338 ns/day, 70.916 hours/ns, 3.917 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    | 254.37     | 254.37     | 254.37     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14968    | 0.14968    | 0.14968    |   0.0 |  0.06
Output  | 0.00021958 | 0.00021958 | 0.00021958 |   0.0 |  0.00
Modify  | 0.67991    | 0.67991    | 0.67991    |   0.0 |  0.27
Other   |            | 0.09557    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      331060.0 ave      331060 max      331060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331060
Ave neighs/atom = 82.765000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.294916342637, Press = 7.16053010061688
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13069.064   -13069.064   -13246.941   -13246.941    344.11641    344.11641    67879.192    67879.192   -710.02693   -710.02693 
   10000   -13079.953   -13079.953   -13249.185   -13249.185    327.38971    327.38971    67742.106    67742.106    493.57951    493.57951 
Loop time of 250.525 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.345 ns/day, 69.590 hours/ns, 3.992 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    | 249.62     | 249.62     | 249.62     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14736    | 0.14736    | 0.14736    |   0.0 |  0.06
Output  | 0.00017971 | 0.00017971 | 0.00017971 |   0.0 |  0.00
Modify  | 0.66416    | 0.66416    | 0.66416    |   0.0 |  0.27
Other   |            | 0.09676    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330520.0 ave      330520 max      330520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330520
Ave neighs/atom = 82.630000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.442110774842, Press = 2.32407804583308
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13079.953   -13079.953   -13249.185   -13249.185    327.38971    327.38971    67742.106    67742.106    493.57951    493.57951 
   11000   -13080.547   -13080.547   -13249.679   -13249.679    327.19688    327.19688    67826.366    67826.366   -485.47013   -485.47013 
Loop time of 251.183 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.344 ns/day, 69.773 hours/ns, 3.981 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    | 250.28     | 250.28     | 250.28     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14665    | 0.14665    | 0.14665    |   0.0 |  0.06
Output  | 0.00017777 | 0.00017777 | 0.00017777 |   0.0 |  0.00
Modify  | 0.66571    | 0.66571    | 0.66571    |   0.0 |  0.27
Other   |            | 0.09491    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      331022.0 ave      331022 max      331022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331022
Ave neighs/atom = 82.755500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.390066930944, Press = 1.3155469484702
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13080.547   -13080.547   -13249.679   -13249.679    327.19688    327.19688    67826.366    67826.366   -485.47013   -485.47013 
   12000   -13077.506   -13077.506   -13247.403   -13247.403    328.67639    328.67639    67683.138    67683.138    1293.6461    1293.6461 
Loop time of 250.065 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.346 ns/day, 69.462 hours/ns, 3.999 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    | 249.16     | 249.16     | 249.16     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14496    | 0.14496    | 0.14496    |   0.0 |  0.06
Output  | 0.00017532 | 0.00017532 | 0.00017532 |   0.0 |  0.00
Modify  | 0.66384    | 0.66384    | 0.66384    |   0.0 |  0.27
Other   |            | 0.09621    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330762.0 ave      330762 max      330762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330762
Ave neighs/atom = 82.690500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.015455865443, Press = 1.71931691720159
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13077.506   -13077.506   -13247.403   -13247.403    328.67639    328.67639    67683.138    67683.138    1293.6461    1293.6461 
   13000   -13073.343   -13073.343   -13246.397   -13246.397    334.78384    334.78384    67910.612    67910.612   -1117.9814   -1117.9814 
Loop time of 254.341 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.340 ns/day, 70.650 hours/ns, 3.932 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    | 253.42     | 253.42     | 253.42     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14824    | 0.14824    | 0.14824    |   0.0 |  0.06
Output  | 0.00021658 | 0.00021658 | 0.00021658 |   0.0 |  0.00
Modify  | 0.67695    | 0.67695    | 0.67695    |   0.0 |  0.27
Other   |            | 0.09612    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      331186.0 ave      331186 max      331186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331186
Ave neighs/atom = 82.796500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.153229411892, Press = -2.13199133473221
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13073.343   -13073.343   -13246.397   -13246.397    334.78384    334.78384    67910.612    67910.612   -1117.9814   -1117.9814 
   14000   -13077.277   -13077.277   -13252.312   -13252.312    338.61669    338.61669    67639.331    67639.331    1420.4759    1420.4759 
Loop time of 251.757 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.343 ns/day, 69.932 hours/ns, 3.972 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    | 250.85     | 250.85     | 250.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14616    | 0.14616    | 0.14616    |   0.0 |  0.06
Output  | 0.00017816 | 0.00017816 | 0.00017816 |   0.0 |  0.00
Modify  | 0.66588    | 0.66588    | 0.66588    |   0.0 |  0.26
Other   |            | 0.09414    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330474.0 ave      330474 max      330474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330474
Ave neighs/atom = 82.618500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.299864642061, Press = 2.40442928112158
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13077.277   -13077.277   -13252.312   -13252.312    338.61669    338.61669    67639.331    67639.331    1420.4759    1420.4759 
   15000   -13076.059   -13076.059   -13247.177   -13247.177    331.04012    331.04012    67865.714    67865.714   -644.02194   -644.02194 
Loop time of 249.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.346 ns/day, 69.442 hours/ns, 4.000 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    | 249.09     | 249.09     | 249.09     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14254    | 0.14254    | 0.14254    |   0.0 |  0.06
Output  | 0.00050328 | 0.00050328 | 0.00050328 |   0.0 |  0.00
Modify  | 0.66087    | 0.66087    | 0.66087    |   0.0 |  0.26
Other   |            | 0.09625    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      331326.0 ave      331326 max      331326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331326
Ave neighs/atom = 82.831500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.243097162724, Press = 1.79234672568341
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13076.059   -13076.059   -13247.177   -13247.177    331.04012    331.04012    67865.714    67865.714   -644.02194   -644.02194 
   16000   -13080.247   -13080.247   -13252.696   -13252.696    333.61489    333.61489    67721.704    67721.704    450.01668    450.01668 
Loop time of 264.385 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.440 hours/ns, 3.782 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    | 263.36     | 263.36     | 263.36     |   0.0 | 99.61
Neigh   | 0.053347   | 0.053347   | 0.053347   |   0.0 |  0.02
Comm    | 0.15574    | 0.15574    | 0.15574    |   0.0 |  0.06
Output  | 0.00024465 | 0.00024465 | 0.00024465 |   0.0 |  0.00
Modify  | 0.72011    | 0.72011    | 0.72011    |   0.0 |  0.27
Other   |            | 0.0992     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330922.0 ave      330922 max      330922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330922
Ave neighs/atom = 82.730500
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.398088780106, Press = -0.93266670302351
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13080.247   -13080.247   -13252.696   -13252.696    333.61489    333.61489    67721.704    67721.704    450.01668    450.01668 
   17000   -13072.522   -13072.522   -13247.112   -13247.112    337.75731    337.75731    67903.006    67903.006   -1059.9571   -1059.9571 
Loop time of 250.458 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.345 ns/day, 69.572 hours/ns, 3.993 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    | 249.55     | 249.55     | 249.55     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14544    | 0.14544    | 0.14544    |   0.0 |  0.06
Output  | 0.00017784 | 0.00017784 | 0.00017784 |   0.0 |  0.00
Modify  | 0.66413    | 0.66413    | 0.66413    |   0.0 |  0.27
Other   |            | 0.09704    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      331006.0 ave      331006 max      331006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331006
Ave neighs/atom = 82.751500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.383533081314, Press = 2.04144840380504
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13072.522   -13072.522   -13247.112   -13247.112    337.75731    337.75731    67903.006    67903.006   -1059.9571   -1059.9571 
   18000   -13078.737   -13078.737   -13248.224   -13248.224    327.88404    327.88404    67706.403    67706.403    952.49634    952.49634 
Loop time of 249.3 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.347 ns/day, 69.250 hours/ns, 4.011 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    | 248.4      | 248.4      | 248.4      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14476    | 0.14476    | 0.14476    |   0.0 |  0.06
Output  | 0.00017699 | 0.00017699 | 0.00017699 |   0.0 |  0.00
Modify  | 0.65988    | 0.65988    | 0.65988    |   0.0 |  0.26
Other   |            | 0.09741    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330582.0 ave      330582 max      330582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330582
Ave neighs/atom = 82.645500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.457910942208, Press = 0.116323722862995
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13078.737   -13078.737   -13248.224   -13248.224    327.88404    327.88404    67706.403    67706.403    952.49634    952.49634 
   19000   -13069.469   -13069.469   -13245.938   -13245.938     341.3902     341.3902    67855.286    67855.286   -398.94202   -398.94202 
Loop time of 250.562 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.345 ns/day, 69.601 hours/ns, 3.991 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    | 249.66     | 249.66     | 249.66     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14611    | 0.14611    | 0.14611    |   0.0 |  0.06
Output  | 0.00017929 | 0.00017929 | 0.00017929 |   0.0 |  0.00
Modify  | 0.66435    | 0.66435    | 0.66435    |   0.0 |  0.27
Other   |            | 0.09571    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      331036.0 ave      331036 max      331036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331036
Ave neighs/atom = 82.759000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.563921138992, Press = 0.678566772740648
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13069.469   -13069.469   -13245.938   -13245.938     341.3902     341.3902    67855.286    67855.286   -398.94202   -398.94202 
   20000   -13079.126   -13079.126    -13250.21    -13250.21     330.9738     330.9738    67773.422    67773.422    109.54229    109.54229 
Loop time of 250.073 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.345 ns/day, 69.465 hours/ns, 3.999 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    | 249.17     | 249.17     | 249.17     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14604    | 0.14604    | 0.14604    |   0.0 |  0.06
Output  | 0.00017785 | 0.00017785 | 0.00017785 |   0.0 |  0.00
Modify  | 0.6629     | 0.6629     | 0.6629     |   0.0 |  0.27
Other   |            | 0.09629    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330646.0 ave      330646 max      330646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330646
Ave neighs/atom = 82.661500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.639326239424, Press = 0.48227661828084
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13079.126   -13079.126    -13250.21    -13250.21     330.9738     330.9738    67773.422    67773.422    109.54229    109.54229 
   21000   -13074.071   -13074.071   -13247.912   -13247.912    336.30824    336.30824    67795.248    67795.248    67.701573    67.701573 
Loop time of 249.842 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.346 ns/day, 69.400 hours/ns, 4.003 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    | 248.94     | 248.94     | 248.94     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14511    | 0.14511    | 0.14511    |   0.0 |  0.06
Output  | 0.00017753 | 0.00017753 | 0.00017753 |   0.0 |  0.00
Modify  | 0.66438    | 0.66438    | 0.66438    |   0.0 |  0.27
Other   |            | 0.09663    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330874.0 ave      330874 max      330874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330874
Ave neighs/atom = 82.718500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.675647431076, Press = -0.486660959943349
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13074.071   -13074.071   -13247.912   -13247.912    336.30824    336.30824    67795.248    67795.248    67.701573    67.701573 
   22000   -13075.268   -13075.268   -13249.457   -13249.457    336.98008    336.98008    67790.744    67790.744   -50.020098   -50.020098 
Loop time of 250.066 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.346 ns/day, 69.463 hours/ns, 3.999 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    | 249.16     | 249.16     | 249.16     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14411    | 0.14411    | 0.14411    |   0.0 |  0.06
Output  | 0.00017583 | 0.00017583 | 0.00017583 |   0.0 |  0.00
Modify  | 0.66334    | 0.66334    | 0.66334    |   0.0 |  0.27
Other   |            | 0.09706    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330840.0 ave      330840 max      330840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330840
Ave neighs/atom = 82.710000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.626412168809, Press = 0.800364888327245
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13075.268   -13075.268   -13249.457   -13249.457    336.98008    336.98008    67790.744    67790.744   -50.020098   -50.020098 
   23000   -13081.031   -13081.031   -13249.791   -13249.791     326.4771     326.4771     67745.31     67745.31    340.92203    340.92203 
Loop time of 250.377 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.345 ns/day, 69.549 hours/ns, 3.994 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    | 249.47     | 249.47     | 249.47     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14416    | 0.14416    | 0.14416    |   0.0 |  0.06
Output  | 0.00017997 | 0.00017997 | 0.00017997 |   0.0 |  0.00
Modify  | 0.66393    | 0.66393    | 0.66393    |   0.0 |  0.27
Other   |            | 0.09664    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330954.0 ave      330954 max      330954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330954
Ave neighs/atom = 82.738500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.638497329539, Press = -1.30246725358698
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13081.031   -13081.031   -13249.791   -13249.791     326.4771     326.4771     67745.31     67745.31    340.92203    340.92203 
   24000   -13074.545   -13074.545   -13247.321   -13247.321    334.24746    334.24746    67845.679    67845.679   -471.21984   -471.21984 
Loop time of 255.509 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.338 ns/day, 70.975 hours/ns, 3.914 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    | 254.52     | 254.52     | 254.52     |   0.0 | 99.61
Neigh   | 0.053295   | 0.053295   | 0.053295   |   0.0 |  0.02
Comm    | 0.15045    | 0.15045    | 0.15045    |   0.0 |  0.06
Output  | 0.00025123 | 0.00025123 | 0.00025123 |   0.0 |  0.00
Modify  | 0.68585    | 0.68585    | 0.68585    |   0.0 |  0.27
Other   |            | 0.09849    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330718.0 ave      330718 max      330718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330718
Ave neighs/atom = 82.679500
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.582050989828, Press = 2.10878652422433
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13074.545   -13074.545   -13247.321   -13247.321    334.24746    334.24746    67845.679    67845.679   -471.21984   -471.21984 
   25000    -13077.42    -13077.42   -13247.488   -13247.488    329.00928    329.00928     67750.25     67750.25    568.24844    568.24844 
Loop time of 256.882 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.336 ns/day, 71.356 hours/ns, 3.893 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    | 255.95     | 255.95     | 255.95     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14982    | 0.14982    | 0.14982    |   0.0 |  0.06
Output  | 0.00017815 | 0.00017815 | 0.00017815 |   0.0 |  0.00
Modify  | 0.68846    | 0.68846    | 0.68846    |   0.0 |  0.27
Other   |            | 0.09624    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330834.0 ave      330834 max      330834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330834
Ave neighs/atom = 82.708500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.596091623247, Press = -1.73771166181003
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000    -13077.42    -13077.42   -13247.488   -13247.488    329.00928    329.00928     67750.25     67750.25    568.24844    568.24844 
   26000   -13072.085   -13072.085   -13244.791   -13244.791    334.11204    334.11204    67872.825    67872.825   -604.76795   -604.76795 
Loop time of 251.351 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.344 ns/day, 69.820 hours/ns, 3.979 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    | 250.44     | 250.44     | 250.44     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14983    | 0.14983    | 0.14983    |   0.0 |  0.06
Output  | 0.00018107 | 0.00018107 | 0.00018107 |   0.0 |  0.00
Modify  | 0.66835    | 0.66835    | 0.66835    |   0.0 |  0.27
Other   |            | 0.09492    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330904.0 ave      330904 max      330904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330904
Ave neighs/atom = 82.726000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.579827739616, Press = 1.78355367371876
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13072.085   -13072.085   -13244.791   -13244.791    334.11204    334.11204    67872.825    67872.825   -604.76795   -604.76795 
   27000   -13077.864   -13077.864   -13252.344   -13252.344    337.54429    337.54429     67755.38     67755.38    139.04742    139.04742 
Loop time of 250.906 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.344 ns/day, 69.696 hours/ns, 3.986 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    | 249.99     | 249.99     | 249.99     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14724    | 0.14724    | 0.14724    |   0.0 |  0.06
Output  | 0.000178   | 0.000178   | 0.000178   |   0.0 |  0.00
Modify  | 0.66869    | 0.66869    | 0.66869    |   0.0 |  0.27
Other   |            | 0.09605    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330702.0 ave      330702 max      330702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330702
Ave neighs/atom = 82.675500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.561426297766, Press = -0.680588923772419
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13077.864   -13077.864   -13252.344   -13252.344    337.54429    337.54429     67755.38     67755.38    139.04742    139.04742 
   28000   -13076.095   -13076.095    -13249.58    -13249.58    335.61855    335.61855    67791.364    67791.364   -79.576342   -79.576342 
Loop time of 255.098 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.339 ns/day, 70.861 hours/ns, 3.920 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    | 254.18     | 254.18     | 254.18     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14712    | 0.14712    | 0.14712    |   0.0 |  0.06
Output  | 0.00023084 | 0.00023084 | 0.00023084 |   0.0 |  0.00
Modify  | 0.67902    | 0.67902    | 0.67902    |   0.0 |  0.27
Other   |            | 0.09614    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      331040.0 ave      331040 max      331040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331040
Ave neighs/atom = 82.760000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.541814225289, Press = 0.978573848483388
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13076.095   -13076.095    -13249.58    -13249.58    335.61855    335.61855    67791.364    67791.364   -79.576342   -79.576342 
   29000   -13077.972   -13077.972   -13248.052   -13248.052    329.03225    329.03225    67779.006    67779.006    207.40492    207.40492 
Loop time of 250.677 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.345 ns/day, 69.633 hours/ns, 3.989 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    | 249.77     | 249.77     | 249.77     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14541    | 0.14541    | 0.14541    |   0.0 |  0.06
Output  | 0.00017789 | 0.00017789 | 0.00017789 |   0.0 |  0.00
Modify  | 0.66639    | 0.66639    | 0.66639    |   0.0 |  0.27
Other   |            | 0.09821    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330834.0 ave      330834 max      330834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330834
Ave neighs/atom = 82.708500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.466584206407, Press = -0.483885613749083
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13077.972   -13077.972   -13248.052   -13248.052    329.03225    329.03225    67779.006    67779.006    207.40492    207.40492 
   30000   -13079.003   -13079.003   -13248.096   -13248.096    327.12287    327.12287    67826.086    67826.086   -358.48638   -358.48638 
Loop time of 250.178 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.345 ns/day, 69.494 hours/ns, 3.997 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    | 249.27     | 249.27     | 249.27     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14597    | 0.14597    | 0.14597    |   0.0 |  0.06
Output  | 0.00017731 | 0.00017731 | 0.00017731 |   0.0 |  0.00
Modify  | 0.66144    | 0.66144    | 0.66144    |   0.0 |  0.26
Other   |            | 0.09835    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330938.0 ave      330938 max      330938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330938
Ave neighs/atom = 82.734500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.365676391287, Press = 0.988028098873701
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13079.003   -13079.003   -13248.096   -13248.096    327.12287    327.12287    67826.086    67826.086   -358.48638   -358.48638 
   31000   -13076.838   -13076.838   -13250.002   -13250.002    334.99661    334.99661    67780.569    67780.569    41.035456    41.035456 
Loop time of 249.245 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.347 ns/day, 69.235 hours/ns, 4.012 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    | 248.34     | 248.34     | 248.34     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14499    | 0.14499    | 0.14499    |   0.0 |  0.06
Output  | 0.00017669 | 0.00017669 | 0.00017669 |   0.0 |  0.00
Modify  | 0.66279    | 0.66279    | 0.66279    |   0.0 |  0.27
Other   |            | 0.0981     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330738.0 ave      330738 max      330738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330738
Ave neighs/atom = 82.684500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.336087921824, Press = -1.77839262266271
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13076.838   -13076.838   -13250.002   -13250.002    334.99661    334.99661    67780.569    67780.569    41.035456    41.035456 
   32000   -13077.002   -13077.002   -13249.599   -13249.599    333.90034    333.90034    67783.426    67783.426    10.901994    10.901994 
Loop time of 250.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.346 ns/day, 69.463 hours/ns, 3.999 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    | 249.16     | 249.16     | 249.16     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14512    | 0.14512    | 0.14512    |   0.0 |  0.06
Output  | 0.00018306 | 0.00018306 | 0.00018306 |   0.0 |  0.00
Modify  | 0.66383    | 0.66383    | 0.66383    |   0.0 |  0.27
Other   |            | 0.098      |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330886.0 ave      330886 max      330886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330886
Ave neighs/atom = 82.721500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.27919764338, Press = 2.10010468332908
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13077.002   -13077.002   -13249.599   -13249.599    333.90034    333.90034    67783.426    67783.426    10.901994    10.901994 
   33000   -13079.794   -13079.794   -13248.682   -13248.682    326.72453    326.72453    67815.098    67815.098   -258.19497   -258.19497 
Loop time of 251.876 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.343 ns/day, 69.966 hours/ns, 3.970 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    | 250.96     | 250.96     | 250.96     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.146      | 0.146      | 0.146      |   0.0 |  0.06
Output  | 0.00017967 | 0.00017967 | 0.00017967 |   0.0 |  0.00
Modify  | 0.67097    | 0.67097    | 0.67097    |   0.0 |  0.27
Other   |            | 0.09779    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330810.0 ave      330810 max      330810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330810
Ave neighs/atom = 82.702500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.187250060971, Press = -0.330438279613992
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13079.794   -13079.794   -13248.682   -13248.682    326.72453    326.72453    67815.098    67815.098   -258.19497   -258.19497 
   34000   -13077.794   -13077.794   -13248.396   -13248.396    330.04181    330.04181    67788.315    67788.315    63.490422    63.490422 
Loop time of 249.82 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.346 ns/day, 69.394 hours/ns, 4.003 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    | 248.92     | 248.92     | 248.92     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14451    | 0.14451    | 0.14451    |   0.0 |  0.06
Output  | 0.00022626 | 0.00022626 | 0.00022626 |   0.0 |  0.00
Modify  | 0.65936    | 0.65936    | 0.65936    |   0.0 |  0.26
Other   |            | 0.09732    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330650.0 ave      330650 max      330650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330650
Ave neighs/atom = 82.662500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.187961232972, Press = 0.547140177408774
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13077.794   -13077.794   -13248.396   -13248.396    330.04181    330.04181    67788.315    67788.315    63.490422    63.490422 
   35000   -13079.011   -13079.011   -13251.136   -13251.136      332.988      332.988    67758.922    67758.922    153.32946    153.32946 
Loop time of 249.588 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.346 ns/day, 69.330 hours/ns, 4.007 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    | 248.69     | 248.69     | 248.69     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1434     | 0.1434     | 0.1434     |   0.0 |  0.06
Output  | 0.00017606 | 0.00017606 | 0.00017606 |   0.0 |  0.00
Modify  | 0.6604     | 0.6604     | 0.6604     |   0.0 |  0.26
Other   |            | 0.09753    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330878.0 ave      330878 max      330878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330878
Ave neighs/atom = 82.719500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.209541240771, Press = -0.223083159655454
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13079.011   -13079.011   -13251.136   -13251.136      332.988      332.988    67758.922    67758.922    153.32946    153.32946 
   36000     -13080.9     -13080.9   -13250.629   -13250.629    328.35204    328.35204    67795.828    67795.828   -199.66522   -199.66522 
Loop time of 249.532 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.346 ns/day, 69.314 hours/ns, 4.008 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    | 248.63     | 248.63     | 248.63     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14367    | 0.14367    | 0.14367    |   0.0 |  0.06
Output  | 0.00017581 | 0.00017581 | 0.00017581 |   0.0 |  0.00
Modify  | 0.6595     | 0.6595     | 0.6595     |   0.0 |  0.26
Other   |            | 0.09684    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      331030.0 ave      331030 max      331030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331030
Ave neighs/atom = 82.757500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.208803680961, Press = 0.515637748770125
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000     -13080.9     -13080.9   -13250.629   -13250.629    328.35204    328.35204    67795.828    67795.828   -199.66522   -199.66522 
   37000   -13075.718   -13075.718   -13248.326   -13248.326    333.92077    333.92077    67791.152    67791.152    101.98589    101.98589 
Loop time of 249.338 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.347 ns/day, 69.261 hours/ns, 4.011 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    | 248.44     | 248.44     | 248.44     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14411    | 0.14411    | 0.14411    |   0.0 |  0.06
Output  | 0.00018105 | 0.00018105 | 0.00018105 |   0.0 |  0.00
Modify  | 0.65828    | 0.65828    | 0.65828    |   0.0 |  0.26
Other   |            | 0.09804    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330704.0 ave      330704 max      330704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330704
Ave neighs/atom = 82.676000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.206914522432, Press = -0.423383837078422
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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13075.718   -13075.718   -13248.326   -13248.326    333.92077    333.92077    67791.152    67791.152    101.98589    101.98589 
   38000   -13080.967   -13080.967   -13252.964   -13252.964    332.74087    332.74087    67772.738    67772.738   -141.40993   -141.40993 
Loop time of 249.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.347 ns/day, 69.212 hours/ns, 4.013 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    | 248.26     | 248.26     | 248.26     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14349    | 0.14349    | 0.14349    |   0.0 |  0.06
Output  | 0.00021715 | 0.00021715 | 0.00021715 |   0.0 |  0.00
Modify  | 0.65906    | 0.65906    | 0.65906    |   0.0 |  0.26
Other   |            | 0.09707    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      330760.0 ave      330760 max      330760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0