# 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.520000764727593*${_u_distance}
variable latticeconst_converted equal 3.520000764727593*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52000076472759
Lattice spacing in x,y,z = 3.5200008 3.5200008 3.5200008
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 (35.200008 35.200008 35.200008)
  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 (35.200008 35.200008 35.200008)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_DeluigiPasianotValencia_2021_FeNiCrCoCu__MO_657255834688_000
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_657255834688_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17638.129   -17638.129       -17800       -17800       313.15       313.15    43614.236    43614.236    3964.2314    3964.2314 
    1000   -17479.779   -17479.779   -17644.471   -17644.471    318.60743    318.60743    44174.072    44174.072   -2320.9463   -2320.9463 
Loop time of 65.7748 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.314 ns/day, 18.271 hours/ns, 15.203 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 64.81      | 64.81      | 64.81      |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1965     | 0.1965     | 0.1965     |   0.0 |  0.30
Output  | 0.00022478 | 0.00022478 | 0.00022478 |   0.0 |  0.00
Modify  | 0.6665     | 0.6665     | 0.6665     |   0.0 |  1.01
Other   |            | 0.1014     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      704000.0 ave      704000 max      704000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704000
Ave neighs/atom = 176.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17479.779   -17479.779   -17644.471   -17644.471    318.60743    318.60743    44174.072    44174.072   -2320.9463   -2320.9463 
    2000   -17482.056   -17482.056    -17642.94    -17642.94    311.24044    311.24044    44104.172    44104.172    1140.7405    1140.7405 
Loop time of 73.5962 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.174 ns/day, 20.443 hours/ns, 13.588 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.499     | 72.499     | 72.499     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21724    | 0.21724    | 0.21724    |   0.0 |  0.30
Output  | 0.00021793 | 0.00021793 | 0.00021793 |   0.0 |  0.00
Modify  | 0.77238    | 0.77238    | 0.77238    |   0.0 |  1.05
Other   |            | 0.1076     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      714604.0 ave      714604 max      714604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714604
Ave neighs/atom = 178.65100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17482.056   -17482.056    -17642.94    -17642.94    311.24044    311.24044    44104.172    44104.172    1140.7405    1140.7405 
    3000   -17487.315   -17487.315   -17645.472   -17645.472    305.96659    305.96659    44110.403    44110.403    446.04728    446.04728 
Loop time of 76.5662 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.128 ns/day, 21.268 hours/ns, 13.061 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.417     | 75.417     | 75.417     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22724    | 0.22724    | 0.22724    |   0.0 |  0.30
Output  | 0.00022369 | 0.00022369 | 0.00022369 |   0.0 |  0.00
Modify  | 0.8127     | 0.8127     | 0.8127     |   0.0 |  1.06
Other   |            | 0.1086     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715870.0 ave      715870 max      715870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715870
Ave neighs/atom = 178.96750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17487.315   -17487.315   -17645.472   -17645.472    305.96659    305.96659    44110.403    44110.403    446.04728    446.04728 
    4000   -17479.484   -17479.484   -17643.221   -17643.221    316.76175    316.76175    44132.366    44132.366   -290.86864   -290.86864 
Loop time of 71.7318 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.204 ns/day, 19.925 hours/ns, 13.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 70.672     | 70.672     | 70.672     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21027    | 0.21027    | 0.21027    |   0.0 |  0.29
Output  | 0.00022175 | 0.00022175 | 0.00022175 |   0.0 |  0.00
Modify  | 0.74394    | 0.74394    | 0.74394    |   0.0 |  1.04
Other   |            | 0.1053     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715626.0 ave      715626 max      715626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715626
Ave neighs/atom = 178.90650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17479.484   -17479.484   -17643.221   -17643.221    316.76175    316.76175    44132.366    44132.366   -290.86864   -290.86864 
    5000   -17488.044   -17488.044    -17646.99    -17646.99    307.49321    307.49321    44098.578    44098.578    847.92401    847.92401 
Loop time of 75.7403 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.039 hours/ns, 13.203 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.604     | 74.604     | 74.604     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22222    | 0.22222    | 0.22222    |   0.0 |  0.29
Output  | 0.00022652 | 0.00022652 | 0.00022652 |   0.0 |  0.00
Modify  | 0.80692    | 0.80692    | 0.80692    |   0.0 |  1.07
Other   |            | 0.1069     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715630.0 ave      715630 max      715630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715630
Ave neighs/atom = 178.90750
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 = 309.997621472731, Press = -370.965773419251
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17488.044   -17488.044    -17646.99    -17646.99    307.49321    307.49321    44098.578    44098.578    847.92401    847.92401 
    6000   -17481.729   -17481.729   -17641.008   -17641.008    308.13468    308.13468     44138.55     44138.55   -499.69076   -499.69076 
Loop time of 77.9873 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.108 ns/day, 21.663 hours/ns, 12.823 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 76.797     | 76.797     | 76.797     |   0.0 | 98.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22783    | 0.22783    | 0.22783    |   0.0 |  0.29
Output  | 0.00023114 | 0.00023114 | 0.00023114 |   0.0 |  0.00
Modify  | 0.85377    | 0.85377    | 0.85377    |   0.0 |  1.09
Other   |            | 0.1084     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715864.0 ave      715864 max      715864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715864
Ave neighs/atom = 178.96600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.151029913, Press = 19.9975812945459
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17481.729   -17481.729   -17641.008   -17641.008    308.13468    308.13468     44138.55     44138.55   -499.69076   -499.69076 
    7000   -17483.804   -17483.804   -17644.828   -17644.828    311.51176    311.51176    44100.981    44100.981    974.59468    974.59468 
Loop time of 77.9756 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.108 ns/day, 21.660 hours/ns, 12.825 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 76.79      | 76.79      | 76.79      |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22518    | 0.22518    | 0.22518    |   0.0 |  0.29
Output  | 0.00028629 | 0.00028629 | 0.00028629 |   0.0 |  0.00
Modify  | 0.851      | 0.851      | 0.851      |   0.0 |  1.09
Other   |            | 0.1089     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715996.0 ave      715996 max      715996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715996
Ave neighs/atom = 178.99900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.854287079932, Press = -48.7024313611205
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17483.804   -17483.804   -17644.828   -17644.828    311.51176    311.51176    44100.981    44100.981    974.59468    974.59468 
    8000   -17485.978   -17485.978   -17644.198   -17644.198    306.08692    306.08692    44118.549    44118.549    258.13802    258.13802 
Loop time of 75.2075 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.149 ns/day, 20.891 hours/ns, 13.297 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.079     | 74.079     | 74.079     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21969    | 0.21969    | 0.21969    |   0.0 |  0.29
Output  | 0.00023042 | 0.00023042 | 0.00023042 |   0.0 |  0.00
Modify  | 0.8032     | 0.8032     | 0.8032     |   0.0 |  1.07
Other   |            | 0.1059     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      716234.0 ave      716234 max      716234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716234
Ave neighs/atom = 179.05850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.378041970668, Press = 13.0404469132458
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17485.978   -17485.978   -17644.198   -17644.198    306.08692    306.08692    44118.549    44118.549    258.13802    258.13802 
    9000   -17485.741   -17485.741   -17643.845   -17643.845    305.86381    305.86381    44113.742    44113.742     476.4492     476.4492 
Loop time of 67.8123 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.274 ns/day, 18.837 hours/ns, 14.747 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    | 66.842     | 66.842     | 66.842     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19964    | 0.19964    | 0.19964    |   0.0 |  0.29
Output  | 0.00018    | 0.00018    | 0.00018    |   0.0 |  0.00
Modify  | 0.67478    | 0.67478    | 0.67478    |   0.0 |  1.00
Other   |            | 0.09562    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715860.0 ave      715860 max      715860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715860
Ave neighs/atom = 178.96500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.107070853816, Press = -11.2365676594364
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17485.741   -17485.741   -17643.845   -17643.845    305.86381    305.86381    44113.742    44113.742     476.4492     476.4492 
   10000   -17486.263   -17486.263   -17648.858   -17648.858    314.55122    314.55122    44107.073    44107.073    215.26869    215.26869 
Loop time of 75.596 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 20.999 hours/ns, 13.228 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    | 74.435     | 74.435     | 74.435     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22285    | 0.22285    | 0.22285    |   0.0 |  0.29
Output  | 0.00018002 | 0.00018002 | 0.00018002 |   0.0 |  0.00
Modify  | 0.83059    | 0.83059    | 0.83059    |   0.0 |  1.10
Other   |            | 0.1078     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715840.0 ave      715840 max      715840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715840
Ave neighs/atom = 178.96000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.116681736723, Press = 2.20748821390584
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17486.263   -17486.263   -17648.858   -17648.858    314.55122    314.55122    44107.073    44107.073    215.26869    215.26869 
   11000    -17479.44    -17479.44   -17642.661   -17642.661    315.76215    315.76215    44143.544    44143.544   -829.45718   -829.45718 
Loop time of 73.1461 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.181 ns/day, 20.318 hours/ns, 13.671 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    | 72.044     | 72.044     | 72.044     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21444    | 0.21444    | 0.21444    |   0.0 |  0.29
Output  | 0.00023535 | 0.00023535 | 0.00023535 |   0.0 |  0.00
Modify  | 0.78342    | 0.78342    | 0.78342    |   0.0 |  1.07
Other   |            | 0.1037     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715678.0 ave      715678 max      715678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715678
Ave neighs/atom = 178.91950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.491110427971, Press = -9.11519429062623
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -17479.44    -17479.44   -17642.661   -17642.661    315.76215    315.76215    44143.544    44143.544   -829.45718   -829.45718 
   12000   -17483.537   -17483.537   -17647.738   -17647.738    317.65764    317.65764    44088.199    44088.199    1247.2451    1247.2451 
Loop time of 67.5597 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.279 ns/day, 18.767 hours/ns, 14.802 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    | 66.592     | 66.592     | 66.592     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19876    | 0.19876    | 0.19876    |   0.0 |  0.29
Output  | 0.00018012 | 0.00018012 | 0.00018012 |   0.0 |  0.00
Modify  | 0.67128    | 0.67128    | 0.67128    |   0.0 |  0.99
Other   |            | 0.09707    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715872.0 ave      715872 max      715872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715872
Ave neighs/atom = 178.96800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.567128691346, Press = 1.84203174006172
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17483.537   -17483.537   -17647.738   -17647.738    317.65764    317.65764    44088.199    44088.199    1247.2451    1247.2451 
   13000   -17485.092   -17485.092   -17644.329   -17644.329    308.05455    308.05455    44167.245    44167.245   -2253.6292   -2253.6292 
Loop time of 67.5095 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.280 ns/day, 18.753 hours/ns, 14.813 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    | 66.544     | 66.544     | 66.544     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19734    | 0.19734    | 0.19734    |   0.0 |  0.29
Output  | 0.00017772 | 0.00017772 | 0.00017772 |   0.0 |  0.00
Modify  | 0.67099    | 0.67099    | 0.67099    |   0.0 |  0.99
Other   |            | 0.0968     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      716202.0 ave      716202 max      716202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716202
Ave neighs/atom = 179.05050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.780598596958, Press = -11.5798943821655
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17485.092   -17485.092   -17644.329   -17644.329    308.05455    308.05455    44167.245    44167.245   -2253.6292   -2253.6292 
   14000   -17481.951   -17481.951   -17642.403   -17642.403    310.40418    310.40418    44078.436    44078.436     2452.334     2452.334 
Loop time of 67.5096 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.280 ns/day, 18.753 hours/ns, 14.813 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    | 66.541     | 66.541     | 66.541     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19968    | 0.19968    | 0.19968    |   0.0 |  0.30
Output  | 0.00018307 | 0.00018307 | 0.00018307 |   0.0 |  0.00
Modify  | 0.67215    | 0.67215    | 0.67215    |   0.0 |  1.00
Other   |            | 0.09683    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715150.0 ave      715150 max      715150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715150
Ave neighs/atom = 178.78750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.715426408221, Press = 4.95020580402691
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17481.951   -17481.951   -17642.403   -17642.403    310.40418    310.40418    44078.436    44078.436     2452.334     2452.334 
   15000   -17484.522   -17484.522   -17646.217   -17646.217    312.80979    312.80979    44145.079    44145.079   -1238.9186   -1238.9186 
Loop time of 67.4878 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.280 ns/day, 18.747 hours/ns, 14.818 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    | 66.519     | 66.519     | 66.519     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20075    | 0.20075    | 0.20075    |   0.0 |  0.30
Output  | 0.00017899 | 0.00017899 | 0.00017899 |   0.0 |  0.00
Modify  | 0.67199    | 0.67199    | 0.67199    |   0.0 |  1.00
Other   |            | 0.09566    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      716420.0 ave      716420 max      716420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716420
Ave neighs/atom = 179.10500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.488105095378, Press = -4.2241425825795
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17484.522   -17484.522   -17646.217   -17646.217    312.80979    312.80979    44145.079    44145.079   -1238.9186   -1238.9186 
   16000   -17485.396   -17485.396   -17644.836   -17644.836    308.44844    308.44844    44114.769    44114.769    291.09393    291.09393 
Loop time of 67.4254 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.281 ns/day, 18.729 hours/ns, 14.831 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 66.458     | 66.458     | 66.458     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1986     | 0.1986     | 0.1986     |   0.0 |  0.29
Output  | 0.00018089 | 0.00018089 | 0.00018089 |   0.0 |  0.00
Modify  | 0.67202    | 0.67202    | 0.67202    |   0.0 |  1.00
Other   |            | 0.09666    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715170.0 ave      715170 max      715170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715170
Ave neighs/atom = 178.79250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.471500458371, Press = 0.435060506939717
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17485.396   -17485.396   -17644.836   -17644.836    308.44844    308.44844    44114.769    44114.769    291.09393    291.09393 
   17000   -17484.599   -17484.599   -17645.871   -17645.871    311.99191    311.99191    44114.815    44114.815    61.684576    61.684576 
Loop time of 67.4737 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.280 ns/day, 18.743 hours/ns, 14.821 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    | 66.505     | 66.505     | 66.505     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19903    | 0.19903    | 0.19903    |   0.0 |  0.29
Output  | 0.00018192 | 0.00018192 | 0.00018192 |   0.0 |  0.00
Modify  | 0.67315    | 0.67315    | 0.67315    |   0.0 |  1.00
Other   |            | 0.09626    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715798.0 ave      715798 max      715798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715798
Ave neighs/atom = 178.94950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.262013560671, Press = -5.30736345377753
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17484.599   -17484.599   -17645.871   -17645.871    311.99191    311.99191    44114.815    44114.815    61.684576    61.684576 
   18000   -17486.363   -17486.363   -17647.103   -17647.103    310.96301    310.96301    44132.385    44132.385   -784.67008   -784.67008 
Loop time of 66.3939 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.301 ns/day, 18.443 hours/ns, 15.062 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    | 65.432     | 65.432     | 65.432     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1945     | 0.1945     | 0.1945     |   0.0 |  0.29
Output  | 0.00017294 | 0.00017294 | 0.00017294 |   0.0 |  0.00
Modify  | 0.66791    | 0.66791    | 0.66791    |   0.0 |  1.01
Other   |            | 0.09906    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715994.0 ave      715994 max      715994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715994
Ave neighs/atom = 178.99850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.219433412564, Press = 3.92169869954008
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17486.363   -17486.363   -17647.103   -17647.103    310.96301    310.96301    44132.385    44132.385   -784.67008   -784.67008 
   19000   -17484.565   -17484.565   -17645.328   -17645.328    311.00575    311.00575    44098.105    44098.105    1016.2071    1016.2071 
Loop time of 67.0749 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.288 ns/day, 18.632 hours/ns, 14.909 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    | 66.099     | 66.099     | 66.099     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19487    | 0.19487    | 0.19487    |   0.0 |  0.29
Output  | 0.00017782 | 0.00017782 | 0.00017782 |   0.0 |  0.00
Modify  | 0.6805     | 0.6805     | 0.6805     |   0.0 |  1.01
Other   |            | 0.09992    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715406.0 ave      715406 max      715406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715406
Ave neighs/atom = 178.85150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.052985207828, Press = -6.17975756802007
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17484.565   -17484.565   -17645.328   -17645.328    311.00575    311.00575    44098.105    44098.105    1016.2071    1016.2071 
   20000   -17484.179   -17484.179   -17646.091   -17646.091    313.22885    313.22885    44132.508    44132.508   -580.04326   -580.04326 
Loop time of 71.9252 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.201 ns/day, 19.979 hours/ns, 13.903 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 70.861     | 70.861     | 70.861     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20808    | 0.20808    | 0.20808    |   0.0 |  0.29
Output  | 0.00018586 | 0.00018586 | 0.00018586 |   0.0 |  0.00
Modify  | 0.75271    | 0.75271    | 0.75271    |   0.0 |  1.05
Other   |            | 0.1037     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      716020.0 ave      716020 max      716020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716020
Ave neighs/atom = 179.00500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.097374486995, Press = 0.726631141210275
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17484.179   -17484.179   -17646.091   -17646.091    313.22885    313.22885    44132.508    44132.508   -580.04326   -580.04326 
   21000   -17481.298   -17481.298   -17645.335   -17645.335     317.3397     317.3397    44110.435    44110.435    524.38944    524.38944 
Loop time of 74.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.152 ns/day, 20.829 hours/ns, 13.336 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    | 73.864     | 73.864     | 73.864     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21705    | 0.21705    | 0.21705    |   0.0 |  0.29
Output  | 0.00027735 | 0.00027735 | 0.00027735 |   0.0 |  0.00
Modify  | 0.79817    | 0.79817    | 0.79817    |   0.0 |  1.06
Other   |            | 0.1064     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715368.0 ave      715368 max      715368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715368
Ave neighs/atom = 178.84200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.159087732881, Press = -2.27259877066873
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17481.298   -17481.298   -17645.335   -17645.335     317.3397     317.3397    44110.435    44110.435    524.38944    524.38944 
   22000   -17484.009   -17484.009    -17644.87    -17644.87    311.19738    311.19738    44137.332    44137.332   -891.13445   -891.13445 
Loop time of 77.2474 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.118 ns/day, 21.458 hours/ns, 12.945 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    | 76.068     | 76.068     | 76.068     |   0.0 | 98.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22525    | 0.22525    | 0.22525    |   0.0 |  0.29
Output  | 0.0001783  | 0.0001783  | 0.0001783  |   0.0 |  0.00
Modify  | 0.84563    | 0.84563    | 0.84563    |   0.0 |  1.09
Other   |            | 0.1079     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715966.0 ave      715966 max      715966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715966
Ave neighs/atom = 178.99150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.242415525593, Press = -0.497749049887104
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17484.009   -17484.009    -17644.87    -17644.87    311.19738    311.19738    44137.332    44137.332   -891.13445   -891.13445 
   23000   -17482.812   -17482.812   -17644.277   -17644.277    312.36541    312.36541    44081.933    44081.933    1755.6397    1755.6397 
Loop time of 72.3033 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.195 ns/day, 20.084 hours/ns, 13.831 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 71.234     | 71.234     | 71.234     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2124     | 0.2124     | 0.2124     |   0.0 |  0.29
Output  | 0.00018103 | 0.00018103 | 0.00018103 |   0.0 |  0.00
Modify  | 0.75483    | 0.75483    | 0.75483    |   0.0 |  1.04
Other   |            | 0.1018     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715696.0 ave      715696 max      715696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715696
Ave neighs/atom = 178.92400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.236296381721, Press = -1.43588579191581
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17482.812   -17482.812   -17644.277   -17644.277    312.36541    312.36541    44081.933    44081.933    1755.6397    1755.6397 
   24000   -17489.848   -17489.848   -17648.694   -17648.694    307.29707    307.29707    44157.251    44157.251   -2326.3691   -2326.3691 
Loop time of 70.5807 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.224 ns/day, 19.606 hours/ns, 14.168 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    | 69.54      | 69.54      | 69.54      |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20715    | 0.20715    | 0.20715    |   0.0 |  0.29
Output  | 0.00018463 | 0.00018463 | 0.00018463 |   0.0 |  0.00
Modify  | 0.73261    | 0.73261    | 0.73261    |   0.0 |  1.04
Other   |            | 0.1007     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      716558.0 ave      716558 max      716558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716558
Ave neighs/atom = 179.13950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.151555831262, Press = -0.312714185781669
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17489.848   -17489.848   -17648.694   -17648.694    307.29707    307.29707    44157.251    44157.251   -2326.3691   -2326.3691 
   25000   -17485.492   -17485.492   -17647.891   -17647.891    314.17277    314.17277    44080.366    44080.366    1776.2444    1776.2444 
Loop time of 74.4518 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.681 hours/ns, 13.432 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.311     | 73.311     | 73.311     |   0.0 | 98.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21785    | 0.21785    | 0.21785    |   0.0 |  0.29
Output  | 0.00017652 | 0.00017652 | 0.00017652 |   0.0 |  0.00
Modify  | 0.81564    | 0.81564    | 0.81564    |   0.0 |  1.10
Other   |            | 0.1068     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      714884.0 ave      714884 max      714884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714884
Ave neighs/atom = 178.72100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.145416199729, Press = -2.39070820334356
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17485.492   -17485.492   -17647.891   -17647.891    314.17277    314.17277    44080.366    44080.366    1776.2444    1776.2444 
   26000   -17478.513   -17478.513   -17645.878   -17645.878    323.77863    323.77863    44151.851    44151.851   -1426.4198   -1426.4198 
Loop time of 65.9167 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.311 ns/day, 18.310 hours/ns, 15.171 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    | 64.957     | 64.957     | 64.957     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19275    | 0.19275    | 0.19275    |   0.0 |  0.29
Output  | 0.00017565 | 0.00017565 | 0.00017565 |   0.0 |  0.00
Modify  | 0.66632    | 0.66632    | 0.66632    |   0.0 |  1.01
Other   |            | 0.1007     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715920.0 ave      715920 max      715920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715920
Ave neighs/atom = 178.98000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.217887023432, Press = 0.451625767843134
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17478.513   -17478.513   -17645.878   -17645.878    323.77863    323.77863    44151.851    44151.851   -1426.4198   -1426.4198 
   27000   -17486.222   -17486.222   -17646.412   -17646.412    309.89862    309.89862    44098.134    44098.134    855.49705    855.49705 
Loop time of 72.6994 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.188 ns/day, 20.194 hours/ns, 13.755 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    | 71.605     | 71.605     | 71.605     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21267    | 0.21267    | 0.21267    |   0.0 |  0.29
Output  | 0.00027435 | 0.00027435 | 0.00027435 |   0.0 |  0.00
Modify  | 0.7763     | 0.7763     | 0.7763     |   0.0 |  1.07
Other   |            | 0.1047     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715048.0 ave      715048 max      715048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715048
Ave neighs/atom = 178.76200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.228630320057, Press = -2.78105060970192
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17486.222   -17486.222   -17646.412   -17646.412    309.89862    309.89862    44098.134    44098.134    855.49705    855.49705 
   28000   -17479.683   -17479.683    -17646.04    -17646.04      321.829      321.829    44144.939    44144.939   -1226.9933   -1226.9933 
Loop time of 75.2563 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.148 ns/day, 20.905 hours/ns, 13.288 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.119     | 74.119     | 74.119     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21831    | 0.21831    | 0.21831    |   0.0 |  0.29
Output  | 0.00022818 | 0.00022818 | 0.00022818 |   0.0 |  0.00
Modify  | 0.81164    | 0.81164    | 0.81164    |   0.0 |  1.08
Other   |            | 0.1073     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715906.0 ave      715906 max      715906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715906
Ave neighs/atom = 178.97650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.229597685526, Press = 0.807774298045589
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17479.683   -17479.683    -17646.04    -17646.04      321.829      321.829    44144.939    44144.939   -1226.9933   -1226.9933 
   29000   -17484.277   -17484.277   -17645.953   -17645.953     312.7737     312.7737     44117.85     44117.85    34.986509    34.986509 
Loop time of 69.1449 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.250 ns/day, 19.207 hours/ns, 14.462 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    | 68.126     | 68.126     | 68.126     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20377    | 0.20377    | 0.20377    |   0.0 |  0.29
Output  | 0.00018152 | 0.00018152 | 0.00018152 |   0.0 |  0.00
Modify  | 0.71298    | 0.71298    | 0.71298    |   0.0 |  1.03
Other   |            | 0.1017     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715420.0 ave      715420 max      715420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715420
Ave neighs/atom = 178.85500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.190041428725, Press = -1.41633457266611
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17484.277   -17484.277   -17645.953   -17645.953     312.7737     312.7737     44117.85     44117.85    34.986509    34.986509 
   30000   -17483.972   -17483.972   -17646.399   -17646.399    314.22553    314.22553    44118.943    44118.943   -255.60446   -255.60446 
Loop time of 67.8661 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.273 ns/day, 18.852 hours/ns, 14.735 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    | 66.896     | 66.896     | 66.896     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20022    | 0.20022    | 0.20022    |   0.0 |  0.30
Output  | 0.00018178 | 0.00018178 | 0.00018178 |   0.0 |  0.00
Modify  | 0.67304    | 0.67304    | 0.67304    |   0.0 |  0.99
Other   |            | 0.09635    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715684.0 ave      715684 max      715684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715684
Ave neighs/atom = 178.92100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.155396332774, Press = -0.398781929114454
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17483.972   -17483.972   -17646.399   -17646.399    314.22553    314.22553    44118.943    44118.943   -255.60446   -255.60446 
   31000   -17485.129   -17485.129   -17646.482   -17646.482     312.1482     312.1482    44116.066    44116.066    14.290804    14.290804 
Loop time of 67.7952 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.274 ns/day, 18.832 hours/ns, 14.750 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    | 66.829     | 66.829     | 66.829     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19712    | 0.19712    | 0.19712    |   0.0 |  0.29
Output  | 0.00018178 | 0.00018178 | 0.00018178 |   0.0 |  0.00
Modify  | 0.6721     | 0.6721     | 0.6721     |   0.0 |  0.99
Other   |            | 0.09656    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715792.0 ave      715792 max      715792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715792
Ave neighs/atom = 178.94800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.067685848928, Press = -1.96187825524187
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17485.129   -17485.129   -17646.482   -17646.482     312.1482     312.1482    44116.066    44116.066    14.290804    14.290804 
   32000   -17487.387   -17487.387   -17648.312   -17648.312    311.31899    311.31899    44133.318    44133.318   -1146.4602   -1146.4602 
Loop time of 67.8522 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.273 ns/day, 18.848 hours/ns, 14.738 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    | 66.886     | 66.886     | 66.886     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19783    | 0.19783    | 0.19783    |   0.0 |  0.29
Output  | 0.000182   | 0.000182   | 0.000182   |   0.0 |  0.00
Modify  | 0.6721     | 0.6721     | 0.6721     |   0.0 |  0.99
Other   |            | 0.09623    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715946.0 ave      715946 max      715946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715946
Ave neighs/atom = 178.98650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.051493695972, Press = 1.08589468956755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17487.387   -17487.387   -17648.312   -17648.312    311.31899    311.31899    44133.318    44133.318   -1146.4602   -1146.4602 
   33000   -17483.418   -17483.418   -17646.794   -17646.794    316.06159    316.06159    44111.207    44111.207    249.81863    249.81863 
Loop time of 67.8254 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.274 ns/day, 18.840 hours/ns, 14.744 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    | 66.858     | 66.858     | 66.858     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19832    | 0.19832    | 0.19832    |   0.0 |  0.29
Output  | 0.00017962 | 0.00017962 | 0.00017962 |   0.0 |  0.00
Modify  | 0.67238    | 0.67238    | 0.67238    |   0.0 |  0.99
Other   |            | 0.09604    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715550.0 ave      715550 max      715550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715550
Ave neighs/atom = 178.88750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.039951517411, Press = -3.23826314899076
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -17483.418   -17483.418   -17646.794   -17646.794    316.06159    316.06159    44111.207    44111.207    249.81863    249.81863 
   34000   -17484.101   -17484.101   -17642.606   -17642.606    306.63874    306.63874    44132.896    44132.896   -505.41681   -505.41681 
Loop time of 67.8323 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.274 ns/day, 18.842 hours/ns, 14.742 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    | 66.866     | 66.866     | 66.866     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19768    | 0.19768    | 0.19768    |   0.0 |  0.29
Output  | 0.00018281 | 0.00018281 | 0.00018281 |   0.0 |  0.00
Modify  | 0.67232    | 0.67232    | 0.67232    |   0.0 |  0.99
Other   |            | 0.09567    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715760.0 ave      715760 max      715760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715760
Ave neighs/atom = 178.94000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.014987987067, Press = 0.922851799732116
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17484.101   -17484.101   -17642.606   -17642.606    306.63874    306.63874    44132.896    44132.896   -505.41681   -505.41681 
   35000   -17485.935   -17485.935   -17650.964   -17650.964    319.25855    319.25855     44097.18     44097.18    462.78833    462.78833 
Loop time of 66.6296 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.297 ns/day, 18.508 hours/ns, 15.008 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.669     | 65.669     | 65.669     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19451    | 0.19451    | 0.19451    |   0.0 |  0.29
Output  | 0.00017837 | 0.00017837 | 0.00017837 |   0.0 |  0.00
Modify  | 0.66764    | 0.66764    | 0.66764    |   0.0 |  1.00
Other   |            | 0.09823    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715892.0 ave      715892 max      715892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715892
Ave neighs/atom = 178.97300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.031317997988, Press = -1.52038161346415
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17485.935   -17485.935   -17650.964   -17650.964    319.25855    319.25855     44097.18     44097.18    462.78833    462.78833 
   36000   -17481.826   -17481.826   -17640.809   -17640.809    307.56273    307.56273    44130.748    44130.748   -204.84877   -204.84877 
Loop time of 67.0648 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.288 ns/day, 18.629 hours/ns, 14.911 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    | 66.098     | 66.098     | 66.098     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19792    | 0.19792    | 0.19792    |   0.0 |  0.30
Output  | 0.00018268 | 0.00018268 | 0.00018268 |   0.0 |  0.00
Modify  | 0.67035    | 0.67035    | 0.67035    |   0.0 |  1.00
Other   |            | 0.09817    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715684.0 ave      715684 max      715684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715684
Ave neighs/atom = 178.92100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.093095631115, Press = -0.649433730810881
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17481.826   -17481.826   -17640.809   -17640.809    307.56273    307.56273    44130.748    44130.748   -204.84877   -204.84877 
   37000   -17484.838   -17484.838   -17646.345   -17646.345    312.44679    312.44679     44106.33     44106.33    455.14017    455.14017 
Loop time of 66.6738 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.296 ns/day, 18.521 hours/ns, 14.998 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    | 65.707     | 65.707     | 65.707     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19522    | 0.19522    | 0.19522    |   0.0 |  0.29
Output  | 0.00043515 | 0.00043515 | 0.00043515 |   0.0 |  0.00
Modify  | 0.67155    | 0.67155    | 0.67155    |   0.0 |  1.01
Other   |            | 0.09986    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      716074.0 ave      716074 max      716074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716074
Ave neighs/atom = 179.01850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.132052142955, Press = -1.33517982306455
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17484.838   -17484.838   -17646.345   -17646.345    312.44679    312.44679     44106.33     44106.33    455.14017    455.14017 
   38000   -17485.107   -17485.107   -17646.961   -17646.961    313.11778    313.11778    44119.706    44119.706   -335.16118   -335.16118 
Loop time of 65.9677 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.310 ns/day, 18.324 hours/ns, 15.159 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    | 65.006     | 65.006     | 65.006     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19389    | 0.19389    | 0.19389    |   0.0 |  0.29
Output  | 0.00017913 | 0.00017913 | 0.00017913 |   0.0 |  0.00
Modify  | 0.66633    | 0.66633    | 0.66633    |   0.0 |  1.01
Other   |            | 0.1009     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      716016.0 ave      716016 max      716016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716016
Ave neighs/atom = 179.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.184196891789, Press = -0.351609236332057
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17485.107   -17485.107   -17646.961   -17646.961    313.11778    313.11778    44119.706    44119.706   -335.16118   -335.16118 
   39000   -17483.365   -17483.365   -17646.515   -17646.515      315.625      315.625    44102.137    44102.137    858.18991    858.18991 
Loop time of 65.9612 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.310 ns/day, 18.323 hours/ns, 15.160 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    | 65         | 65         | 65         |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19375    | 0.19375    | 0.19375    |   0.0 |  0.29
Output  | 0.00017842 | 0.00017842 | 0.00017842 |   0.0 |  0.00
Modify  | 0.6666     | 0.6666     | 0.6666     |   0.0 |  1.01
Other   |            | 0.1007     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715710.0 ave      715710 max      715710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715710
Ave neighs/atom = 178.92750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.182137901525, Press = -1.75581653122138
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17483.365   -17483.365   -17646.515   -17646.515      315.625      315.625    44102.137    44102.137    858.18991    858.18991 
   40000   -17487.108   -17487.108   -17646.419   -17646.419    308.19877    308.19877    44146.109    44146.109     -1370.66     -1370.66 
Loop time of 65.9489 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.310 ns/day, 18.319 hours/ns, 15.163 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    | 64.987     | 64.987     | 64.987     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19261    | 0.19261    | 0.19261    |   0.0 |  0.29
Output  | 0.00022739 | 0.00022739 | 0.00022739 |   0.0 |  0.00
Modify  | 0.66772    | 0.66772    | 0.66772    |   0.0 |  1.01
Other   |            | 0.101      |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      716004.0 ave      716004 max      716004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716004
Ave neighs/atom = 179.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.179909732869, Press = 0.59019691419328
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17487.108   -17487.108   -17646.419   -17646.419    308.19877    308.19877    44146.109    44146.109     -1370.66     -1370.66 
   41000   -17482.423   -17482.423   -17647.169   -17647.169    318.71163    318.71163    44101.575    44101.575    915.22146    915.22146 
Loop time of 65.9519 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.310 ns/day, 18.320 hours/ns, 15.163 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    | 64.989     | 64.989     | 64.989     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19523    | 0.19523    | 0.19523    |   0.0 |  0.30
Output  | 0.00017407 | 0.00017407 | 0.00017407 |   0.0 |  0.00
Modify  | 0.66609    | 0.66609    | 0.66609    |   0.0 |  1.01
Other   |            | 0.1011     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715308.0 ave      715308 max      715308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715308
Ave neighs/atom = 178.82700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.151650576687, Press = -2.17773636819017
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17482.423   -17482.423   -17647.169   -17647.169    318.71163    318.71163    44101.575    44101.575    915.22146    915.22146 
   42000   -17483.751   -17483.751   -17648.013   -17648.013    317.77661    317.77661    44141.167    44141.167   -1282.9797   -1282.9797 
Loop time of 65.9821 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.309 ns/day, 18.328 hours/ns, 15.156 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    | 65.019     | 65.019     | 65.019     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19389    | 0.19389    | 0.19389    |   0.0 |  0.29
Output  | 0.00017453 | 0.00017453 | 0.00017453 |   0.0 |  0.00
Modify  | 0.66792    | 0.66792    | 0.66792    |   0.0 |  1.01
Other   |            | 0.1013     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715678.0 ave      715678 max      715678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715678
Ave neighs/atom = 178.91950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.121575086417, Press = 0.513225659424811
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17483.751   -17483.751   -17648.013   -17648.013    317.77661    317.77661    44141.167    44141.167   -1282.9797   -1282.9797 
   43000   -17480.002   -17480.002    -17642.57    -17642.57    314.49742    314.49742    44111.994    44111.994    783.64353    783.64353 
Loop time of 65.9203 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.311 ns/day, 18.311 hours/ns, 15.170 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    | 64.956     | 64.956     | 64.956     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19463    | 0.19463    | 0.19463    |   0.0 |  0.30
Output  | 0.0001754  | 0.0001754  | 0.0001754  |   0.0 |  0.00
Modify  | 0.66862    | 0.66862    | 0.66862    |   0.0 |  1.01
Other   |            | 0.1013     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715032.0 ave      715032 max      715032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715032
Ave neighs/atom = 178.75800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.12493154853, Press = -1.83493132963406
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -17480.002   -17480.002    -17642.57    -17642.57    314.49742    314.49742    44111.994    44111.994    783.64353    783.64353 
   44000   -17485.313   -17485.313   -17647.889   -17647.889     314.5142     314.5142    44127.412    44127.412   -731.98817   -731.98817 
Loop time of 66.0027 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.309 ns/day, 18.334 hours/ns, 15.151 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    | 65.038     | 65.038     | 65.038     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19705    | 0.19705    | 0.19705    |   0.0 |  0.30
Output  | 0.00017552 | 0.00017552 | 0.00017552 |   0.0 |  0.00
Modify  | 0.66558    | 0.66558    | 0.66558    |   0.0 |  1.01
Other   |            | 0.1016     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      716026.0 ave      716026 max      716026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716026
Ave neighs/atom = 179.00650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.127076228908, Press = 0.25321659342296
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -17485.313   -17485.313   -17647.889   -17647.889     314.5142     314.5142    44127.412    44127.412   -731.98817   -731.98817 
   45000   -17483.433   -17483.433   -17646.832   -17646.832    316.10547    316.10547    44113.559    44113.559     145.6872     145.6872 
Loop time of 65.9352 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.310 ns/day, 18.315 hours/ns, 15.166 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    | 64.97      | 64.97      | 64.97      |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19435    | 0.19435    | 0.19435    |   0.0 |  0.29
Output  | 0.00023917 | 0.00023917 | 0.00023917 |   0.0 |  0.00
Modify  | 0.6698     | 0.6698     | 0.6698     |   0.0 |  1.02
Other   |            | 0.1004     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715392.0 ave      715392 max      715392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715392
Ave neighs/atom = 178.84800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.13607127078, Press = -0.941630906758802
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -17483.433   -17483.433   -17646.832   -17646.832    316.10547    316.10547    44113.559    44113.559     145.6872     145.6872 
   46000   -17482.164   -17482.164   -17646.886   -17646.886    318.66591    318.66591    44129.219    44129.219   -570.62996   -570.62996 
Loop time of 65.9701 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.310 ns/day, 18.325 hours/ns, 15.158 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    | 65.007     | 65.007     | 65.007     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19262    | 0.19262    | 0.19262    |   0.0 |  0.29
Output  | 0.00017439 | 0.00017439 | 0.00017439 |   0.0 |  0.00
Modify  | 0.66983    | 0.66983    | 0.66983    |   0.0 |  1.02
Other   |            | 0.1002     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715664.0 ave      715664 max      715664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715664
Ave neighs/atom = 178.91600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.101877337449, Press = -0.348464768435848
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -17482.164   -17482.164   -17646.886   -17646.886    318.66591    318.66591    44129.219    44129.219   -570.62996   -570.62996 
   47000   -17489.795   -17489.795   -17645.502   -17645.502    301.22544    301.22544    44093.507    44093.507    1117.5627    1117.5627 
Loop time of 65.9107 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.311 ns/day, 18.309 hours/ns, 15.172 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    | 64.946     | 64.946     | 64.946     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19567    | 0.19567    | 0.19567    |   0.0 |  0.30
Output  | 0.00017574 | 0.00017574 | 0.00017574 |   0.0 |  0.00
Modify  | 0.66824    | 0.66824    | 0.66824    |   0.0 |  1.01
Other   |            | 0.1005     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      715634.0 ave      715634 max      715634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715634
Ave neighs/atom = 178.90850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.085093812708, Press = -0.991224022554868
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -17489.795   -17489.795   -17645.502   -17645.502    301.22544    301.22544    44093.507    44093.507    1117.5627    1117.5627 
   48000   -17482.703   -17482.703   -17642.082   -17642.082    308.32979    308.32979    44152.911    44152.911   -1428.2918   -1428.2918 
Loop time of 65.8173 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.313 ns/day, 18.283 hours/ns, 15.194 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    | 64.856     | 64.856     | 64.856     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19205    | 0.19205    | 0.19205    |   0.0 |  0.29
Output  | 0.00017646 | 0.00017646 | 0.00017646 |   0.0 |  0.00
Modify  | 0.6685     | 0.6685     | 0.6685     |   0.0 |  1.02
Other   |            | 0.1002     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      716374.0 ave      716374 max      716374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0