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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.613315671682358*${_u_distance}
variable latticeconst_converted equal 3.613315671682358*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331567168236
Lattice spacing in x,y,z = 3.6133157 3.6133157 3.6133157
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 (36.133157 36.133157 36.133157)
  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 (36.133157 36.133157 36.133157)
  create_atoms CPU = 0.007 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JeongParkDo_2018_PdCu__MO_353393547686_001
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6305927869 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_353393547686_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -14008.467   -14008.467       -14160       -14160       293.15       293.15    47175.631    47175.631    3430.8896    3430.8896 
    1000   -13849.002   -13849.002   -14003.684   -14003.684    299.24183    299.24183    48019.328    48019.328   -2367.7421   -2367.7421 
Loop time of 262.027 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.330 ns/day, 72.785 hours/ns, 3.816 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    | 261.12     | 261.12     | 261.12     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14811    | 0.14811    | 0.14811    |   0.0 |  0.06
Output  | 0.00029956 | 0.00029956 | 0.00029956 |   0.0 |  0.00
Modify  | 0.66392    | 0.66392    | 0.66392    |   0.0 |  0.25
Other   |            | 0.09682    |            |       |  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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13849.002   -13849.002   -14003.684   -14003.684    299.24183    299.24183    48019.328    48019.328   -2367.7421   -2367.7421 
    2000   -13859.305   -13859.305   -14012.236   -14012.236    295.85458    295.85458    47901.143    47901.143    142.63061    142.63061 
Loop time of 304.433 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.565 hours/ns, 3.285 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    | 303.34     | 303.34     | 303.34     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16667    | 0.16667    | 0.16667    |   0.0 |  0.05
Output  | 0.00021237 | 0.00021237 | 0.00021237 |   0.0 |  0.00
Modify  | 0.81989    | 0.81989    | 0.81989    |   0.0 |  0.27
Other   |            | 0.1078     |            |       |  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:      343446.0 ave      343446 max      343446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343446
Ave neighs/atom = 85.861500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13859.305   -13859.305   -14012.236   -14012.236    295.85458    295.85458    47901.143    47901.143    142.63061    142.63061 
    3000   -13856.435   -13856.435   -14011.373   -14011.373    299.73786    299.73786    47942.165    47942.165    -746.1661    -746.1661 
Loop time of 289.18 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.299 ns/day, 80.328 hours/ns, 3.458 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    | 288.15     | 288.15     | 288.15     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15803    | 0.15803    | 0.15803    |   0.0 |  0.05
Output  | 0.00021215 | 0.00021215 | 0.00021215 |   0.0 |  0.00
Modify  | 0.76298    | 0.76298    | 0.76298    |   0.0 |  0.26
Other   |            | 0.1044     |            |       |  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:      343626.0 ave      343626 max      343626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343626
Ave neighs/atom = 85.906500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13856.435   -13856.435   -14011.373   -14011.373    299.73786    299.73786    47942.165    47942.165    -746.1661    -746.1661 
    4000   -13856.343   -13856.343   -14007.995   -14007.995    293.38063    293.38063    47939.837    47939.837   -455.49559   -455.49559 
Loop time of 259.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.147 hours/ns, 3.850 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    | 258.86     | 258.86     | 258.86     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14183    | 0.14183    | 0.14183    |   0.0 |  0.05
Output  | 0.00021265 | 0.00021265 | 0.00021265 |   0.0 |  0.00
Modify  | 0.63179    | 0.63179    | 0.63179    |   0.0 |  0.24
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:      343674.0 ave      343674 max      343674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343674
Ave neighs/atom = 85.918500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13856.343   -13856.343   -14007.995   -14007.995    293.38063    293.38063    47939.837    47939.837   -455.49559   -455.49559 
    5000   -13859.978   -13859.978   -14007.154   -14007.154    284.72244    284.72244    47898.374    47898.374    826.36592    826.36592 
Loop time of 259.785 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.162 hours/ns, 3.849 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    | 258.91     | 258.91     | 258.91     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14326    | 0.14326    | 0.14326    |   0.0 |  0.06
Output  | 0.00017733 | 0.00017733 | 0.00017733 |   0.0 |  0.00
Modify  | 0.63631    | 0.63631    | 0.63631    |   0.0 |  0.24
Other   |            | 0.09586    |            |       |  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:      343590.0 ave      343590 max      343590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343590
Ave neighs/atom = 85.897500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.810508035216, Press = 334.949275819644
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13859.978   -13859.978   -14007.154   -14007.154    284.72244    284.72244    47898.374    47898.374    826.36592    826.36592 
    6000   -13853.348   -13853.348   -14008.924   -14008.924    300.97202    300.97202    47960.439    47960.439   -939.92797   -939.92797 
Loop time of 261.084 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.523 hours/ns, 3.830 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    | 260.19     | 260.19     | 260.19     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14614    | 0.14614    | 0.14614    |   0.0 |  0.06
Output  | 0.00022106 | 0.00022106 | 0.00022106 |   0.0 |  0.00
Modify  | 0.65703    | 0.65703    | 0.65703    |   0.0 |  0.25
Other   |            | 0.09247    |            |       |  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:      343702.0 ave      343702 max      343702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343702
Ave neighs/atom = 85.925500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.542087686019, Press = -15.9123726181298
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13853.348   -13853.348   -14008.924   -14008.924    300.97202    300.97202    47960.439    47960.439   -939.92797   -939.92797 
    7000   -13859.988   -13859.988   -14009.647   -14009.647    289.52612    289.52612    47858.292    47858.292    1789.3855    1789.3855 
Loop time of 270.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.320 ns/day, 75.038 hours/ns, 3.702 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    | 269.2      | 269.2      | 269.2      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15128    | 0.15128    | 0.15128    |   0.0 |  0.06
Output  | 0.00017843 | 0.00017843 | 0.00017843 |   0.0 |  0.00
Modify  | 0.69335    | 0.69335    | 0.69335    |   0.0 |  0.26
Other   |            | 0.09566    |            |       |  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:      343668.0 ave      343668 max      343668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343668
Ave neighs/atom = 85.917000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.973491900616, Press = 30.9873228950397
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13859.988   -13859.988   -14009.647   -14009.647    289.52612    289.52612    47858.292    47858.292    1789.3855    1789.3855 
    8000   -13858.608   -13858.608   -14007.995   -14007.995     289.0005     289.0005    47971.786    47971.786   -1397.5372   -1397.5372 
Loop time of 293.325 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.295 ns/day, 81.479 hours/ns, 3.409 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    | 292.26     | 292.26     | 292.26     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16203    | 0.16203    | 0.16203    |   0.0 |  0.06
Output  | 0.0002209  | 0.0002209  | 0.0002209  |   0.0 |  0.00
Modify  | 0.79618    | 0.79618    | 0.79618    |   0.0 |  0.27
Other   |            | 0.104      |            |       |  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:      343708.0 ave      343708 max      343708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343708
Ave neighs/atom = 85.927000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.062142328213, Press = -12.2121269475795
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13858.608   -13858.608   -14007.995   -14007.995     289.0005     289.0005    47971.786    47971.786   -1397.5372   -1397.5372 
    9000   -13855.399   -13855.399   -14005.368   -14005.368    290.12676    290.12676    47901.193    47901.193    1019.3242    1019.3242 
Loop time of 264.774 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.548 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.85     | 263.85     | 263.85     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14737    | 0.14737    | 0.14737    |   0.0 |  0.06
Output  | 0.0001806  | 0.0001806  | 0.0001806  |   0.0 |  0.00
Modify  | 0.67652    | 0.67652    | 0.67652    |   0.0 |  0.26
Other   |            | 0.09632    |            |       |  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:      343568.0 ave      343568 max      343568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343568
Ave neighs/atom = 85.892000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.743709717224, Press = 11.5910484547744
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13855.399   -13855.399   -14005.368   -14005.368    290.12676    290.12676    47901.193    47901.193    1019.3242    1019.3242 
   10000   -13858.393   -13858.393   -14007.834   -14007.834     289.1043     289.1043     47922.37     47922.37    94.822125    94.822125 
Loop time of 298.371 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.290 ns/day, 82.881 hours/ns, 3.352 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    | 297.3      | 297.3      | 297.3      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16265    | 0.16265    | 0.16265    |   0.0 |  0.05
Output  | 0.00017956 | 0.00017956 | 0.00017956 |   0.0 |  0.00
Modify  | 0.80019    | 0.80019    | 0.80019    |   0.0 |  0.27
Other   |            | 0.1044     |            |       |  0.03

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

Total # of neighbors = 343698
Ave neighs/atom = 85.924500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.911950134913, Press = -0.976361985884522
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13858.393   -13858.393   -14007.834   -14007.834     289.1043     289.1043     47922.37     47922.37    94.822125    94.822125 
   11000   -13858.431   -13858.431   -14007.173   -14007.173    287.75083    287.75083    47929.502    47929.502   -88.990609   -88.990609 
Loop time of 294.481 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.293 ns/day, 81.800 hours/ns, 3.396 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    | 293.42     | 293.42     | 293.42     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16081    | 0.16081    | 0.16081    |   0.0 |  0.05
Output  | 0.00023222 | 0.00023222 | 0.00023222 |   0.0 |  0.00
Modify  | 0.79284    | 0.79284    | 0.79284    |   0.0 |  0.27
Other   |            | 0.1042     |            |       |  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:      343644.0 ave      343644 max      343644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343644
Ave neighs/atom = 85.911000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.236942720905, Press = 3.6759709403494
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13858.431   -13858.431   -14007.173   -14007.173    287.75083    287.75083    47929.502    47929.502   -88.990609   -88.990609 
   12000   -13854.762   -13854.762   -14006.923   -14006.923    294.36645    294.36645    47909.753    47909.753    638.66823    638.66823 
Loop time of 292.783 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.295 ns/day, 81.328 hours/ns, 3.416 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    | 291.71     | 291.71     | 291.71     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16307    | 0.16307    | 0.16307    |   0.0 |  0.06
Output  | 0.00017638 | 0.00017638 | 0.00017638 |   0.0 |  0.00
Modify  | 0.80575    | 0.80575    | 0.80575    |   0.0 |  0.28
Other   |            | 0.1059     |            |       |  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:      343636.0 ave      343636 max      343636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343636
Ave neighs/atom = 85.909000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.033868402407, Press = -0.698041749251656
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13854.762   -13854.762   -14006.923   -14006.923    294.36645    294.36645    47909.753    47909.753    638.66823    638.66823 
   13000   -13859.422   -13859.422   -14009.659   -14009.659    290.64395    290.64395    47968.384    47968.384   -1362.0543   -1362.0543 
Loop time of 271.156 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.319 ns/day, 75.321 hours/ns, 3.688 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    | 270.2      | 270.2      | 270.2      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15335    | 0.15335    | 0.15335    |   0.0 |  0.06
Output  | 0.00018367 | 0.00018367 | 0.00018367 |   0.0 |  0.00
Modify  | 0.70369    | 0.70369    | 0.70369    |   0.0 |  0.26
Other   |            | 0.09793    |            |       |  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:      343624.0 ave      343624 max      343624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343624
Ave neighs/atom = 85.906000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.981741037338, Press = 0.914655855363137
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13859.422   -13859.422   -14009.659   -14009.659    290.64395    290.64395    47968.384    47968.384   -1362.0543   -1362.0543 
   14000   -13856.537   -13856.537   -14006.477   -14006.477    290.06877    290.06877     47874.41     47874.41     1695.318     1695.318 
Loop time of 305.698 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.916 hours/ns, 3.271 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 304.58     | 304.58     | 304.58     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16667    | 0.16667    | 0.16667    |   0.0 |  0.05
Output  | 0.00025797 | 0.00025797 | 0.00025797 |   0.0 |  0.00
Modify  | 0.84523    | 0.84523    | 0.84523    |   0.0 |  0.28
Other   |            | 0.1078     |            |       |  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:      343572.0 ave      343572 max      343572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343572
Ave neighs/atom = 85.893000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.934163240347, Press = 3.07305161123728
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13856.537   -13856.537   -14006.477   -14006.477    290.06877    290.06877     47874.41     47874.41     1695.318     1695.318 
   15000   -13861.279   -13861.279   -14010.735   -14010.735    289.13388    289.13388    47983.159    47983.159   -1953.9122   -1953.9122 
Loop time of 291.359 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.297 ns/day, 80.933 hours/ns, 3.432 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    | 290.3      | 290.3      | 290.3      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16116    | 0.16116    | 0.16116    |   0.0 |  0.06
Output  | 0.0024994  | 0.0024994  | 0.0024994  |   0.0 |  0.00
Modify  | 0.7918     | 0.7918     | 0.7918     |   0.0 |  0.27
Other   |            | 0.1044     |            |       |  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:      343852.0 ave      343852 max      343852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343852
Ave neighs/atom = 85.963000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.769445537139, Press = -1.42554270951134
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13861.279   -13861.279   -14010.735   -14010.735    289.13388    289.13388    47983.159    47983.159   -1953.9122   -1953.9122 
   16000   -13851.739   -13851.739   -14004.765   -14004.765    296.03912    296.03912    47877.901    47877.901    1870.4893    1870.4893 
Loop time of 298.286 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.290 ns/day, 82.857 hours/ns, 3.352 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    | 297.18     | 297.18     | 297.18     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16516    | 0.16516    | 0.16516    |   0.0 |  0.06
Output  | 0.00021881 | 0.00021881 | 0.00021881 |   0.0 |  0.00
Modify  | 0.82884    | 0.82884    | 0.82884    |   0.0 |  0.28
Other   |            | 0.1071     |            |       |  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:      343604.0 ave      343604 max      343604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343604
Ave neighs/atom = 85.901000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.820059393291, Press = 3.36151582818281
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13851.739   -13851.739   -14004.765   -14004.765    296.03912    296.03912    47877.901    47877.901    1870.4893    1870.4893 
   17000   -13858.183   -13858.183   -14010.144   -14010.144    293.97788    293.97788    47937.008    47937.008   -458.62444   -458.62444 
Loop time of 284.2 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.304 ns/day, 78.944 hours/ns, 3.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 283.19     | 283.19     | 283.19     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15896    | 0.15896    | 0.15896    |   0.0 |  0.06
Output  | 0.00022023 | 0.00022023 | 0.00022023 |   0.0 |  0.00
Modify  | 0.75182    | 0.75182    | 0.75182    |   0.0 |  0.26
Other   |            | 0.1007     |            |       |  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:      343788.0 ave      343788 max      343788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343788
Ave neighs/atom = 85.947000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.992581872004, Press = -0.523202885833159
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13858.183   -13858.183   -14010.144   -14010.144    293.97788    293.97788    47937.008    47937.008   -458.62444   -458.62444 
   18000     -13850.5     -13850.5   -14004.765   -14004.765    298.43705    298.43705    47931.773    47931.773    288.77824    288.77824 
Loop time of 260.682 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.412 hours/ns, 3.836 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    | 259.77     | 259.77     | 259.77     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1482     | 0.1482     | 0.1482     |   0.0 |  0.06
Output  | 0.00022384 | 0.00022384 | 0.00022384 |   0.0 |  0.00
Modify  | 0.66531    | 0.66531    | 0.66531    |   0.0 |  0.26
Other   |            | 0.09451    |            |       |  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:      343572.0 ave      343572 max      343572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343572
Ave neighs/atom = 85.893000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.07256874739, Press = 1.65838257879933
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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     -13850.5     -13850.5   -14004.765   -14004.765    298.43705    298.43705    47931.773    47931.773    288.77824    288.77824 
   19000   -13859.869   -13859.869    -14009.39    -14009.39    289.25761    289.25761    47945.041    47945.041   -636.75803   -636.75803 
Loop time of 305.476 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.854 hours/ns, 3.274 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 304.34     | 304.34     | 304.34     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16826    | 0.16826    | 0.16826    |   0.0 |  0.06
Output  | 0.00022891 | 0.00022891 | 0.00022891 |   0.0 |  0.00
Modify  | 0.86142    | 0.86142    | 0.86142    |   0.0 |  0.28
Other   |            | 0.1091     |            |       |  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:      343592.0 ave      343592 max      343592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343592
Ave neighs/atom = 85.898000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.155222615838, Press = 0.668963589174908
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13859.869   -13859.869    -14009.39    -14009.39    289.25761    289.25761    47945.041    47945.041   -636.75803   -636.75803 
   20000   -13853.426   -13853.426   -14006.251   -14006.251    295.65078    295.65078    47895.379    47895.379    1150.9666    1150.9666 
Loop time of 303.667 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.352 hours/ns, 3.293 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    | 302.56     | 302.56     | 302.56     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16775    | 0.16775    | 0.16775    |   0.0 |  0.06
Output  | 0.00023503 | 0.00023503 | 0.00023503 |   0.0 |  0.00
Modify  | 0.83556    | 0.83556    | 0.83556    |   0.0 |  0.28
Other   |            | 0.1076     |            |       |  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:      343592.0 ave      343592 max      343592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343592
Ave neighs/atom = 85.898000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.187278673848, Press = 2.77233821256052
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13853.426   -13853.426   -14006.251   -14006.251    295.65078    295.65078    47895.379    47895.379    1150.9666    1150.9666 
   21000   -13854.626   -13854.626   -14006.631   -14006.631    294.06463    294.06463    47972.837    47972.837   -1168.5945   -1168.5945 
Loop time of 300.537 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.287 ns/day, 83.482 hours/ns, 3.327 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 299.45     | 299.45     | 299.45     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.165      | 0.165      | 0.165      |   0.0 |  0.05
Output  | 0.00018044 | 0.00018044 | 0.00018044 |   0.0 |  0.00
Modify  | 0.81474    | 0.81474    | 0.81474    |   0.0 |  0.27
Other   |            | 0.1055     |            |       |  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:      343644.0 ave      343644 max      343644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343644
Ave neighs/atom = 85.911000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.217465886502, Press = -1.44676753330782
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13854.626   -13854.626   -14006.631   -14006.631    294.06463    294.06463    47972.837    47972.837   -1168.5945   -1168.5945 
   22000   -13858.099   -13858.099   -14009.719   -14009.719    293.31847    293.31847     47871.56     47871.56    1358.2826    1358.2826 
Loop time of 296.988 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.291 ns/day, 82.497 hours/ns, 3.367 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    | 295.91     | 295.91     | 295.91     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16399    | 0.16399    | 0.16399    |   0.0 |  0.06
Output  | 0.0002228  | 0.0002228  | 0.0002228  |   0.0 |  0.00
Modify  | 0.81202    | 0.81202    | 0.81202    |   0.0 |  0.27
Other   |            | 0.1044     |            |       |  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:      343518.0 ave      343518 max      343518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343518
Ave neighs/atom = 85.879500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.21084037052, Press = 2.82231423450495
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13858.099   -13858.099   -14009.719   -14009.719    293.31847    293.31847     47871.56     47871.56    1358.2826    1358.2826 
   23000   -13856.441   -13856.441   -14006.816   -14006.816    290.90936    290.90936    47955.265    47955.265   -721.31107   -721.31107 
Loop time of 261.132 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.537 hours/ns, 3.829 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    | 260.22     | 260.22     | 260.22     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14859    | 0.14859    | 0.14859    |   0.0 |  0.06
Output  | 0.00018096 | 0.00018096 | 0.00018096 |   0.0 |  0.00
Modify  | 0.66618    | 0.66618    | 0.66618    |   0.0 |  0.26
Other   |            | 0.09345    |            |       |  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:      343746.0 ave      343746 max      343746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343746
Ave neighs/atom = 85.936500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.325755101688, Press = -1.21476438095897
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13856.441   -13856.441   -14006.816   -14006.816    290.90936    290.90936    47955.265    47955.265   -721.31107   -721.31107 
   24000   -13853.626   -13853.626   -14005.966   -14005.966    294.71208    294.71208    47876.085    47876.085    1693.5771    1693.5771 
Loop time of 261.027 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.507 hours/ns, 3.831 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    | 260.12     | 260.12     | 260.12     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15004    | 0.15004    | 0.15004    |   0.0 |  0.06
Output  | 0.00017903 | 0.00017903 | 0.00017903 |   0.0 |  0.00
Modify  | 0.66624    | 0.66624    | 0.66624    |   0.0 |  0.26
Other   |            | 0.09313    |            |       |  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:      343638.0 ave      343638 max      343638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343638
Ave neighs/atom = 85.909500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.347903874415, Press = 2.29377331837921
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13853.626   -13853.626   -14005.966   -14005.966    294.71208    294.71208    47876.085    47876.085    1693.5771    1693.5771 
   25000    -13861.25    -13861.25   -14011.144   -14011.144    289.98124    289.98124    47979.594    47979.594    -1903.239    -1903.239 
Loop time of 303.253 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.237 hours/ns, 3.298 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    | 302.14     | 302.14     | 302.14     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16768    | 0.16768    | 0.16768    |   0.0 |  0.06
Output  | 0.0002461  | 0.0002461  | 0.0002461  |   0.0 |  0.00
Modify  | 0.84288    | 0.84288    | 0.84288    |   0.0 |  0.28
Other   |            | 0.1066     |            |       |  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:      343738.0 ave      343738 max      343738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343738
Ave neighs/atom = 85.934500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.387961946568, Press = -2.81031894079745
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -13861.25    -13861.25   -14011.144   -14011.144    289.98124    289.98124    47979.594    47979.594    -1903.239    -1903.239 
   26000   -13854.304   -13854.304   -14006.043   -14006.043    293.54981    293.54981    47890.086    47890.086     1249.718     1249.718 
Loop time of 304.892 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.692 hours/ns, 3.280 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    | 303.79     | 303.79     | 303.79     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16662    | 0.16662    | 0.16662    |   0.0 |  0.05
Output  | 0.00023334 | 0.00023334 | 0.00023334 |   0.0 |  0.00
Modify  | 0.82779    | 0.82779    | 0.82779    |   0.0 |  0.27
Other   |            | 0.1065     |            |       |  0.03

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

Total # of neighbors = 343574
Ave neighs/atom = 85.893500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.358726382064, Press = 2.58239365540318
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13854.304   -13854.304   -14006.043   -14006.043    293.54981    293.54981    47890.086    47890.086     1249.718     1249.718 
   27000   -13859.627   -13859.627   -14010.079   -14010.079    291.06002    291.06002    47938.207    47938.207   -616.63842   -616.63842 
Loop time of 295.925 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.292 ns/day, 82.201 hours/ns, 3.379 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    | 294.86     | 294.86     | 294.86     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16174    | 0.16174    | 0.16174    |   0.0 |  0.05
Output  | 0.00023031 | 0.00023031 | 0.00023031 |   0.0 |  0.00
Modify  | 0.79506    | 0.79506    | 0.79506    |   0.0 |  0.27
Other   |            | 0.104      |            |       |  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:      343736.0 ave      343736 max      343736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343736
Ave neighs/atom = 85.934000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.306198408149, Press = -0.508944188543391
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13859.627   -13859.627   -14010.079   -14010.079    291.06002    291.06002    47938.207    47938.207   -616.63842   -616.63842 
   28000   -13852.057   -13852.057   -14005.993   -14005.993    297.79902    297.79902    47910.629    47910.629    647.88324    647.88324 
Loop time of 303.332 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.259 hours/ns, 3.297 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 302.25     | 302.25     | 302.25     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16478    | 0.16478    | 0.16478    |   0.0 |  0.05
Output  | 0.00033485 | 0.00033485 | 0.00033485 |   0.0 |  0.00
Modify  | 0.80968    | 0.80968    | 0.80968    |   0.0 |  0.27
Other   |            | 0.1046     |            |       |  0.03

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

Total # of neighbors = 343670
Ave neighs/atom = 85.917500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.373897860227, Press = 1.38728768990959
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13852.057   -13852.057   -14005.993   -14005.993    297.79902    297.79902    47910.629    47910.629    647.88324    647.88324 
   29000   -13857.402   -13857.402   -14006.768   -14006.768    288.95821    288.95821    47919.845    47919.845    248.68655    248.68655 
Loop time of 304.735 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.649 hours/ns, 3.282 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 303.61     | 303.61     | 303.61     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16801    | 0.16801    | 0.16801    |   0.0 |  0.06
Output  | 0.00017931 | 0.00017931 | 0.00017931 |   0.0 |  0.00
Modify  | 0.85221    | 0.85221    | 0.85221    |   0.0 |  0.28
Other   |            | 0.1093     |            |       |  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:      343644.0 ave      343644 max      343644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343644
Ave neighs/atom = 85.911000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.389402265945, Press = -0.424323773677643
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13857.402   -13857.402   -14006.768   -14006.768    288.95821    288.95821    47919.845    47919.845    248.68655    248.68655 
   30000    -13861.22    -13861.22   -14009.841   -14009.841    287.51833    287.51833    47954.909    47954.909   -1098.7666   -1098.7666 
Loop time of 261.087 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.524 hours/ns, 3.830 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    | 260.18     | 260.18     | 260.18     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14815    | 0.14815    | 0.14815    |   0.0 |  0.06
Output  | 0.00022129 | 0.00022129 | 0.00022129 |   0.0 |  0.00
Modify  | 0.66178    | 0.66178    | 0.66178    |   0.0 |  0.25
Other   |            | 0.0928     |            |       |  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:      343678.0 ave      343678 max      343678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343678
Ave neighs/atom = 85.919500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.373712892971, Press = 3.14225124605976
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -13861.22    -13861.22   -14009.841   -14009.841    287.51833    287.51833    47954.909    47954.909   -1098.7666   -1098.7666 
   31000    -13854.77    -13854.77   -14008.099   -14008.099    296.62518    296.62518    47889.499    47889.499    1186.0917    1186.0917 
Loop time of 260.67 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.408 hours/ns, 3.836 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    | 259.77     | 259.77     | 259.77     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14768    | 0.14768    | 0.14768    |   0.0 |  0.06
Output  | 0.00017789 | 0.00017789 | 0.00017789 |   0.0 |  0.00
Modify  | 0.66052    | 0.66052    | 0.66052    |   0.0 |  0.25
Other   |            | 0.0937     |            |       |  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:      343628.0 ave      343628 max      343628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343628
Ave neighs/atom = 85.907000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.336400616444, Press = -1.25381840450289
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -13854.77    -13854.77   -14008.099   -14008.099    296.62518    296.62518    47889.499    47889.499    1186.0917    1186.0917 
   32000   -13860.279   -13860.279     -14008.7     -14008.7    287.13215    287.13215    47940.347    47940.347   -521.07659   -521.07659 
Loop time of 260.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.379 hours/ns, 3.838 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    | 259.66     | 259.66     | 259.66     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14694    | 0.14694    | 0.14694    |   0.0 |  0.06
Output  | 0.00017943 | 0.00017943 | 0.00017943 |   0.0 |  0.00
Modify  | 0.66051    | 0.66051    | 0.66051    |   0.0 |  0.25
Other   |            | 0.09338    |            |       |  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:      343696.0 ave      343696 max      343696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343696
Ave neighs/atom = 85.924000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.29296991909, Press = 1.6921403847103
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13860.279   -13860.279     -14008.7     -14008.7    287.13215    287.13215    47940.347    47940.347   -521.07659   -521.07659 
   33000   -13858.362   -13858.362   -14011.038   -14011.038    295.36248    295.36248    47910.197    47910.197    82.308795    82.308795 
Loop time of 260.772 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.437 hours/ns, 3.835 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    | 259.87     | 259.87     | 259.87     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14755    | 0.14755    | 0.14755    |   0.0 |  0.06
Output  | 0.00021723 | 0.00021723 | 0.00021723 |   0.0 |  0.00
Modify  | 0.66101    | 0.66101    | 0.66101    |   0.0 |  0.25
Other   |            | 0.09325    |            |       |  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:      343728.0 ave      343728 max      343728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343728
Ave neighs/atom = 85.932000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.323254692778, Press = -0.358255437144598
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13858.362   -13858.362   -14011.038   -14011.038    295.36248    295.36248    47910.197    47910.197    82.308795    82.308795 
   34000   -13854.882   -13854.882   -14007.432   -14007.432    295.11835    295.11835    47930.456    47930.456   -31.200061   -31.200061 
Loop time of 260.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.384 hours/ns, 3.838 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    | 259.68     | 259.68     | 259.68     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14712    | 0.14712    | 0.14712    |   0.0 |  0.06
Output  | 0.00017755 | 0.00017755 | 0.00017755 |   0.0 |  0.00
Modify  | 0.65924    | 0.65924    | 0.65924    |   0.0 |  0.25
Other   |            | 0.09397    |            |       |  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:      343658.0 ave      343658 max      343658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343658
Ave neighs/atom = 85.914500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.34797317466, Press = 1.44306483325198
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13854.882   -13854.882   -14007.432   -14007.432    295.11835    295.11835    47930.456    47930.456   -31.200061   -31.200061 
   35000    -13857.07    -13857.07   -14007.312   -14007.312    290.65313    290.65313     47930.86     47930.86   -89.569711   -89.569711 
Loop time of 290.973 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.297 ns/day, 80.826 hours/ns, 3.437 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    | 289.92     | 289.92     | 289.92     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16262    | 0.16262    | 0.16262    |   0.0 |  0.06
Output  | 0.0001793  | 0.0001793  | 0.0001793  |   0.0 |  0.00
Modify  | 0.78381    | 0.78381    | 0.78381    |   0.0 |  0.27
Other   |            | 0.1036     |            |       |  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:      343626.0 ave      343626 max      343626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343626
Ave neighs/atom = 85.906500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.412429353061, Press = -0.33708585544706
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -13857.07    -13857.07   -14007.312   -14007.312    290.65313    290.65313     47930.86     47930.86   -89.569711   -89.569711 
   36000   -13855.487   -13855.487   -14007.006   -14007.006    293.12326    293.12326    47888.804    47888.804    1161.3878    1161.3878 
Loop time of 305.542 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.873 hours/ns, 3.273 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 304.43     | 304.43     | 304.43     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16906    | 0.16906    | 0.16906    |   0.0 |  0.06
Output  | 0.0001812  | 0.0001812  | 0.0001812  |   0.0 |  0.00
Modify  | 0.83606    | 0.83606    | 0.83606    |   0.0 |  0.27
Other   |            | 0.106      |            |       |  0.03

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

Total # of neighbors = 343668
Ave neighs/atom = 85.917000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.39028113707, Press = 1.68746853785809
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13855.487   -13855.487   -14007.006   -14007.006    293.12326    293.12326    47888.804    47888.804    1161.3878    1161.3878 
   37000   -13862.347   -13862.347   -14010.969   -14010.969    287.52003    287.52003    47954.353    47954.353   -1165.5025   -1165.5025 
Loop time of 297.72 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.290 ns/day, 82.700 hours/ns, 3.359 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 296.62     | 296.62     | 296.62     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16615    | 0.16615    | 0.16615    |   0.0 |  0.06
Output  | 0.00018405 | 0.00018405 | 0.00018405 |   0.0 |  0.00
Modify  | 0.82797    | 0.82797    | 0.82797    |   0.0 |  0.28
Other   |            | 0.1057     |            |       |  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:      343716.0 ave      343716 max      343716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343716
Ave neighs/atom = 85.929000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.328945738989, Press = -1.17811743123879
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13862.347   -13862.347   -14010.969   -14010.969    287.52003    287.52003    47954.353    47954.353   -1165.5025   -1165.5025 
   38000   -13854.886   -13854.886   -14006.685   -14006.685    293.66552    293.66552    47884.836    47884.836    1338.3008    1338.3008 
Loop time of 260.648 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.402 hours/ns, 3.837 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    | 259.75     | 259.75     | 259.75     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14755    | 0.14755    | 0.14755    |   0.0 |  0.06
Output  | 0.00017856 | 0.00017856 | 0.00017856 |   0.0 |  0.00
Modify  | 0.65934    | 0.65934    | 0.65934    |   0.0 |  0.25
Other   |            | 0.09271    |            |       |  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:      343594.0 ave      343594 max      343594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343594
Ave neighs/atom = 85.898500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.285908309989, Press = 1.62661206592487
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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 
   38000   -13854.886   -13854.886   -14006.685   -14006.685    293.66552    293.66552    47884.836    47884.836    1338.3008    1338.3008 
   39000   -13856.522   -13856.522   -14006.811   -14006.811    290.74454    290.74454    47935.042    47935.042   -97.260782   -97.260782 
Loop time of 260.813 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.448 hours/ns, 3.834 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    | 259.91     | 259.91     | 259.91     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14721    | 0.14721    | 0.14721    |   0.0 |  0.06
Output  | 0.00018071 | 0.00018071 | 0.00018071 |   0.0 |  0.00
Modify  | 0.65901    | 0.65901    | 0.65901    |   0.0 |  0.25
Other   |            | 0.09403    |            |       |  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:      343730.0 ave      343730 max      343730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343730
Ave neighs/atom = 85.932500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
47924.6210770887

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0