# 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 195.078*${_u_mass}
variable mass_converted equal 195.078*1

kim_interactions Pt

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

kim interactions Pt
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtCu__MO_070797404269_001
pair_coeff * * Pt
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 195.078

# 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_070797404269_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.9036    3430.9036 
    1000   -13843.211   -13843.211   -14003.047   -14003.047    309.21216    309.21216    47829.723    47829.723    2400.5555    2400.5555 
Loop time of 270.699 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.319 ns/day, 75.194 hours/ns, 3.694 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    | 269.75     | 269.75     | 269.75     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15209    | 0.15209    | 0.15209    |   0.0 |  0.06
Output  | 0.00022758 | 0.00022758 | 0.00022758 |   0.0 |  0.00
Modify  | 0.70131    | 0.70131    | 0.70131    |   0.0 |  0.26
Other   |            | 0.09906    |            |       |  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   -13843.211   -13843.211   -14003.047   -14003.047    309.21216    309.21216    47829.723    47829.723    2400.5555    2400.5555 
    2000   -13862.499   -13862.499   -14004.076   -14004.076    273.89072    273.89072    47886.537    47886.537   -715.59251   -715.59251 
Loop time of 278.428 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.310 ns/day, 77.341 hours/ns, 3.592 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    | 277.46     | 277.46     | 277.46     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15412    | 0.15412    | 0.15412    |   0.0 |  0.06
Output  | 0.0002152  | 0.0002152  | 0.0002152  |   0.0 |  0.00
Modify  | 0.71096    | 0.71096    | 0.71096    |   0.0 |  0.26
Other   |            | 0.1005     |            |       |  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:      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 = 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   -13862.499   -13862.499   -14004.076   -14004.076    273.89072    273.89072    47886.537    47886.537   -715.59251   -715.59251 
    3000   -13850.114   -13850.114   -14003.292   -14003.292    296.33272    296.33272    47881.957    47881.957   -55.170957   -55.170957 
Loop time of 281.896 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.306 ns/day, 78.304 hours/ns, 3.547 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    | 280.91     | 280.91     | 280.91     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15619    | 0.15619    | 0.15619    |   0.0 |  0.06
Output  | 0.00025878 | 0.00025878 | 0.00025878 |   0.0 |  0.00
Modify  | 0.73369    | 0.73369    | 0.73369    |   0.0 |  0.26
Other   |            | 0.1005     |            |       |  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:      343694.0 ave      343694 max      343694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343694
Ave neighs/atom = 85.923500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -13850.114   -13850.114   -14003.292   -14003.292    296.33272    296.33272    47881.957    47881.957   -55.170957   -55.170957 
    4000   -13862.127   -13862.127   -14009.409   -14009.409    284.92716    284.92716    47820.717    47820.717    1379.6995    1379.6995 
Loop time of 282.31 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.306 ns/day, 78.419 hours/ns, 3.542 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    | 281.32     | 281.32     | 281.32     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15619    | 0.15619    | 0.15619    |   0.0 |  0.06
Output  | 0.00028996 | 0.00028996 | 0.00028996 |   0.0 |  0.00
Modify  | 0.73075    | 0.73075    | 0.73075    |   0.0 |  0.26
Other   |            | 0.101      |            |       |  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:      343564.0 ave      343564 max      343564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343564
Ave neighs/atom = 85.891000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -13862.127   -13862.127   -14009.409   -14009.409    284.92716    284.92716    47820.717    47820.717    1379.6995    1379.6995 
    5000   -13849.614   -13849.614   -14004.815   -14004.815    300.24609    300.24609      47896.6      47896.6   -1150.7067   -1150.7067 
Loop time of 282.11 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.306 ns/day, 78.364 hours/ns, 3.545 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    | 281.13     | 281.13     | 281.13     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15469    | 0.15469    | 0.15469    |   0.0 |  0.05
Output  | 0.00023585 | 0.00023585 | 0.00023585 |   0.0 |  0.00
Modify  | 0.72554    | 0.72554    | 0.72554    |   0.0 |  0.26
Other   |            | 0.09949    |            |       |  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 = 300.573014514843, Press = 289.282744230029
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   -13849.614   -13849.614   -14004.815   -14004.815    300.24609    300.24609      47896.6      47896.6   -1150.7067   -1150.7067 
    6000    -13857.52    -13857.52   -14005.141   -14005.141    285.58421    285.58421    47893.653    47893.653   -1179.3247   -1179.3247 
Loop time of 282.788 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.306 ns/day, 78.552 hours/ns, 3.536 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    | 281.78     | 281.78     | 281.78     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15602    | 0.15602    | 0.15602    |   0.0 |  0.06
Output  | 0.0001793  | 0.0001793  | 0.0001793  |   0.0 |  0.00
Modify  | 0.74913    | 0.74913    | 0.74913    |   0.0 |  0.26
Other   |            | 0.1013     |            |       |  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:      343742.0 ave      343742 max      343742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343742
Ave neighs/atom = 85.935500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.248819562928, Press = 35.6113108030283
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    -13857.52    -13857.52   -14005.141   -14005.141    285.58421    285.58421    47893.653    47893.653   -1179.3247   -1179.3247 
    7000   -13853.633   -13853.633   -14007.869   -14007.869    298.37972    298.37972    47848.533    47848.533    673.59156    673.59156 
Loop time of 283.537 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.305 ns/day, 78.760 hours/ns, 3.527 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    | 282.54     | 282.54     | 282.54     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15578    | 0.15578    | 0.15578    |   0.0 |  0.05
Output  | 0.00022666 | 0.00022666 | 0.00022666 |   0.0 |  0.00
Modify  | 0.74595    | 0.74595    | 0.74595    |   0.0 |  0.26
Other   |            | 0.1002     |            |       |  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:      343744.0 ave      343744 max      343744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343744
Ave neighs/atom = 85.936000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.43709945757, Press = 25.2590226447853
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   -13853.633   -13853.633   -14007.869   -14007.869    298.37972    298.37972    47848.533    47848.533    673.59156    673.59156 
    8000   -13860.936   -13860.936   -14007.642   -14007.642    283.81136    283.81136    47820.799    47820.799    1723.2825    1723.2825 
Loop time of 272.964 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.317 ns/day, 75.823 hours/ns, 3.663 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    | 272        | 272        | 272        |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15146    | 0.15146    | 0.15146    |   0.0 |  0.06
Output  | 0.00017966 | 0.00017966 | 0.00017966 |   0.0 |  0.00
Modify  | 0.71835    | 0.71835    | 0.71835    |   0.0 |  0.26
Other   |            | 0.09878    |            |       |  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.083292739769, Press = 24.0703318351823
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   -13860.936   -13860.936   -14007.642   -14007.642    283.81136    283.81136    47820.799    47820.799    1723.2825    1723.2825 
    9000   -13853.789   -13853.789    -14007.12    -14007.12     296.6301     296.6301    47878.835    47878.835   -689.86428   -689.86428 
Loop time of 277.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.312 ns/day, 77.028 hours/ns, 3.606 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    | 276.32     | 276.32     | 276.32     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15353    | 0.15353    | 0.15353    |   0.0 |  0.06
Output  | 0.00016977 | 0.00016977 | 0.00016977 |   0.0 |  0.00
Modify  | 0.72788    | 0.72788    | 0.72788    |   0.0 |  0.26
Other   |            | 0.09965    |            |       |  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:      343756.0 ave      343756 max      343756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343756
Ave neighs/atom = 85.939000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.883362807426, Press = 12.3265330289687
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   -13853.789   -13853.789    -14007.12    -14007.12     296.6301     296.6301    47878.835    47878.835   -689.86428   -689.86428 
   10000    -13860.03    -13860.03   -14009.223   -14009.223    288.62555    288.62555    47871.968    47871.968   -785.52127   -785.52127 
Loop time of 274.919 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.314 ns/day, 76.366 hours/ns, 3.637 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    | 273.94     | 273.94     | 273.94     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15268    | 0.15268    | 0.15268    |   0.0 |  0.06
Output  | 0.00017799 | 0.00017799 | 0.00017799 |   0.0 |  0.00
Modify  | 0.72598    | 0.72598    | 0.72598    |   0.0 |  0.26
Other   |            | 0.0996     |            |       |  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:      343718.0 ave      343718 max      343718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343718
Ave neighs/atom = 85.929500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.68570538185, Press = 12.781242504726
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    -13860.03    -13860.03   -14009.223   -14009.223    288.62555    288.62555    47871.968    47871.968   -785.52127   -785.52127 
   11000   -13857.066   -13857.066   -14006.682   -14006.682    289.44179    289.44179    47897.952    47897.952   -1430.1459   -1430.1459 
Loop time of 272.668 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.317 ns/day, 75.741 hours/ns, 3.667 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    | 271.7      | 271.7      | 271.7      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15223    | 0.15223    | 0.15223    |   0.0 |  0.06
Output  | 0.00018254 | 0.00018254 | 0.00018254 |   0.0 |  0.00
Modify  | 0.71823    | 0.71823    | 0.71823    |   0.0 |  0.26
Other   |            | 0.0987     |            |       |  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:      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.762479747707, Press = 13.0854423009526
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   -13857.066   -13857.066   -14006.682   -14006.682    289.44179    289.44179    47897.952    47897.952   -1430.1459   -1430.1459 
   12000   -13856.828   -13856.828   -14005.368   -14005.368    287.36076    287.36076    47908.765    47908.765   -1769.0658   -1769.0658 
Loop time of 275.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.314 ns/day, 76.473 hours/ns, 3.632 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    | 274.33     | 274.33     | 274.33     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15263    | 0.15263    | 0.15263    |   0.0 |  0.06
Output  | 0.00022846 | 0.00022846 | 0.00022846 |   0.0 |  0.00
Modify  | 0.72127    | 0.72127    | 0.72127    |   0.0 |  0.26
Other   |            | 0.09916    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343614.0 ave      343614 max      343614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343614
Ave neighs/atom = 85.903500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.950145008506, Press = 5.29305833798259
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   -13856.828   -13856.828   -14005.368   -14005.368    287.36076    287.36076    47908.765    47908.765   -1769.0658   -1769.0658 
   13000   -13857.311   -13857.311   -14007.767   -14007.767    291.06661    291.06661    47902.399    47902.399   -1935.4398   -1935.4398 
Loop time of 285.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.341 hours/ns, 3.501 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    | 284.6      | 284.6      | 284.6      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15756    | 0.15756    | 0.15756    |   0.0 |  0.06
Output  | 0.00024486 | 0.00024486 | 0.00024486 |   0.0 |  0.00
Modify  | 0.76812    | 0.76812    | 0.76812    |   0.0 |  0.27
Other   |            | 0.1019     |            |       |  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:      343648.0 ave      343648 max      343648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343648
Ave neighs/atom = 85.912000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.008763161747, Press = 5.15215121587765
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   -13857.311   -13857.311   -14007.767   -14007.767    291.06661    291.06661    47902.399    47902.399   -1935.4398   -1935.4398 
   14000   -13850.729   -13850.729   -14001.913   -14001.913    292.47605    292.47605    47893.781    47893.781   -469.62154   -469.62154 
Loop time of 287.787 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.300 ns/day, 79.941 hours/ns, 3.475 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    | 286.75     | 286.75     | 286.75     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15888    | 0.15888    | 0.15888    |   0.0 |  0.06
Output  | 0.00017457 | 0.00017457 | 0.00017457 |   0.0 |  0.00
Modify  | 0.7776     | 0.7776     | 0.7776     |   0.0 |  0.27
Other   |            | 0.1021     |            |       |  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:      343718.0 ave      343718 max      343718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343718
Ave neighs/atom = 85.929500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.920398621051, Press = 4.97279805200308
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   -13850.729   -13850.729   -14001.913   -14001.913    292.47605    292.47605    47893.781    47893.781   -469.62154   -469.62154 
   15000   -13856.285   -13856.285   -14006.484   -14006.484     290.5716     290.5716    47829.635    47829.635    1504.8448    1504.8448 
Loop time of 282.25 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.306 ns/day, 78.403 hours/ns, 3.543 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    | 281.23     | 281.23     | 281.23     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1569     | 0.1569     | 0.1569     |   0.0 |  0.06
Output  | 0.00045092 | 0.00045092 | 0.00045092 |   0.0 |  0.00
Modify  | 0.75743    | 0.75743    | 0.75743    |   0.0 |  0.27
Other   |            | 0.1013     |            |       |  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:      343620.0 ave      343620 max      343620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343620
Ave neighs/atom = 85.905000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.957709205499, Press = 3.37292759053738
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   -13856.285   -13856.285   -14006.484   -14006.484     290.5716     290.5716    47829.635    47829.635    1504.8448    1504.8448 
   16000   -13855.616   -13855.616   -14008.104   -14008.104    294.99849    294.99849    47858.139    47858.139    115.12625    115.12625 
Loop time of 285.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.348 hours/ns, 3.501 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    | 284.63     | 284.63     | 284.63     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15786    | 0.15786    | 0.15786    |   0.0 |  0.06
Output  | 0.00017796 | 0.00017796 | 0.00017796 |   0.0 |  0.00
Modify  | 0.76294    | 0.76294    | 0.76294    |   0.0 |  0.27
Other   |            | 0.1014     |            |       |  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:      343850.0 ave      343850 max      343850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343850
Ave neighs/atom = 85.962500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.004511216095, Press = 2.35240743627399
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   -13855.616   -13855.616   -14008.104   -14008.104    294.99849    294.99849    47858.139    47858.139    115.12625    115.12625 
   17000   -13854.934   -13854.934    -14004.84    -14004.84    290.00301    290.00301     47873.75     47873.75   -22.252741   -22.252741 
Loop time of 285.201 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.303 ns/day, 79.223 hours/ns, 3.506 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    | 284.19     | 284.19     | 284.19     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1567     | 0.1567     | 0.1567     |   0.0 |  0.05
Output  | 0.00017715 | 0.00017715 | 0.00017715 |   0.0 |  0.00
Modify  | 0.7528     | 0.7528     | 0.7528     |   0.0 |  0.26
Other   |            | 0.101      |            |       |  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:      343692.0 ave      343692 max      343692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343692
Ave neighs/atom = 85.923000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.949590510977, Press = 1.2313544938599
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   -13854.934   -13854.934    -14004.84    -14004.84    290.00301    290.00301     47873.75     47873.75   -22.252741   -22.252741 
   18000   -13856.025   -13856.025   -14004.409   -14004.409    287.05992    287.05992    47885.127    47885.127   -481.18576   -481.18576 
Loop time of 286.393 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.554 hours/ns, 3.492 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    | 285.35     | 285.35     | 285.35     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16076    | 0.16076    | 0.16076    |   0.0 |  0.06
Output  | 0.00017592 | 0.00017592 | 0.00017592 |   0.0 |  0.00
Modify  | 0.78435    | 0.78435    | 0.78435    |   0.0 |  0.27
Other   |            | 0.1027     |            |       |  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:      343688.0 ave      343688 max      343688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343688
Ave neighs/atom = 85.922000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.916503676957, Press = 3.67103109010198
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   -13856.025   -13856.025   -14004.409   -14004.409    287.05992    287.05992    47885.127    47885.127   -481.18576   -481.18576 
   19000   -13852.449   -13852.449   -14003.988   -14003.988    293.16224    293.16224    47896.875    47896.875   -954.99569   -954.99569 
Loop time of 279.451 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.309 ns/day, 77.625 hours/ns, 3.578 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    | 278.45     | 278.45     | 278.45     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15555    | 0.15555    | 0.15555    |   0.0 |  0.06
Output  | 0.00022442 | 0.00022442 | 0.00022442 |   0.0 |  0.00
Modify  | 0.74782    | 0.74782    | 0.74782    |   0.0 |  0.27
Other   |            | 0.101      |            |       |  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:      343654.0 ave      343654 max      343654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343654
Ave neighs/atom = 85.913500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.940990848404, Press = 1.44852664930081
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   -13852.449   -13852.449   -14003.988   -14003.988    293.16224    293.16224    47896.875    47896.875   -954.99569   -954.99569 
   20000   -13856.598   -13856.598   -14008.715   -14008.715    294.28183    294.28183    47897.433    47897.433   -1894.1059   -1894.1059 
Loop time of 276.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.313 ns/day, 76.686 hours/ns, 3.622 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    | 275.09     | 275.09     | 275.09     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15361    | 0.15361    | 0.15361    |   0.0 |  0.06
Output  | 0.00017902 | 0.00017902 | 0.00017902 |   0.0 |  0.00
Modify  | 0.72995    | 0.72995    | 0.72995    |   0.0 |  0.26
Other   |            | 0.0992     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343686.0 ave      343686 max      343686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343686
Ave neighs/atom = 85.921500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.970020016503, Press = 2.25525268769812
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   -13856.598   -13856.598   -14008.715   -14008.715    294.28183    294.28183    47897.433    47897.433   -1894.1059   -1894.1059 
   21000   -13853.786   -13853.786   -14005.344   -14005.344    293.19932    293.19932    47900.196    47900.196   -1301.2151   -1301.2151 
Loop time of 280.377 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.308 ns/day, 77.882 hours/ns, 3.567 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    | 279.38     | 279.38     | 279.38     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15522    | 0.15522    | 0.15522    |   0.0 |  0.06
Output  | 0.00024502 | 0.00024502 | 0.00024502 |   0.0 |  0.00
Modify  | 0.74462    | 0.74462    | 0.74462    |   0.0 |  0.27
Other   |            | 0.09984    |            |       |  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:      343650.0 ave      343650 max      343650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343650
Ave neighs/atom = 85.912500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.990897275899, Press = 4.57403265963424
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   -13853.786   -13853.786   -14005.344   -14005.344    293.19932    293.19932    47900.196    47900.196   -1301.2151   -1301.2151 
   22000   -13854.484   -13854.484   -14005.332   -14005.332    291.82534    291.82534    47878.184    47878.184   -473.09196   -473.09196 
Loop time of 281.811 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.307 ns/day, 78.281 hours/ns, 3.548 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    | 280.81     | 280.81     | 280.81     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15415    | 0.15415    | 0.15415    |   0.0 |  0.05
Output  | 0.00017575 | 0.00017575 | 0.00017575 |   0.0 |  0.00
Modify  | 0.74397    | 0.74397    | 0.74397    |   0.0 |  0.26
Other   |            | 0.1006     |            |       |  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:      343642.0 ave      343642 max      343642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343642
Ave neighs/atom = 85.910500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.980942343443, Press = 3.99819155789599
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   -13854.484   -13854.484   -14005.332   -14005.332    291.82534    291.82534    47878.184    47878.184   -473.09196   -473.09196 
   23000    -13854.86    -13854.86   -14007.598   -14007.598    295.48166    295.48166    47894.729    47894.729   -1451.8883   -1451.8883 
Loop time of 272.97 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.317 ns/day, 75.825 hours/ns, 3.663 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    | 272        | 272        | 272        |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15113    | 0.15113    | 0.15113    |   0.0 |  0.06
Output  | 0.00017635 | 0.00017635 | 0.00017635 |   0.0 |  0.00
Modify  | 0.72234    | 0.72234    | 0.72234    |   0.0 |  0.26
Other   |            | 0.09894    |            |       |  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 = 292.981546637412, Press = 3.89510505115898
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    -13854.86    -13854.86   -14007.598   -14007.598    295.48166    295.48166    47894.729    47894.729   -1451.8883   -1451.8883 
   24000   -13855.321   -13855.321   -14006.905   -14006.905    293.25021    293.25021    47899.223    47899.223   -1568.2181   -1568.2181 
Loop time of 275.926 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.313 ns/day, 76.646 hours/ns, 3.624 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    | 274.94     | 274.94     | 274.94     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15233    | 0.15233    | 0.15233    |   0.0 |  0.06
Output  | 0.00017693 | 0.00017693 | 0.00017693 |   0.0 |  0.00
Modify  | 0.73104    | 0.73104    | 0.73104    |   0.0 |  0.26
Other   |            | 0.0998     |            |       |  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:      343614.0 ave      343614 max      343614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343614
Ave neighs/atom = 85.903500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.949667794439, Press = 6.21950661617724
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   -13855.321   -13855.321   -14006.905   -14006.905    293.25021    293.25021    47899.223    47899.223   -1568.2181   -1568.2181 
   25000   -13858.148   -13858.148   -14008.725   -14008.725    291.30171    291.30171    47875.735    47875.735   -793.71795   -793.71795 
Loop time of 273.712 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.316 ns/day, 76.031 hours/ns, 3.653 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    | 272.75     | 272.75     | 272.75     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15068    | 0.15068    | 0.15068    |   0.0 |  0.06
Output  | 0.00017419 | 0.00017419 | 0.00017419 |   0.0 |  0.00
Modify  | 0.71729    | 0.71729    | 0.71729    |   0.0 |  0.26
Other   |            | 0.0983     |            |       |  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:      343640.0 ave      343640 max      343640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343640
Ave neighs/atom = 85.910000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.966443293836, Press = 3.59502111495005
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   -13858.148   -13858.148   -14008.725   -14008.725    291.30171    291.30171    47875.735    47875.735   -793.71795   -793.71795 
   26000   -13855.478   -13855.478   -14007.073   -14007.073    293.27026    293.27026    47823.582    47823.582    1942.2677    1942.2677 
Loop time of 275.079 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.314 ns/day, 76.411 hours/ns, 3.635 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    | 274.1      | 274.1      | 274.1      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15283    | 0.15283    | 0.15283    |   0.0 |  0.06
Output  | 0.00030053 | 0.00030053 | 0.00030053 |   0.0 |  0.00
Modify  | 0.72825    | 0.72825    | 0.72825    |   0.0 |  0.26
Other   |            | 0.09947    |            |       |  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:      343706.0 ave      343706 max      343706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343706
Ave neighs/atom = 85.926500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.941496216458, Press = 3.61104367880407
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   -13855.478   -13855.478   -14007.073   -14007.073    293.27026    293.27026    47823.582    47823.582    1942.2677    1942.2677 
   27000    -13855.13    -13855.13   -14005.791   -14005.791     291.4638     291.4638    47825.714    47825.714    2053.4424    2053.4424 
Loop time of 274.352 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.315 ns/day, 76.209 hours/ns, 3.645 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    | 273.37     | 273.37     | 273.37     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15293    | 0.15293    | 0.15293    |   0.0 |  0.06
Output  | 0.00022044 | 0.00022044 | 0.00022044 |   0.0 |  0.00
Modify  | 0.72474    | 0.72474    | 0.72474    |   0.0 |  0.26
Other   |            | 0.1002     |            |       |  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:      343840.0 ave      343840 max      343840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343840
Ave neighs/atom = 85.960000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.960423011475, Press = 2.22928521916543
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    -13855.13    -13855.13   -14005.791   -14005.791     291.4638     291.4638    47825.714    47825.714    2053.4424    2053.4424 
   28000   -13854.366   -13854.366   -14005.865   -14005.865     293.0851     293.0851    47868.086    47868.086    103.08637    103.08637 
Loop time of 274.301 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.315 ns/day, 76.195 hours/ns, 3.646 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    | 273.33     | 273.33     | 273.33     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15216    | 0.15216    | 0.15216    |   0.0 |  0.06
Output  | 0.00017688 | 0.00017688 | 0.00017688 |   0.0 |  0.00
Modify  | 0.71957    | 0.71957    | 0.71957    |   0.0 |  0.26
Other   |            | 0.09948    |            |       |  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:      343772.0 ave      343772 max      343772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343772
Ave neighs/atom = 85.943000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.980017600184, Press = 2.02607053423947
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   -13854.366   -13854.366   -14005.865   -14005.865     293.0851     293.0851    47868.086    47868.086    103.08637    103.08637 
   29000    -13855.28    -13855.28   -14006.159   -14006.159    291.88562    291.88562    47830.241    47830.241    1685.2811    1685.2811 
Loop time of 275.609 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.313 ns/day, 76.558 hours/ns, 3.628 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    | 274.63     | 274.63     | 274.63     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15277    | 0.15277    | 0.15277    |   0.0 |  0.06
Output  | 0.0001781  | 0.0001781  | 0.0001781  |   0.0 |  0.00
Modify  | 0.72539    | 0.72539    | 0.72539    |   0.0 |  0.26
Other   |            | 0.1003     |            |       |  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:      343700.0 ave      343700 max      343700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343700
Ave neighs/atom = 85.925000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.966487469407, Press = 0.369565564822359
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    -13855.28    -13855.28   -14006.159   -14006.159    291.88562    291.88562    47830.241    47830.241    1685.2811    1685.2811 
   30000   -13853.431   -13853.431    -14005.22    -14005.22    293.64597    293.64597    47832.074    47832.074    1841.6841    1841.6841 
Loop time of 280.999 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.307 ns/day, 78.055 hours/ns, 3.559 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    | 279.99     | 279.99     | 279.99     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1565     | 0.1565     | 0.1565     |   0.0 |  0.06
Output  | 0.00017464 | 0.00017464 | 0.00017464 |   0.0 |  0.00
Modify  | 0.74867    | 0.74867    | 0.74867    |   0.0 |  0.27
Other   |            | 0.1003     |            |       |  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:      343682.0 ave      343682 max      343682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343682
Ave neighs/atom = 85.920500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.9376622119, Press = 0.0697564227360133
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   -13853.431   -13853.431    -14005.22    -14005.22    293.64597    293.64597    47832.074    47832.074    1841.6841    1841.6841 
   31000   -13856.048   -13856.048   -14008.418   -14008.418    294.77052    294.77052    47825.947    47825.947    1548.9235    1548.9235 
Loop time of 275.094 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.314 ns/day, 76.415 hours/ns, 3.635 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    | 274.11     | 274.11     | 274.11     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15398    | 0.15398    | 0.15398    |   0.0 |  0.06
Output  | 0.00017786 | 0.00017786 | 0.00017786 |   0.0 |  0.00
Modify  | 0.72963    | 0.72963    | 0.72963    |   0.0 |  0.27
Other   |            | 0.09951    |            |       |  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 = 292.93383033348, Press = 0.460967699956176
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   -13856.048   -13856.048   -14008.418   -14008.418    294.77052    294.77052    47825.947    47825.947    1548.9235    1548.9235 
   32000   -13861.683   -13861.683   -14010.479   -14010.479    287.85523    287.85523    47838.454    47838.454    486.47196    486.47196 
Loop time of 276.35 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.313 ns/day, 76.764 hours/ns, 3.619 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    | 275.38     | 275.38     | 275.38     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15337    | 0.15337    | 0.15337    |   0.0 |  0.06
Output  | 0.00017624 | 0.00017624 | 0.00017624 |   0.0 |  0.00
Modify  | 0.72216    | 0.72216    | 0.72216    |   0.0 |  0.26
Other   |            | 0.09916    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343784.0 ave      343784 max      343784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343784
Ave neighs/atom = 85.946000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.953659008601, Press = -0.581346988588901
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   -13861.683   -13861.683   -14010.479   -14010.479    287.85523    287.85523    47838.454    47838.454    486.47196    486.47196 
   33000   -13860.357   -13860.357   -14009.843   -14009.843    289.19003    289.19003    47863.413    47863.413   -530.04994   -530.04994 
Loop time of 275.078 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.314 ns/day, 76.411 hours/ns, 3.635 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    | 274.11     | 274.11     | 274.11     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1525     | 0.1525     | 0.1525     |   0.0 |  0.06
Output  | 0.0001771  | 0.0001771  | 0.0001771  |   0.0 |  0.00
Modify  | 0.72125    | 0.72125    | 0.72125    |   0.0 |  0.26
Other   |            | 0.09887    |            |       |  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:      343720.0 ave      343720 max      343720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343720
Ave neighs/atom = 85.930000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.926458108441, Press = -1.18946520592301
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   -13860.357   -13860.357   -14009.843   -14009.843    289.19003    289.19003    47863.413    47863.413   -530.04994   -530.04994 
   34000   -13852.879   -13852.879   -14004.993   -14004.993    294.27347    294.27347    47845.467    47845.467    1256.9228    1256.9228 
Loop time of 275.04 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.314 ns/day, 76.400 hours/ns, 3.636 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    | 274.06     | 274.06     | 274.06     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15244    | 0.15244    | 0.15244    |   0.0 |  0.06
Output  | 0.00023236 | 0.00023236 | 0.00023236 |   0.0 |  0.00
Modify  | 0.7263     | 0.7263     | 0.7263     |   0.0 |  0.26
Other   |            | 0.09982    |            |       |  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:      343706.0 ave      343706 max      343706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343706
Ave neighs/atom = 85.926500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.95174619512, Press = 1.23206208008106
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   -13852.879   -13852.879   -14004.993   -14004.993    294.27347    294.27347    47845.467    47845.467    1256.9228    1256.9228 
   35000   -13853.751   -13853.751   -14007.001   -14007.001    296.47236    296.47236    47852.696    47852.696    538.57354    538.57354 
Loop time of 272.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.317 ns/day, 75.624 hours/ns, 3.673 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    | 271.28     | 271.28     | 271.28     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15135    | 0.15135    | 0.15135    |   0.0 |  0.06
Output  | 0.00022505 | 0.00022505 | 0.00022505 |   0.0 |  0.00
Modify  | 0.71426    | 0.71426    | 0.71426    |   0.0 |  0.26
Other   |            | 0.09873    |            |       |  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:      343814.0 ave      343814 max      343814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343814
Ave neighs/atom = 85.953500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.971226074885, Press = 0.383157370158127
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   -13853.751   -13853.751   -14007.001   -14007.001    296.47236    296.47236    47852.696    47852.696    538.57354    538.57354 
   36000   -13856.626   -13856.626   -14007.428   -14007.428    291.73748    291.73748    47821.369    47821.369    1886.2234    1886.2234 
Loop time of 273.582 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.316 ns/day, 75.995 hours/ns, 3.655 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    | 272.61     | 272.61     | 272.61     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15224    | 0.15224    | 0.15224    |   0.0 |  0.06
Output  | 0.00017596 | 0.00017596 | 0.00017596 |   0.0 |  0.00
Modify  | 0.71894    | 0.71894    | 0.71894    |   0.0 |  0.26
Other   |            | 0.09912    |            |       |  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:      343764.0 ave      343764 max      343764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343764
Ave neighs/atom = 85.941000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.998175786202, Press = 1.35597770622902
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   -13856.626   -13856.626   -14007.428   -14007.428    291.73748    291.73748    47821.369    47821.369    1886.2234    1886.2234 
   37000   -13856.464   -13856.464   -14008.992   -14008.992    295.07494    295.07494    47870.901    47870.901   -646.19243   -646.19243 
Loop time of 276.517 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.312 ns/day, 76.810 hours/ns, 3.616 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    | 275.53     | 275.53     | 275.53     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15316    | 0.15316    | 0.15316    |   0.0 |  0.06
Output  | 0.00029263 | 0.00029263 | 0.00029263 |   0.0 |  0.00
Modify  | 0.7311     | 0.7311     | 0.7311     |   0.0 |  0.26
Other   |            | 0.0995     |            |       |  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:      343776.0 ave      343776 max      343776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343776
Ave neighs/atom = 85.944000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.039777295036, Press = 0.994652748573631
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   -13856.464   -13856.464   -14008.992   -14008.992    295.07494    295.07494    47870.901    47870.901   -646.19243   -646.19243 
   38000   -13854.745   -13854.745   -14008.591   -14008.591    297.62719    297.62719    47846.259    47846.259    495.08314    495.08314 
Loop time of 276.995 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.312 ns/day, 76.943 hours/ns, 3.610 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    | 276.02     | 276.02     | 276.02     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15303    | 0.15303    | 0.15303    |   0.0 |  0.06
Output  | 0.00017786 | 0.00017786 | 0.00017786 |   0.0 |  0.00
Modify  | 0.72475    | 0.72475    | 0.72475    |   0.0 |  0.26
Other   |            | 0.09869    |            |       |  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:      343752.0 ave      343752 max      343752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343752
Ave neighs/atom = 85.938000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.063196552396, Press = 1.17269789363725
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.745   -13854.745   -14008.591   -14008.591    297.62719    297.62719    47846.259    47846.259    495.08314    495.08314 
   39000   -13853.645   -13853.645   -14008.567   -14008.567    299.70749    299.70749     47880.55     47880.55    -1007.632    -1007.632 
Loop time of 274.996 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.314 ns/day, 76.388 hours/ns, 3.636 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    | 274.03     | 274.03     | 274.03     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1499     | 0.1499     | 0.1499     |   0.0 |  0.05
Output  | 0.00022229 | 0.00022229 | 0.00022229 |   0.0 |  0.00
Modify  | 0.72201    | 0.72201    | 0.72201    |   0.0 |  0.26
Other   |            | 0.09864    |            |       |  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:      343748.0 ave      343748 max      343748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0