# 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.615000084042549*${_u_distance}
variable latticeconst_converted equal 3.615000084042549*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61500008404255
Lattice spacing in x,y,z = 3.6150001 3.6150001 3.6150001
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.150001 36.150001 36.150001)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.150001 36.150001 36.150001)
  create_atoms CPU = 0.007 seconds

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

kim_interactions Cu

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

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


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_266134052596_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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13987.791   -13987.791       -14160       -14160       333.15       333.15    47241.637    47241.637    3893.5585    3893.5585 
    1000   -13800.465   -13800.465   -13977.244   -13977.244     341.9912     341.9912    47982.959    47982.959    937.52412    937.52412 
Loop time of 102.554 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.842 ns/day, 28.487 hours/ns, 9.751 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    | 101.46     | 101.46     | 101.46     |   0.0 | 98.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21613    | 0.21613    | 0.21613    |   0.0 |  0.21
Output  | 0.00021168 | 0.00021168 | 0.00021168 |   0.0 |  0.00
Modify  | 0.76816    | 0.76816    | 0.76816    |   0.0 |  0.75
Other   |            | 0.1081     |            |       |  0.11

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:      896000.0 ave      896000 max      896000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 896000
Ave neighs/atom = 224.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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13800.465   -13800.465   -13977.244   -13977.244     341.9912     341.9912    47982.959    47982.959    937.52412    937.52412 
    2000   -13817.337   -13817.337   -13987.681   -13987.681    329.54258    329.54258    47989.947    47989.947   -630.30705   -630.30705 
Loop time of 96.3894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.896 ns/day, 26.775 hours/ns, 10.375 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    | 95.385     | 95.385     | 95.385     |   0.0 | 98.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20088    | 0.20088    | 0.20088    |   0.0 |  0.21
Output  | 0.00030116 | 0.00030116 | 0.00030116 |   0.0 |  0.00
Modify  | 0.69745    | 0.69745    | 0.69745    |   0.0 |  0.72
Other   |            | 0.1062     |            |       |  0.11

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:      898058.0 ave      898058 max      898058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898058
Ave neighs/atom = 224.51450
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13817.337   -13817.337   -13987.681   -13987.681    329.54258    329.54258    47989.947    47989.947   -630.30705   -630.30705 
    3000   -13806.479   -13806.479   -13977.416   -13977.416    330.68937    330.68937    48035.359    48035.359   -824.13854   -824.13854 
Loop time of 100.577 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.859 ns/day, 27.938 hours/ns, 9.943 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    | 99.547     | 99.547     | 99.547     |   0.0 | 98.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20516    | 0.20516    | 0.20516    |   0.0 |  0.20
Output  | 0.00021315 | 0.00021315 | 0.00021315 |   0.0 |  0.00
Modify  | 0.71867    | 0.71867    | 0.71867    |   0.0 |  0.71
Other   |            | 0.1062     |            |       |  0.11

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:      898258.0 ave      898258 max      898258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898258
Ave neighs/atom = 224.56450
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13806.479   -13806.479   -13977.416   -13977.416    330.68937    330.68937    48035.359    48035.359   -824.13854   -824.13854 
    4000   -13817.179   -13817.179   -13985.606   -13985.606    325.83331    325.83331    47969.732    47969.732    229.34733    229.34733 
Loop time of 97.493 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.886 ns/day, 27.081 hours/ns, 10.257 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    | 96.488     | 96.488     | 96.488     |   0.0 | 98.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20192    | 0.20192    | 0.20192    |   0.0 |  0.21
Output  | 0.00031625 | 0.00031625 | 0.00031625 |   0.0 |  0.00
Modify  | 0.6971     | 0.6971     | 0.6971     |   0.0 |  0.72
Other   |            | 0.1054     |            |       |  0.11

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:      897786.0 ave      897786 max      897786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897786
Ave neighs/atom = 224.44650
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13817.179   -13817.179   -13985.606   -13985.606    325.83331    325.83331    47969.732    47969.732    229.34733    229.34733 
    5000   -13806.656   -13806.656   -13981.335   -13981.335    337.92974    337.92974    47957.501    47957.501    1138.6983    1138.6983 
Loop time of 113.236 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.763 ns/day, 31.454 hours/ns, 8.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    | 112.15     | 112.15     | 112.15     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.216      | 0.216      | 0.216      |   0.0 |  0.19
Output  | 0.000184   | 0.000184   | 0.000184   |   0.0 |  0.00
Modify  | 0.76454    | 0.76454    | 0.76454    |   0.0 |  0.68
Other   |            | 0.1044     |            |       |  0.09

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:      898314.0 ave      898314 max      898314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898314
Ave neighs/atom = 224.57850
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 = 338.576379860294, Press = -49.3700772699735
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13806.656   -13806.656   -13981.335   -13981.335    337.92974    337.92974    47957.501    47957.501    1138.6983    1138.6983 
    6000   -13815.255   -13815.255   -13983.671   -13983.671    325.81142    325.81142    47984.342    47984.342   -46.381229   -46.381229 
Loop time of 116.149 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.744 ns/day, 32.264 hours/ns, 8.610 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115        | 115        | 115        |   0.0 | 99.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22067    | 0.22067    | 0.22067    |   0.0 |  0.19
Output  | 0.00017917 | 0.00017917 | 0.00017917 |   0.0 |  0.00
Modify  | 0.82357    | 0.82357    | 0.82357    |   0.0 |  0.71
Other   |            | 0.1075     |            |       |  0.09

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:      898488.0 ave      898488 max      898488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898488
Ave neighs/atom = 224.62200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.17367269209, Press = 52.9300121114103
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13815.255   -13815.255   -13983.671   -13983.671    325.81142    325.81142    47984.342    47984.342   -46.381229   -46.381229 
    7000   -13809.037   -13809.037   -13982.056   -13982.056    334.71759    334.71759    48073.517    48073.517   -2447.9236   -2447.9236 
Loop time of 89.7561 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.963 ns/day, 24.932 hours/ns, 11.141 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    | 88.8       | 88.8       | 88.8       |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18934    | 0.18934    | 0.18934    |   0.0 |  0.21
Output  | 0.00022859 | 0.00022859 | 0.00022859 |   0.0 |  0.00
Modify  | 0.66461    | 0.66461    | 0.66461    |   0.0 |  0.74
Other   |            | 0.1015     |            |       |  0.11

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:      898188.0 ave      898188 max      898188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898188
Ave neighs/atom = 224.54700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.474069441487, Press = -3.36653171467498
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13809.037   -13809.037   -13982.056   -13982.056    334.71759    334.71759    48073.517    48073.517   -2447.9236   -2447.9236 
    8000    -13806.16    -13806.16   -13981.029   -13981.029    338.29569    338.29569    48014.741    48014.741   -532.67461   -532.67461 
Loop time of 117.141 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.738 ns/day, 32.539 hours/ns, 8.537 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    | 116.11     | 116.11     | 116.11     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20671    | 0.20671    | 0.20671    |   0.0 |  0.18
Output  | 0.0002747  | 0.0002747  | 0.0002747  |   0.0 |  0.00
Modify  | 0.72222    | 0.72222    | 0.72222    |   0.0 |  0.62
Other   |            | 0.09763    |            |       |  0.08

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:      897234.0 ave      897234 max      897234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897234
Ave neighs/atom = 224.30850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.195819579701, Press = -13.6145581716179
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    -13806.16    -13806.16   -13981.029   -13981.029    338.29569    338.29569    48014.741    48014.741   -532.67461   -532.67461 
    9000   -13814.755   -13814.755   -13985.677   -13985.677    330.65972    330.65972     47926.52     47926.52    1515.0807    1515.0807 
Loop time of 102.536 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.843 ns/day, 28.482 hours/ns, 9.753 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    | 101.53     | 101.53     | 101.53     |   0.0 | 99.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19982    | 0.19982    | 0.19982    |   0.0 |  0.19
Output  | 0.00018873 | 0.00018873 | 0.00018873 |   0.0 |  0.00
Modify  | 0.71033    | 0.71033    | 0.71033    |   0.0 |  0.69
Other   |            | 0.1005     |            |       |  0.10

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:      898008.0 ave      898008 max      898008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898008
Ave neighs/atom = 224.50200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.319308561352, Press = -3.23282276454111
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13814.755   -13814.755   -13985.677   -13985.677    330.65972    330.65972     47926.52     47926.52    1515.0807    1515.0807 
   10000   -13803.409   -13803.409   -13978.229   -13978.229    338.20118    338.20118    47973.017    47973.017    1018.1027    1018.1027 
Loop time of 120.067 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.720 ns/day, 33.352 hours/ns, 8.329 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    | 118.93     | 118.93     | 118.93     |   0.0 | 99.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22187    | 0.22187    | 0.22187    |   0.0 |  0.18
Output  | 0.00022838 | 0.00022838 | 0.00022838 |   0.0 |  0.00
Modify  | 0.80841    | 0.80841    | 0.80841    |   0.0 |  0.67
Other   |            | 0.1039     |            |       |  0.09

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:      898840.0 ave      898840 max      898840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898840
Ave neighs/atom = 224.71000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.590348537937, Press = 4.99423969587718
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13803.409   -13803.409   -13978.229   -13978.229    338.20118    338.20118    47973.017    47973.017    1018.1027    1018.1027 
   11000   -13811.734   -13811.734   -13983.051   -13983.051    331.42295    331.42295    48011.657    48011.657   -703.93969   -703.93969 
Loop time of 114.567 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.824 hours/ns, 8.729 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    | 113.52     | 113.52     | 113.52     |   0.0 | 99.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20944    | 0.20944    | 0.20944    |   0.0 |  0.18
Output  | 0.00018193 | 0.00018193 | 0.00018193 |   0.0 |  0.00
Modify  | 0.73375    | 0.73375    | 0.73375    |   0.0 |  0.64
Other   |            | 0.09986    |            |       |  0.09

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:      898232.0 ave      898232 max      898232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898232
Ave neighs/atom = 224.55800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.684753332277, Press = 3.32242036580743
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13811.734   -13811.734   -13983.051   -13983.051    331.42295    331.42295    48011.657    48011.657   -703.93969   -703.93969 
   12000   -13812.756   -13812.756   -13986.506   -13986.506    336.13139    336.13139    48021.826    48021.826   -1334.9031   -1334.9031 
Loop time of 126.438 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.683 ns/day, 35.122 hours/ns, 7.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    | 125.27     | 125.27     | 125.27     |   0.0 | 99.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22424    | 0.22424    | 0.22424    |   0.0 |  0.18
Output  | 0.0001805  | 0.0001805  | 0.0001805  |   0.0 |  0.00
Modify  | 0.84155    | 0.84155    | 0.84155    |   0.0 |  0.67
Other   |            | 0.1061     |            |       |  0.08

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:      897960.0 ave      897960 max      897960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897960
Ave neighs/atom = 224.49000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.7744618425, Press = -5.3743134160355
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13812.756   -13812.756   -13986.506   -13986.506    336.13139    336.13139    48021.826    48021.826   -1334.9031   -1334.9031 
   13000   -13814.696   -13814.696   -13986.464   -13986.464    332.29595    332.29595    47923.075    47923.075    1540.3018    1540.3018 
Loop time of 122.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.707 ns/day, 33.959 hours/ns, 8.180 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    | 121.1      | 121.1      | 121.1      |   0.0 | 99.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22321    | 0.22321    | 0.22321    |   0.0 |  0.18
Output  | 0.00017869 | 0.00017869 | 0.00017869 |   0.0 |  0.00
Modify  | 0.82073    | 0.82073    | 0.82073    |   0.0 |  0.67
Other   |            | 0.1047     |            |       |  0.09

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:      897696.0 ave      897696 max      897696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897696
Ave neighs/atom = 224.42400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.683389539694, Press = -7.44984204579963
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13814.696   -13814.696   -13986.464   -13986.464    332.29595    332.29595    47923.075    47923.075    1540.3018    1540.3018 
   14000   -13810.434   -13810.434   -13984.004   -13984.004    335.78137    335.78137    47929.158    47929.158    1656.5038    1656.5038 
Loop time of 92.9816 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.929 ns/day, 25.828 hours/ns, 10.755 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    | 92.016     | 92.016     | 92.016     |   0.0 | 98.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19245    | 0.19245    | 0.19245    |   0.0 |  0.21
Output  | 0.00017806 | 0.00017806 | 0.00017806 |   0.0 |  0.00
Modify  | 0.67243    | 0.67243    | 0.67243    |   0.0 |  0.72
Other   |            | 0.1003     |            |       |  0.11

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:      898722.0 ave      898722 max      898722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898722
Ave neighs/atom = 224.68050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.612091424746, Press = 5.56251356224617
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13810.434   -13810.434   -13984.004   -13984.004    335.78137    335.78137    47929.158    47929.158    1656.5038    1656.5038 
   15000   -13810.689   -13810.689   -13985.758   -13985.758    338.68269    338.68269    48003.206    48003.206   -690.19053   -690.19053 
Loop time of 104.953 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.154 hours/ns, 9.528 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    | 103.92     | 103.92     | 103.92     |   0.0 | 99.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20491    | 0.20491    | 0.20491    |   0.0 |  0.20
Output  | 0.00017604 | 0.00017604 | 0.00017604 |   0.0 |  0.00
Modify  | 0.72332    | 0.72332    | 0.72332    |   0.0 |  0.69
Other   |            | 0.1022     |            |       |  0.10

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:      899024.0 ave      899024 max      899024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 899024
Ave neighs/atom = 224.75600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.492574712255, Press = 2.64483049292762
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13810.689   -13810.689   -13985.758   -13985.758    338.68269    338.68269    48003.206    48003.206   -690.19053   -690.19053 
   16000   -13808.244   -13808.244   -13981.194   -13981.194    334.58347    334.58347    48016.636    48016.636   -613.55137   -613.55137 
Loop time of 127.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.678 ns/day, 35.403 hours/ns, 7.846 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    | 126.25     | 126.25     | 126.25     |   0.0 | 99.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23093    | 0.23093    | 0.23093    |   0.0 |  0.18
Output  | 0.0001824  | 0.0001824  | 0.0001824  |   0.0 |  0.00
Modify  | 0.86217    | 0.86217    | 0.86217    |   0.0 |  0.68
Other   |            | 0.1075     |            |       |  0.08

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:      897990.0 ave      897990 max      897990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897990
Ave neighs/atom = 224.49750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.311290190899, Press = 1.07737685219721
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13808.244   -13808.244   -13981.194   -13981.194    334.58347    334.58347    48016.636    48016.636   -613.55137   -613.55137 
   17000    -13813.67    -13813.67   -13983.424   -13983.424    328.40017    328.40017     47984.91     47984.91   -35.052579   -35.052579 
Loop time of 102.296 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.845 ns/day, 28.416 hours/ns, 9.776 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    | 101.29     | 101.29     | 101.29     |   0.0 | 99.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19887    | 0.19887    | 0.19887    |   0.0 |  0.19
Output  | 0.00018099 | 0.00018099 | 0.00018099 |   0.0 |  0.00
Modify  | 0.70298    | 0.70298    | 0.70298    |   0.0 |  0.69
Other   |            | 0.1019     |            |       |  0.10

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:      897984.0 ave      897984 max      897984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897984
Ave neighs/atom = 224.49600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.33392790284, Press = -2.20847534315833
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -13813.67    -13813.67   -13983.424   -13983.424    328.40017    328.40017     47984.91     47984.91   -35.052579   -35.052579 
   18000   -13809.452   -13809.452   -13981.935   -13981.935    333.67927    333.67927    47962.595    47962.595    841.37001    841.37001 
Loop time of 111.442 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.775 ns/day, 30.956 hours/ns, 8.973 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    | 110.47     | 110.47     | 110.47     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19994    | 0.19994    | 0.19994    |   0.0 |  0.18
Output  | 0.00018326 | 0.00018326 | 0.00018326 |   0.0 |  0.00
Modify  | 0.67899    | 0.67899    | 0.67899    |   0.0 |  0.61
Other   |            | 0.09696    |            |       |  0.09

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:      897978.0 ave      897978 max      897978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897978
Ave neighs/atom = 224.49450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.226939542245, Press = -3.64299238869404
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13809.452   -13809.452   -13981.935   -13981.935    333.67927    333.67927    47962.595    47962.595    841.37001    841.37001 
   19000   -13818.131   -13818.131   -13987.683   -13987.683    328.01054    328.01054    47886.141    47886.141    2408.3016    2408.3016 
Loop time of 113.583 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.761 ns/day, 31.551 hours/ns, 8.804 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    | 112.61     | 112.61     | 112.61     |   0.0 | 99.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20071    | 0.20071    | 0.20071    |   0.0 |  0.18
Output  | 0.00017568 | 0.00017568 | 0.00017568 |   0.0 |  0.00
Modify  | 0.67801    | 0.67801    | 0.67801    |   0.0 |  0.60
Other   |            | 0.09551    |            |       |  0.08

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:      898724.0 ave      898724 max      898724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898724
Ave neighs/atom = 224.68100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.160753235138, Press = 2.44918904122168
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13818.131   -13818.131   -13987.683   -13987.683    328.01054    328.01054    47886.141    47886.141    2408.3016    2408.3016 
   20000   -13809.082   -13809.082   -13982.848   -13982.848    336.16324    336.16324    48013.786    48013.786   -656.56624   -656.56624 
Loop time of 113.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.764 ns/day, 31.434 hours/ns, 8.837 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.19     | 112.19     | 112.19     |   0.0 | 99.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20067    | 0.20067    | 0.20067    |   0.0 |  0.18
Output  | 0.00017936 | 0.00017936 | 0.00017936 |   0.0 |  0.00
Modify  | 0.67643    | 0.67643    | 0.67643    |   0.0 |  0.60
Other   |            | 0.09545    |            |       |  0.08

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:      899448.0 ave      899448 max      899448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 899448
Ave neighs/atom = 224.86200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.030288309752, Press = 3.41993700639142
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13809.082   -13809.082   -13982.848   -13982.848    336.16324    336.16324    48013.786    48013.786   -656.56624   -656.56624 
   21000   -13817.967   -13817.967   -13987.773   -13987.773     328.5012     328.5012    48019.467    48019.467   -1486.9355   -1486.9355 
Loop time of 113.12 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.764 ns/day, 31.422 hours/ns, 8.840 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    | 112.15     | 112.15     | 112.15     |   0.0 | 99.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20068    | 0.20068    | 0.20068    |   0.0 |  0.18
Output  | 0.00018108 | 0.00018108 | 0.00018108 |   0.0 |  0.00
Modify  | 0.67757    | 0.67757    | 0.67757    |   0.0 |  0.60
Other   |            | 0.09576    |            |       |  0.08

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:      897846.0 ave      897846 max      897846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897846
Ave neighs/atom = 224.46150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.919205158601, Press = -1.1134550547475
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13817.967   -13817.967   -13987.773   -13987.773     328.5012     328.5012    48019.467    48019.467   -1486.9355   -1486.9355 
   22000   -13807.891   -13807.891   -13982.993   -13982.993    338.74729    338.74729    47968.795    47968.795    593.36133    593.36133 
Loop time of 113.041 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.764 ns/day, 31.400 hours/ns, 8.846 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    | 112.07     | 112.07     | 112.07     |   0.0 | 99.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19913    | 0.19913    | 0.19913    |   0.0 |  0.18
Output  | 0.00018137 | 0.00018137 | 0.00018137 |   0.0 |  0.00
Modify  | 0.67685    | 0.67685    | 0.67685    |   0.0 |  0.60
Other   |            | 0.09535    |            |       |  0.08

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:      898010.0 ave      898010 max      898010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898010
Ave neighs/atom = 224.50250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.834322851414, Press = -4.23634365574916
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13807.891   -13807.891   -13982.993   -13982.993    338.74729    338.74729    47968.795    47968.795    593.36133    593.36133 
   23000   -13811.863   -13811.863   -13985.128   -13985.128    335.19358    335.19358     47933.89     47933.89    1400.2303    1400.2303 
Loop time of 112.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.767 ns/day, 31.292 hours/ns, 8.877 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    | 111.68     | 111.68     | 111.68     |   0.0 | 99.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20011    | 0.20011    | 0.20011    |   0.0 |  0.18
Output  | 0.00018583 | 0.00018583 | 0.00018583 |   0.0 |  0.00
Modify  | 0.67756    | 0.67756    | 0.67756    |   0.0 |  0.60
Other   |            | 0.09552    |            |       |  0.08

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:      898594.0 ave      898594 max      898594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898594
Ave neighs/atom = 224.64850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.832995694249, Press = 0.178229040438073
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13811.863   -13811.863   -13985.128   -13985.128    335.19358    335.19358     47933.89     47933.89    1400.2303    1400.2303 
   24000   -13816.249   -13816.249   -13988.383   -13988.383    333.00478    333.00478    47977.023    47977.023    -198.3286    -198.3286 
Loop time of 112.502 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.251 hours/ns, 8.889 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    | 111.53     | 111.53     | 111.53     |   0.0 | 99.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20108    | 0.20108    | 0.20108    |   0.0 |  0.18
Output  | 0.00018103 | 0.00018103 | 0.00018103 |   0.0 |  0.00
Modify  | 0.6776     | 0.6776     | 0.6776     |   0.0 |  0.60
Other   |            | 0.09525    |            |       |  0.08

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:      898944.0 ave      898944 max      898944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898944
Ave neighs/atom = 224.73600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.898588513312, Press = 2.11695806188907
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13816.249   -13816.249   -13988.383   -13988.383    333.00478    333.00478    47977.023    47977.023    -198.3286    -198.3286 
   25000   -13808.706   -13808.706   -13983.933   -13983.933    338.98846    338.98846     48020.15     48020.15   -950.01248   -950.01248 
Loop time of 111.528 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.775 ns/day, 30.980 hours/ns, 8.966 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    | 110.55     | 110.55     | 110.55     |   0.0 | 99.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2002     | 0.2002     | 0.2002     |   0.0 |  0.18
Output  | 0.00017713 | 0.00017713 | 0.00017713 |   0.0 |  0.00
Modify  | 0.67741    | 0.67741    | 0.67741    |   0.0 |  0.61
Other   |            | 0.09578    |            |       |  0.09

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:      898420.0 ave      898420 max      898420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898420
Ave neighs/atom = 224.60500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.870514552408, Press = 0.217152783870149
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13808.706   -13808.706   -13983.933   -13983.933    338.98846    338.98846     48020.15     48020.15   -950.01248   -950.01248 
   26000   -13811.447   -13811.447   -13981.995   -13981.995      329.937      329.937    47977.273    47977.273    387.77576    387.77576 
Loop time of 97.9448 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.882 ns/day, 27.207 hours/ns, 10.210 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    | 96.947     | 96.947     | 96.947     |   0.0 | 98.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19679    | 0.19679    | 0.19679    |   0.0 |  0.20
Output  | 0.0002357  | 0.0002357  | 0.0002357  |   0.0 |  0.00
Modify  | 0.69909    | 0.69909    | 0.69909    |   0.0 |  0.71
Other   |            | 0.1022     |            |       |  0.10

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:      897922.0 ave      897922 max      897922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897922
Ave neighs/atom = 224.48050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.875372442162, Press = -1.31709491398046
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13811.447   -13811.447   -13981.995   -13981.995      329.937      329.937    47977.273    47977.273    387.77576    387.77576 
   27000   -13814.587   -13814.587   -13986.219   -13986.219    332.03441    332.03441    47929.994    47929.994    1338.3348    1338.3348 
Loop time of 91.0642 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.949 ns/day, 25.296 hours/ns, 10.981 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    | 90.101     | 90.101     | 90.101     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19125    | 0.19125    | 0.19125    |   0.0 |  0.21
Output  | 0.00017722 | 0.00017722 | 0.00017722 |   0.0 |  0.00
Modify  | 0.66988    | 0.66988    | 0.66988    |   0.0 |  0.74
Other   |            | 0.1018     |            |       |  0.11

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:      898460.0 ave      898460 max      898460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898460
Ave neighs/atom = 224.61500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.980324107806, Press = 0.626592389083523
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13814.587   -13814.587   -13986.219   -13986.219    332.03441    332.03441    47929.994    47929.994    1338.3348    1338.3348 
   28000   -13810.717   -13810.717       -13983       -13983    333.29369    333.29369    47999.407    47999.407   -352.49476   -352.49476 
Loop time of 90.8198 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.951 ns/day, 25.228 hours/ns, 11.011 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 89.861     | 89.861     | 89.861     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18972    | 0.18972    | 0.18972    |   0.0 |  0.21
Output  | 0.00017716 | 0.00017716 | 0.00017716 |   0.0 |  0.00
Modify  | 0.66625    | 0.66625    | 0.66625    |   0.0 |  0.73
Other   |            | 0.1026     |            |       |  0.11

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:      899064.0 ave      899064 max      899064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 899064
Ave neighs/atom = 224.76600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.980343249233, Press = 1.84277278850657
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13810.717   -13810.717       -13983       -13983    333.29369    333.29369    47999.407    47999.407   -352.49476   -352.49476 
   29000   -13815.073   -13815.073   -13984.778   -13984.778    328.30465    328.30465    48013.429    48013.429   -1016.1876   -1016.1876 
Loop time of 92.4618 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.934 ns/day, 25.684 hours/ns, 10.815 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    | 91.497     | 91.497     | 91.497     |   0.0 | 98.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19155    | 0.19155    | 0.19155    |   0.0 |  0.21
Output  | 0.00017784 | 0.00017784 | 0.00017784 |   0.0 |  0.00
Modify  | 0.67145    | 0.67145    | 0.67145    |   0.0 |  0.73
Other   |            | 0.1016     |            |       |  0.11

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:      898106.0 ave      898106 max      898106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898106
Ave neighs/atom = 224.52650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.882640895208, Press = -0.031427431573335
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13815.073   -13815.073   -13984.778   -13984.778    328.30465    328.30465    48013.429    48013.429   -1016.1876   -1016.1876 
   30000    -13813.39    -13813.39   -13983.871   -13983.871    329.80766    329.80766     47964.92     47964.92    542.56764    542.56764 
Loop time of 108.484 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.796 ns/day, 30.134 hours/ns, 9.218 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    | 107.45     | 107.45     | 107.45     |   0.0 | 99.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20569    | 0.20569    | 0.20569    |   0.0 |  0.19
Output  | 0.00022912 | 0.00022912 | 0.00022912 |   0.0 |  0.00
Modify  | 0.72658    | 0.72658    | 0.72658    |   0.0 |  0.67
Other   |            | 0.1033     |            |       |  0.10

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:      897888.0 ave      897888 max      897888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897888
Ave neighs/atom = 224.47200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.864253002597, Press = -0.495467950828691
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000    -13813.39    -13813.39   -13983.871   -13983.871    329.80766    329.80766     47964.92     47964.92    542.56764    542.56764 
   31000   -13810.277   -13810.277   -13982.328   -13982.328    332.84367    332.84367    47969.714    47969.714    597.73619    597.73619 
Loop time of 93.371 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.925 ns/day, 25.936 hours/ns, 10.710 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    | 92.401     | 92.401     | 92.401     |   0.0 | 98.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1948     | 0.1948     | 0.1948     |   0.0 |  0.21
Output  | 0.00017508 | 0.00017508 | 0.00017508 |   0.0 |  0.00
Modify  | 0.67307    | 0.67307    | 0.67307    |   0.0 |  0.72
Other   |            | 0.1022     |            |       |  0.11

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:      898476.0 ave      898476 max      898476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898476
Ave neighs/atom = 224.61900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.837453024686, Press = 0.0113822409307523
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13810.277   -13810.277   -13982.328   -13982.328    332.84367    332.84367    47969.714    47969.714    597.73619    597.73619 
   32000   -13816.226   -13816.226   -13986.892   -13986.892    330.16437    330.16437    47976.464    47976.464   -75.864716   -75.864716 
Loop time of 96.8221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.892 ns/day, 26.895 hours/ns, 10.328 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    | 95.815     | 95.815     | 95.815     |   0.0 | 98.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19889    | 0.19889    | 0.19889    |   0.0 |  0.21
Output  | 0.00017593 | 0.00017593 | 0.00017593 |   0.0 |  0.00
Modify  | 0.70386    | 0.70386    | 0.70386    |   0.0 |  0.73
Other   |            | 0.104      |            |       |  0.11

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:      898356.0 ave      898356 max      898356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898356
Ave neighs/atom = 224.58900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.79445159884, Press = 0.792050913605076
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13816.226   -13816.226   -13986.892   -13986.892    330.16437    330.16437    47976.464    47976.464   -75.864716   -75.864716 
   33000   -13810.558   -13810.558   -13982.913   -13982.913      333.432      333.432    48027.046    48027.046   -1108.1846   -1108.1846 
Loop time of 90.9221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.950 ns/day, 25.256 hours/ns, 10.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    | 89.961     | 89.961     | 89.961     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19102    | 0.19102    | 0.19102    |   0.0 |  0.21
Output  | 0.00017553 | 0.00017553 | 0.00017553 |   0.0 |  0.00
Modify  | 0.66827    | 0.66827    | 0.66827    |   0.0 |  0.73
Other   |            | 0.1015     |            |       |  0.11

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:      898132.0 ave      898132 max      898132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898132
Ave neighs/atom = 224.53300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.748513236517, Press = 0.676751766085034
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13810.558   -13810.558   -13982.913   -13982.913      333.432      333.432    48027.046    48027.046   -1108.1846   -1108.1846 
   34000   -13817.061   -13817.061   -13986.323   -13986.323    327.44849    327.44849    48011.982    48011.982   -1067.1598   -1067.1598 
Loop time of 91.2956 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.946 ns/day, 25.360 hours/ns, 10.953 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    | 90.324     | 90.324     | 90.324     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19501    | 0.19501    | 0.19501    |   0.0 |  0.21
Output  | 0.00017762 | 0.00017762 | 0.00017762 |   0.0 |  0.00
Modify  | 0.67445    | 0.67445    | 0.67445    |   0.0 |  0.74
Other   |            | 0.1023     |            |       |  0.11

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:      898072.0 ave      898072 max      898072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898072
Ave neighs/atom = 224.51800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.7150286662, Press = -1.93890550240875
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13817.061   -13817.061   -13986.323   -13986.323    327.44849    327.44849    48011.982    48011.982   -1067.1598   -1067.1598 
   35000   -13808.498   -13808.498   -13983.876   -13983.876    339.28032    339.28032    47942.289    47942.289    1334.2215    1334.2215 
Loop time of 90.8644 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.951 ns/day, 25.240 hours/ns, 11.005 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    | 89.902     | 89.902     | 89.902     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19281    | 0.19281    | 0.19281    |   0.0 |  0.21
Output  | 0.00018139 | 0.00018139 | 0.00018139 |   0.0 |  0.00
Modify  | 0.66852    | 0.66852    | 0.66852    |   0.0 |  0.74
Other   |            | 0.1009     |            |       |  0.11

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:      898066.0 ave      898066 max      898066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898066
Ave neighs/atom = 224.51650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.666309535397, Press = -1.49287139145232
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13808.498   -13808.498   -13983.876   -13983.876    339.28032    339.28032    47942.289    47942.289    1334.2215    1334.2215 
   36000   -13812.533   -13812.533   -13982.781   -13982.781    329.35593    329.35593    47948.753    47948.753    1181.1152    1181.1152 
Loop time of 96.5179 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.895 ns/day, 26.811 hours/ns, 10.361 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    | 95.515     | 95.515     | 95.515     |   0.0 | 98.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19705    | 0.19705    | 0.19705    |   0.0 |  0.20
Output  | 0.00022215 | 0.00022215 | 0.00022215 |   0.0 |  0.00
Modify  | 0.70409    | 0.70409    | 0.70409    |   0.0 |  0.73
Other   |            | 0.1016     |            |       |  0.11

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:      898380.0 ave      898380 max      898380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898380
Ave neighs/atom = 224.59500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.678053000013, Press = 0.827837494583361
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13812.533   -13812.533   -13982.781   -13982.781    329.35593    329.35593    47948.753    47948.753    1181.1152    1181.1152 
   37000   -13807.242   -13807.242   -13979.435   -13979.435     333.1187     333.1187     47999.03     47999.03    55.831152    55.831152 
Loop time of 90.876 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.951 ns/day, 25.243 hours/ns, 11.004 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    | 89.916     | 89.916     | 89.916     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19332    | 0.19332    | 0.19332    |   0.0 |  0.21
Output  | 0.00017622 | 0.00017622 | 0.00017622 |   0.0 |  0.00
Modify  | 0.66594    | 0.66594    | 0.66594    |   0.0 |  0.73
Other   |            | 0.1007     |            |       |  0.11

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:      898614.0 ave      898614 max      898614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898614
Ave neighs/atom = 224.65350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.698230958228, Press = 0.269342238611636
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13807.242   -13807.242   -13979.435   -13979.435     333.1187     333.1187     47999.03     47999.03    55.831152    55.831152 
   38000   -13813.315   -13813.315   -13986.335   -13986.335    334.71993    334.71993    47985.868    47985.868   -213.10097   -213.10097 
Loop time of 90.767 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.952 ns/day, 25.213 hours/ns, 11.017 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    | 89.805     | 89.805     | 89.805     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19166    | 0.19166    | 0.19166    |   0.0 |  0.21
Output  | 0.00017458 | 0.00017458 | 0.00017458 |   0.0 |  0.00
Modify  | 0.66903    | 0.66903    | 0.66903    |   0.0 |  0.74
Other   |            | 0.1006     |            |       |  0.11

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:      898138.0 ave      898138 max      898138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898138
Ave neighs/atom = 224.53450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.67689076952, Press = -0.0778264079104517
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13813.315   -13813.315   -13986.335   -13986.335    334.71993    334.71993    47985.868    47985.868   -213.10097   -213.10097 
   39000   -13814.893   -13814.893   -13985.936   -13985.936    330.89434    330.89434    47987.457    47987.457   -324.60393   -324.60393 
Loop time of 90.6974 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.953 ns/day, 25.194 hours/ns, 11.026 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    | 89.737     | 89.737     | 89.737     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19171    | 0.19171    | 0.19171    |   0.0 |  0.21
Output  | 0.00017708 | 0.00017708 | 0.00017708 |   0.0 |  0.00
Modify  | 0.66852    | 0.66852    | 0.66852    |   0.0 |  0.74
Other   |            | 0.1005     |            |       |  0.11

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:      898038.0 ave      898038 max      898038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898038
Ave neighs/atom = 224.50950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.715508233283, Press = 0.0189682618160305
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13814.893   -13814.893   -13985.936   -13985.936    330.89434    330.89434    47987.457    47987.457   -324.60393   -324.60393 
   40000   -13808.005   -13808.005    -13980.36    -13980.36    333.43184    333.43184    48014.995    48014.995   -455.90289   -455.90289 
Loop time of 90.7974 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.952 ns/day, 25.222 hours/ns, 11.014 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    | 89.836     | 89.836     | 89.836     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19211    | 0.19211    | 0.19211    |   0.0 |  0.21
Output  | 0.00017711 | 0.00017711 | 0.00017711 |   0.0 |  0.00
Modify  | 0.66747    | 0.66747    | 0.66747    |   0.0 |  0.74
Other   |            | 0.1015     |            |       |  0.11

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:      898036.0 ave      898036 max      898036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898036
Ave neighs/atom = 224.50900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.773961141377, Press = -0.727900447228713
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13808.005   -13808.005    -13980.36    -13980.36    333.43184    333.43184    48014.995    48014.995   -455.90289   -455.90289 
   41000   -13811.841   -13811.841   -13984.673   -13984.673    334.35379    334.35379    47959.254    47959.254    690.62682    690.62682 
Loop time of 102.989 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.839 ns/day, 28.608 hours/ns, 9.710 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    | 101.94     | 101.94     | 101.94     |   0.0 | 98.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20778    | 0.20778    | 0.20778    |   0.0 |  0.20
Output  | 0.0001774  | 0.0001774  | 0.0001774  |   0.0 |  0.00
Modify  | 0.73954    | 0.73954    | 0.73954    |   0.0 |  0.72
Other   |            | 0.1048     |            |       |  0.10

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:      897694.0 ave      897694 max      897694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897694
Ave neighs/atom = 224.42350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.814595749535, Press = -0.980512300651643
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13811.841   -13811.841   -13984.673   -13984.673    334.35379    334.35379    47959.254    47959.254    690.62682    690.62682 
   42000   -13812.968   -13812.968   -13986.079   -13986.079    334.89649    334.89649    47936.612    47936.612    1214.6744    1214.6744 
Loop time of 94.9349 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.910 ns/day, 26.371 hours/ns, 10.534 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    | 93.951     | 93.951     | 93.951     |   0.0 | 98.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19715    | 0.19715    | 0.19715    |   0.0 |  0.21
Output  | 0.00017673 | 0.00017673 | 0.00017673 |   0.0 |  0.00
Modify  | 0.68547    | 0.68547    | 0.68547    |   0.0 |  0.72
Other   |            | 0.1014     |            |       |  0.11

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:      898510.0 ave      898510 max      898510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898510
Ave neighs/atom = 224.62750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.880742158495, Press = 0.178656999512195
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13812.968   -13812.968   -13986.079   -13986.079    334.89649    334.89649    47936.612    47936.612    1214.6744    1214.6744 
   43000   -13809.213   -13809.213   -13980.751   -13980.751    331.85139    331.85139    47980.337    47980.337    471.61133    471.61133 
Loop time of 112.021 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.771 ns/day, 31.117 hours/ns, 8.927 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    | 111.02     | 111.02     | 111.02     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20433    | 0.20433    | 0.20433    |   0.0 |  0.18
Output  | 0.00018366 | 0.00018366 | 0.00018366 |   0.0 |  0.00
Modify  | 0.69803    | 0.69803    | 0.69803    |   0.0 |  0.62
Other   |            | 0.09879    |            |       |  0.09

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:      898640.0 ave      898640 max      898640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898640
Ave neighs/atom = 224.66000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.888808282084, Press = 1.42253971092928
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13809.213   -13809.213   -13980.751   -13980.751    331.85139    331.85139    47980.337    47980.337    471.61133    471.61133 
   44000   -13817.633   -13817.633   -13987.605   -13987.605    328.82288    328.82288    48055.148    48055.148    -2446.422    -2446.422 
Loop time of 93.5446 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.924 ns/day, 25.985 hours/ns, 10.690 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    | 92.579     | 92.579     | 92.579     |   0.0 | 98.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19211    | 0.19211    | 0.19211    |   0.0 |  0.21
Output  | 0.00017559 | 0.00017559 | 0.00017559 |   0.0 |  0.00
Modify  | 0.67209    | 0.67209    | 0.67209    |   0.0 |  0.72
Other   |            | 0.101      |            |       |  0.11

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:      898208.0 ave      898208 max      898208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898208
Ave neighs/atom = 224.55200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.845548921044, Press = 0.0246735561646917
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13817.633   -13817.633   -13987.605   -13987.605    328.82288    328.82288    48055.148    48055.148    -2446.422    -2446.422 
   45000   -13812.477   -13812.477   -13985.228   -13985.228    334.19871    334.19871    48014.032    48014.032   -969.96489   -969.96489 
Loop time of 90.9841 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.950 ns/day, 25.273 hours/ns, 10.991 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    | 90.023     | 90.023     | 90.023     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19216    | 0.19216    | 0.19216    |   0.0 |  0.21
Output  | 0.00017802 | 0.00017802 | 0.00017802 |   0.0 |  0.00
Modify  | 0.66751    | 0.66751    | 0.66751    |   0.0 |  0.73
Other   |            | 0.1012     |            |       |  0.11

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:      897468.0 ave      897468 max      897468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897468
Ave neighs/atom = 224.36700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.852257225482, Press = -0.826200847975925
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13812.477   -13812.477   -13985.228   -13985.228    334.19871    334.19871    48014.032    48014.032   -969.96489   -969.96489 
   46000   -13810.548   -13810.548   -13982.721   -13982.721    333.08038    333.08038    47968.981    47968.981    597.58556    597.58556 
Loop time of 91.0286 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.949 ns/day, 25.286 hours/ns, 10.986 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    | 90.067     | 90.067     | 90.067     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19078    | 0.19078    | 0.19078    |   0.0 |  0.21
Output  | 0.00017808 | 0.00017808 | 0.00017808 |   0.0 |  0.00
Modify  | 0.6689     | 0.6689     | 0.6689     |   0.0 |  0.73
Other   |            | 0.1014     |            |       |  0.11

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:      898096.0 ave      898096 max      898096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898096
Ave neighs/atom = 224.52400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.850313403833, Press = -0.3964691354796
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13810.548   -13810.548   -13982.721   -13982.721    333.08038    333.08038    47968.981    47968.981    597.58556    597.58556 
   47000   -13811.636   -13811.636   -13982.891   -13982.891    331.30498    331.30498    47964.276    47964.276    706.70437    706.70437 
Loop time of 90.8279 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.951 ns/day, 25.230 hours/ns, 11.010 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    | 89.866     | 89.866     | 89.866     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19242    | 0.19242    | 0.19242    |   0.0 |  0.21
Output  | 0.0001732  | 0.0001732  | 0.0001732  |   0.0 |  0.00
Modify  | 0.66811    | 0.66811    | 0.66811    |   0.0 |  0.74
Other   |            | 0.101      |            |       |  0.11

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:      898264.0 ave      898264 max      898264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898264
Ave neighs/atom = 224.56600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.852833317674, Press = 0.148780570664618
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13811.636   -13811.636   -13982.891   -13982.891    331.30498    331.30498    47964.276    47964.276    706.70437    706.70437 
   48000   -13814.144   -13814.144   -13984.239   -13984.239    329.06045    329.06045    48012.659    48012.659   -874.64714   -874.64714 
Loop time of 91.2985 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.946 ns/day, 25.361 hours/ns, 10.953 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    | 90.331     | 90.331     | 90.331     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19334    | 0.19334    | 0.19334    |   0.0 |  0.21
Output  | 0.00017451 | 0.00017451 | 0.00017451 |   0.0 |  0.00
Modify  | 0.67283    | 0.67283    | 0.67283    |   0.0 |  0.74
Other   |            | 0.101      |            |       |  0.11

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:      898374.0 ave      898374 max      898374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898374
Ave neighs/atom = 224.59350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.86083793818, Press = 0.853705933811068
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -13814.144   -13814.144   -13984.239   -13984.239    329.06045    329.06045    48012.659    48012.659   -874.64714   -874.64714 
   49000   -13811.513   -13811.513   -13980.529   -13980.529    326.97336    326.97336    48067.655    48067.655    -2133.997    -2133.997 
Loop time of 91.3846 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.945 ns/day, 25.385 hours/ns, 10.943 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    | 90.416     | 90.416     | 90.416     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19282    | 0.19282    | 0.19282    |   0.0 |  0.21
Output  | 0.00017863 | 0.00017863 | 0.00017863 |   0.0 |  0.00
Modify  | 0.67459    | 0.67459    | 0.67459    |   0.0 |  0.74
Other   |            | 0.1006     |            |       |  0.11

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:      898262.0 ave      898262 max      898262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898262
Ave neighs/atom = 224.56550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.87160503288, Press = -1.42162970999933
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13811.513   -13811.513   -13980.529   -13980.529    326.97336    326.97336    48067.655    48067.655    -2133.997    -2133.997 
   50000   -13805.496   -13805.496   -13982.695   -13982.695    342.80378    342.80378    47961.581    47961.581    892.99309    892.99309 
Loop time of 91.4757 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.945 ns/day, 25.410 hours/ns, 10.932 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 90.508     | 90.508     | 90.508     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19349    | 0.19349    | 0.19349    |   0.0 |  0.21
Output  | 0.0002355  | 0.0002355  | 0.0002355  |   0.0 |  0.00
Modify  | 0.67181    | 0.67181    | 0.67181    |   0.0 |  0.73
Other   |            | 0.1024     |            |       |  0.11

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:      897242.0 ave      897242 max      897242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897242
Ave neighs/atom = 224.31050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.902476810408, Press = -1.23292897981443
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -13805.496   -13805.496   -13982.695   -13982.695    342.80378    342.80378    47961.581    47961.581    892.99309    892.99309 
   51000   -13808.435   -13808.435   -13981.308   -13981.308    334.43432    334.43432     47930.46     47930.46    1879.7965    1879.7965 
Loop time of 91.3533 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.946 ns/day, 25.376 hours/ns, 10.947 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    | 90.385     | 90.385     | 90.385     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19387    | 0.19387    | 0.19387    |   0.0 |  0.21
Output  | 0.0001798  | 0.0001798  | 0.0001798  |   0.0 |  0.00
Modify  | 0.67276    | 0.67276    | 0.67276    |   0.0 |  0.74
Other   |            | 0.1014     |            |       |  0.11

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:      898636.0 ave      898636 max      898636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898636
Ave neighs/atom = 224.65900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.931568461198, Press = 0.158035693156505
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -13808.435   -13808.435   -13981.308   -13981.308    334.43432    334.43432     47930.46     47930.46    1879.7965    1879.7965 
   52000   -13815.069   -13815.069   -13987.936   -13987.936    334.42288    334.42288    47980.915    47980.915   -329.85655   -329.85655 
Loop time of 91.3207 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.946 ns/day, 25.367 hours/ns, 10.950 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    | 90.353     | 90.353     | 90.353     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19354    | 0.19354    | 0.19354    |   0.0 |  0.21
Output  | 0.00017615 | 0.00017615 | 0.00017615 |   0.0 |  0.00
Modify  | 0.6722     | 0.6722     | 0.6722     |   0.0 |  0.74
Other   |            | 0.1016     |            |       |  0.11

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:      898768.0 ave      898768 max      898768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898768
Ave neighs/atom = 224.69200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.905022584537, Press = 0.815223873012376
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -13815.069   -13815.069   -13987.936   -13987.936    334.42288    334.42288    47980.915    47980.915   -329.85655   -329.85655 
   53000   -13810.463   -13810.463   -13985.013   -13985.013    337.67978    337.67978     48044.51     48044.51    -1812.164    -1812.164 
Loop time of 91.3343 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.946 ns/day, 25.371 hours/ns, 10.949 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    | 90.368     | 90.368     | 90.368     |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19372    | 0.19372    | 0.19372    |   0.0 |  0.21
Output  | 0.00022783 | 0.00022783 | 0.00022783 |   0.0 |  0.00
Modify  | 0.67106    | 0.67106    | 0.67106    |   0.0 |  0.73
Other   |            | 0.1017     |            |       |  0.11

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:      898260.0 ave      898260 max      898260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898260
Ave neighs/atom = 224.56500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.901796318494, Press = -0.361257729112375
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -13810.463   -13810.463   -13985.013   -13985.013    337.67978    337.67978     48044.51     48044.51    -1812.164    -1812.164 
   54000   -13805.682   -13805.682   -13978.562   -13978.562    334.44815    334.44815    47994.884    47994.884    291.56793    291.56793 
Loop time of 91.2057 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.947 ns/day, 25.335 hours/ns, 10.964 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    | 90.24      | 90.24      | 90.24      |   0.0 | 98.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19227    | 0.19227    | 0.19227    |   0.0 |  0.21
Output  | 0.00022636 | 0.00022636 | 0.00022636 |   0.0 |  0.00
Modify  | 0.6718     | 0.6718     | 0.6718     |   0.0 |  0.74
Other   |            | 0.1019     |            |       |  0.11

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:      897690.0 ave      897690 max      897690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 897690
Ave neighs/atom = 224.42250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.901214279528, Press = -0.597284251048426
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -13805.682   -13805.682   -13978.562   -13978.562    334.44815    334.44815    47994.884    47994.884    291.56793    291.56793 
   55000   -13812.956   -13812.956   -13983.148   -13983.148    329.24776    329.24776    47975.451    47975.451    324.54918    324.54918 
Loop time of 89.4962 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.965 ns/day, 24.860 hours/ns, 11.174 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    | 88.536     | 88.536     | 88.536     |   0.0 | 98.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18745    | 0.18745    | 0.18745    |   0.0 |  0.21
Output  | 0.00022041 | 0.00022041 | 0.00022041 |   0.0 |  0.00
Modify  | 0.67026    | 0.67026    | 0.67026    |   0.0 |  0.75
Other   |            | 0.1026     |            |       |  0.11

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:      898254.0 ave      898254 max      898254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 898254
Ave neighs/atom = 224.56350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.937958136676, Press = -0.0694014309099535
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 = 8.724884
  ghost atom cutoff = 8.724884
  binsize = 4.362442, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.72488399972482
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -13812.956   -13812.956   -13983.148   -13983.148    329.24776    329.24776    47975.451    47975.451    324.54918    324.54918 
   56000   -13806.656   -13806.656   -13982.007   -13982.007    339.22876    339.22876    48009.063    48009.063    -449.6499    -449.6499 
Loop time of 105.147 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.822 ns/day, 29.207 hours/ns, 9.511 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.08     | 104.08     | 104.08     |   0.0 | 98.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20572    | 0.20572    | 0.20572    |   0.0 |  0.20
Output  | 0.00017601 | 0.00017601 | 0.00017601 |   0.0 |  0.00
Modify  | 0.7588     | 0.7588     | 0.7588     |   0.0 |  0.72
Other   |            | 0.1065     |            |       |  0.10

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:      898322.0 ave      898322 max      898322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0