# 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.6133156493306164*${_u_distance}
variable latticeconst_converted equal 3.6133156493306164*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331564933062
Lattice spacing in x,y,z = 3.6133156 3.6133156 3.6133156
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.133156 36.133156 36.133156)
  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.133156 36.133156 36.133156)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Cu

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

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


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13998.129   -13998.129       -14160       -14160       313.15       313.15     47175.63     47175.63    3664.9628    3664.9628 
    1000   -13827.921   -13827.921   -13993.569   -13993.569    320.45756    320.45756    48028.204    48028.204   -1241.1994   -1241.1994 
Loop time of 419.9 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.639 hours/ns, 2.382 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    | 418.84     | 418.84     | 418.84     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16246    | 0.16246    | 0.16246    |   0.0 |  0.04
Output  | 0.00026585 | 0.00026585 | 0.00026585 |   0.0 |  0.00
Modify  | 0.79559    | 0.79559    | 0.79559    |   0.0 |  0.19
Other   |            | 0.1062     |            |       |  0.03

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

Total # of neighbors = 536000
Ave neighs/atom = 134.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13827.921   -13827.921   -13993.569   -13993.569    320.45756    320.45756    48028.204    48028.204   -1241.1994   -1241.1994 
    2000   -13839.016   -13839.016   -14001.672   -14001.672    314.66872    314.66872    47992.242    47992.242   -1071.7595   -1071.7595 
Loop time of 431.305 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.807 hours/ns, 2.319 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    | 430.23     | 430.23     | 430.23     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16483    | 0.16483    | 0.16483    |   0.0 |  0.04
Output  | 0.00026607 | 0.00026607 | 0.00026607 |   0.0 |  0.00
Modify  | 0.806      | 0.806      | 0.806      |   0.0 |  0.19
Other   |            | 0.1067     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5844.00 ave        5844 max        5844 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:      528374.0 ave      528374 max      528374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528374
Ave neighs/atom = 132.09350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13839.016   -13839.016   -14001.672   -14001.672    314.66872    314.66872    47992.242    47992.242   -1071.7595   -1071.7595 
    3000   -13835.771   -13835.771   -14001.546   -14001.546    320.70365    320.70365    47954.874    47954.874      240.854      240.854 
Loop time of 432.15 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.042 hours/ns, 2.314 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    | 431.06     | 431.06     | 431.06     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16552    | 0.16552    | 0.16552    |   0.0 |  0.04
Output  | 0.00022026 | 0.00022026 | 0.00022026 |   0.0 |  0.00
Modify  | 0.81855    | 0.81855    | 0.81855    |   0.0 |  0.19
Other   |            | 0.1087     |            |       |  0.03

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

Total # of neighbors = 529536
Ave neighs/atom = 132.38400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13835.771   -13835.771   -14001.546   -14001.546    320.70365    320.70365    47954.874    47954.874      240.854      240.854 
    4000   -13835.538   -13835.538   -13997.886   -13997.886    314.07445    314.07445    47999.191    47999.191   -776.20443   -776.20443 
Loop time of 415.409 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.391 hours/ns, 2.407 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    | 414.35     | 414.35     | 414.35     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16096    | 0.16096    | 0.16096    |   0.0 |  0.04
Output  | 0.00022215 | 0.00022215 | 0.00022215 |   0.0 |  0.00
Modify  | 0.78684    | 0.78684    | 0.78684    |   0.0 |  0.19
Other   |            | 0.1071     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5844.00 ave        5844 max        5844 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:      530080.0 ave      530080 max      530080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530080
Ave neighs/atom = 132.52000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13835.538   -13835.538   -13997.886   -13997.886    314.07445    314.07445    47999.191    47999.191   -776.20443   -776.20443 
    5000   -13839.845   -13839.845   -13996.818   -13996.818    303.67417    303.67417    47969.938    47969.938    163.71576    163.71576 
Loop time of 395.935 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 109.982 hours/ns, 2.526 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    | 394.96     | 394.96     | 394.96     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15548    | 0.15548    | 0.15548    |   0.0 |  0.04
Output  | 0.00018267 | 0.00018267 | 0.00018267 |   0.0 |  0.00
Modify  | 0.72092    | 0.72092    | 0.72092    |   0.0 |  0.18
Other   |            | 0.1009     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      529176.0 ave      529176 max      529176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529176
Ave neighs/atom = 132.29400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.886414153444, Press = -328.473818500616
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13839.845   -13839.845   -13996.818   -13996.818    303.67417    303.67417    47969.938    47969.938    163.71576    163.71576 
    6000   -13832.257   -13832.257   -13998.425   -13998.425    321.46281    321.46281    47949.822    47949.822    792.22417    792.22417 
Loop time of 433.195 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.332 hours/ns, 2.308 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    | 432.07     | 432.07     | 432.07     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16643    | 0.16643    | 0.16643    |   0.0 |  0.04
Output  | 0.00028042 | 0.00028042 | 0.00028042 |   0.0 |  0.00
Modify  | 0.84661    | 0.84661    | 0.84661    |   0.0 |  0.20
Other   |            | 0.1078     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5847.00 ave        5847 max        5847 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:      529532.0 ave      529532 max      529532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529532
Ave neighs/atom = 132.38300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.488081522501, Press = -5.77664315152288
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13832.257   -13832.257   -13998.425   -13998.425    321.46281    321.46281    47949.822    47949.822    792.22417    792.22417 
    7000   -13839.916   -13839.916   -13998.644   -13998.644    307.07113    307.07113    47990.871    47990.871   -555.10484   -555.10484 
Loop time of 433.779 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.494 hours/ns, 2.305 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    | 432.65     | 432.65     | 432.65     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16676    | 0.16676    | 0.16676    |   0.0 |  0.04
Output  | 0.00023376 | 0.00023376 | 0.00023376 |   0.0 |  0.00
Modify  | 0.85517    | 0.85517    | 0.85517    |   0.0 |  0.20
Other   |            | 0.1086     |            |       |  0.03

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

Total # of neighbors = 530056
Ave neighs/atom = 132.51400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.919461747876, Press = 6.33444439288017
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13839.916   -13839.916   -13998.644   -13998.644    307.07113    307.07113    47990.871    47990.871   -555.10484   -555.10484 
    8000   -13838.151   -13838.151   -13998.326   -13998.326    309.87025    309.87025    48025.588    48025.588   -1624.4256   -1624.4256 
Loop time of 429.27 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.242 hours/ns, 2.330 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    | 428.15     | 428.15     | 428.15     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16625    | 0.16625    | 0.16625    |   0.0 |  0.04
Output  | 0.00017979 | 0.00017979 | 0.00017979 |   0.0 |  0.00
Modify  | 0.84685    | 0.84685    | 0.84685    |   0.0 |  0.20
Other   |            | 0.108      |            |       |  0.03

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

Total # of neighbors = 529750
Ave neighs/atom = 132.43750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.081594732588, Press = -29.1114148897752
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13838.151   -13838.151   -13998.326   -13998.326    309.87025    309.87025    48025.588    48025.588   -1624.4256   -1624.4256 
    9000   -13831.937   -13831.937   -13994.099   -13994.099    313.71151    313.71151    47901.848    47901.848    2548.8749    2548.8749 
Loop time of 431.427 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.841 hours/ns, 2.318 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    | 430.31     | 430.31     | 430.31     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16553    | 0.16553    | 0.16553    |   0.0 |  0.04
Output  | 0.00030117 | 0.00030117 | 0.00030117 |   0.0 |  0.00
Modify  | 0.84224    | 0.84224    | 0.84224    |   0.0 |  0.20
Other   |            | 0.1072     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      529060.0 ave      529060 max      529060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529060
Ave neighs/atom = 132.26500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.445855840531, Press = -2.21842474616987
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13831.937   -13831.937   -13994.099   -13994.099    313.71151    313.71151    47901.848    47901.848    2548.8749    2548.8749 
   10000   -13838.576   -13838.576   -13999.095   -13999.095    310.53421    310.53421    47969.812    47969.812   -35.987423   -35.987423 
Loop time of 433.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.354 hours/ns, 2.308 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    | 432.17     | 432.17     | 432.17     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16401    | 0.16401    | 0.16401    |   0.0 |  0.04
Output  | 0.00018092 | 0.00018092 | 0.00018092 |   0.0 |  0.00
Modify  | 0.82958    | 0.82958    | 0.82958    |   0.0 |  0.19
Other   |            | 0.1068     |            |       |  0.02

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

Total # of neighbors = 529912
Ave neighs/atom = 132.47800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.656548243966, Press = 1.43518305529727
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13838.576   -13838.576   -13999.095   -13999.095    310.53421    310.53421    47969.812    47969.812   -35.987423   -35.987423 
   11000   -13834.685   -13834.685   -13995.175   -13995.175    310.48054    310.48054    48005.272    48005.272   -661.75839   -661.75839 
Loop time of 432.269 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.075 hours/ns, 2.313 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    | 431.17     | 431.17     | 431.17     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16488    | 0.16488    | 0.16488    |   0.0 |  0.04
Output  | 0.00031684 | 0.00031684 | 0.00031684 |   0.0 |  0.00
Modify  | 0.8284     | 0.8284     | 0.8284     |   0.0 |  0.19
Other   |            | 0.1062     |            |       |  0.02

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

Total # of neighbors = 529604
Ave neighs/atom = 132.40100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.703434666579, Press = -4.67225313811292
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13834.685   -13834.685   -13995.175   -13995.175    310.48054    310.48054    48005.272    48005.272   -661.75839   -661.75839 
   12000   -13835.918   -13835.918   -13997.004   -13997.004    311.63286    311.63286    47956.235    47956.235    524.88485    524.88485 
Loop time of 432.389 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.108 hours/ns, 2.313 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    | 431.28     | 431.28     | 431.28     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1661     | 0.1661     | 0.1661     |   0.0 |  0.04
Output  | 0.00025021 | 0.00025021 | 0.00025021 |   0.0 |  0.00
Modify  | 0.83413    | 0.83413    | 0.83413    |   0.0 |  0.19
Other   |            | 0.1059     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      529072.0 ave      529072 max      529072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529072
Ave neighs/atom = 132.26800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.382134622558, Press = -4.99831640949235
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13835.918   -13835.918   -13997.004   -13997.004    311.63286    311.63286    47956.235    47956.235    524.88485    524.88485 
   13000     -13837.7     -13837.7   -13999.173   -13999.173    312.37992    312.37992    47966.828    47966.828    39.879063    39.879063 
Loop time of 433.647 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.458 hours/ns, 2.306 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    | 432.55     | 432.55     | 432.55     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16486    | 0.16486    | 0.16486    |   0.0 |  0.04
Output  | 0.00025142 | 0.00025142 | 0.00025142 |   0.0 |  0.00
Modify  | 0.8304     | 0.8304     | 0.8304     |   0.0 |  0.19
Other   |            | 0.1064     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      529584.0 ave      529584 max      529584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529584
Ave neighs/atom = 132.39600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.374901421685, Press = 1.02800519163137
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000     -13837.7     -13837.7   -13999.173   -13999.173    312.37992    312.37992    47966.828    47966.828    39.879063    39.879063 
   14000   -13835.661   -13835.661   -13995.548   -13995.548    309.31226    309.31226    48020.567    48020.567   -1005.1646   -1005.1646 
Loop time of 432.635 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.176 hours/ns, 2.311 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    | 431.55     | 431.55     | 431.55     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16403    | 0.16403    | 0.16403    |   0.0 |  0.04
Output  | 0.00025491 | 0.00025491 | 0.00025491 |   0.0 |  0.00
Modify  | 0.81842    | 0.81842    | 0.81842    |   0.0 |  0.19
Other   |            | 0.1046     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5845.00 ave        5845 max        5845 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:      529618.0 ave      529618 max      529618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529618
Ave neighs/atom = 132.40450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.496612458105, Press = -4.30960756407178
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13835.661   -13835.661   -13995.548   -13995.548    309.31226    309.31226    48020.567    48020.567   -1005.1646   -1005.1646 
   15000   -13837.666   -13837.666   -13996.222   -13996.222    306.73694    306.73694    47910.877    47910.877    2039.6683    2039.6683 
Loop time of 432.952 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.264 hours/ns, 2.310 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    | 431.83     | 431.83     | 431.83     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16701    | 0.16701    | 0.16701    |   0.0 |  0.04
Output  | 0.00028467 | 0.00028467 | 0.00028467 |   0.0 |  0.00
Modify  | 0.84943    | 0.84943    | 0.84943    |   0.0 |  0.20
Other   |            | 0.1082     |            |       |  0.02

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

Total # of neighbors = 529110
Ave neighs/atom = 132.27750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.575491436165, Press = -5.73370712449026
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13837.666   -13837.666   -13996.222   -13996.222    306.73694    306.73694    47910.877    47910.877    2039.6683    2039.6683 
   16000   -13835.037   -13835.037   -13996.937   -13996.937    313.20758    313.20758    47956.141    47956.141    721.30756    721.30756 
Loop time of 432.613 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.170 hours/ns, 2.312 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    | 431.49     | 431.49     | 431.49     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16682    | 0.16682    | 0.16682    |   0.0 |  0.04
Output  | 0.0001799  | 0.0001799  | 0.0001799  |   0.0 |  0.00
Modify  | 0.8434     | 0.8434     | 0.8434     |   0.0 |  0.19
Other   |            | 0.1078     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5847.00 ave        5847 max        5847 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:      529984.0 ave      529984 max      529984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529984
Ave neighs/atom = 132.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 = 313.530685799129, Press = 3.27953346213109
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13835.037   -13835.037   -13996.937   -13996.937    313.20758    313.20758    47956.141    47956.141    721.30756    721.30756 
   17000   -13840.059   -13840.059   -13999.414   -13999.414    308.28206    308.28206    47985.811    47985.811    -555.7731    -555.7731 
Loop time of 429.808 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.391 hours/ns, 2.327 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    | 428.7      | 428.7      | 428.7      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16549    | 0.16549    | 0.16549    |   0.0 |  0.04
Output  | 0.00017931 | 0.00017931 | 0.00017931 |   0.0 |  0.00
Modify  | 0.83387    | 0.83387    | 0.83387    |   0.0 |  0.19
Other   |            | 0.1064     |            |       |  0.02

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

Total # of neighbors = 529874
Ave neighs/atom = 132.46850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.657266246027, Press = -2.2774421924336
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13840.059   -13840.059   -13999.414   -13999.414    308.28206    308.28206    47985.811    47985.811    -555.7731    -555.7731 
   18000   -13834.753   -13834.753   -13999.971   -13999.971    319.62495    319.62495    47965.436    47965.436    86.325841    86.325841 
Loop time of 412.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.568 hours/ns, 2.425 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    | 411.38     | 411.38     | 411.38     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16202    | 0.16202    | 0.16202    |   0.0 |  0.04
Output  | 0.00022873 | 0.00022873 | 0.00022873 |   0.0 |  0.00
Modify  | 0.80154    | 0.80154    | 0.80154    |   0.0 |  0.19
Other   |            | 0.1041     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      529526.0 ave      529526 max      529526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529526
Ave neighs/atom = 132.38150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.722174976219, Press = -2.67258805020252
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13834.753   -13834.753   -13999.971   -13999.971    319.62495    319.62495    47965.436    47965.436    86.325841    86.325841 
   19000   -13840.874   -13840.874   -14002.045   -14002.045    311.79657    311.79657     47959.59     47959.59   -47.785076   -47.785076 
Loop time of 369.693 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.692 hours/ns, 2.705 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    | 368.78     | 368.78     | 368.78     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14748    | 0.14748    | 0.14748    |   0.0 |  0.04
Output  | 0.00017942 | 0.00017942 | 0.00017942 |   0.0 |  0.00
Modify  | 0.66836    | 0.66836    | 0.66836    |   0.0 |  0.18
Other   |            | 0.0933     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      529952.0 ave      529952 max      529952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529952
Ave neighs/atom = 132.48800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.650856240595, Press = 0.575976812493568
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13840.874   -13840.874   -14002.045   -14002.045    311.79657    311.79657     47959.59     47959.59   -47.785076   -47.785076 
   20000   -13835.534   -13835.534    -13998.45    -13998.45    315.17289    315.17289    48003.256    48003.256   -865.84299   -865.84299 
Loop time of 368.706 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.418 hours/ns, 2.712 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    | 367.8      | 367.8      | 367.8      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1479     | 0.1479     | 0.1479     |   0.0 |  0.04
Output  | 0.00018672 | 0.00018672 | 0.00018672 |   0.0 |  0.00
Modify  | 0.66805    | 0.66805    | 0.66805    |   0.0 |  0.18
Other   |            | 0.0927     |            |       |  0.03

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

Total # of neighbors = 530112
Ave neighs/atom = 132.52800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.518784794691, Press = -2.25924353997416
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13835.534   -13835.534    -13998.45    -13998.45    315.17289    315.17289    48003.256    48003.256   -865.84299   -865.84299 
   21000   -13840.065   -13840.065   -13998.423   -13998.423    306.35499    306.35499    47918.337    47918.337    1527.1823    1527.1823 
Loop time of 388.922 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.034 hours/ns, 2.571 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    | 387.94     | 387.94     | 387.94     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15481    | 0.15481    | 0.15481    |   0.0 |  0.04
Output  | 0.00023128 | 0.00023128 | 0.00023128 |   0.0 |  0.00
Modify  | 0.72765    | 0.72765    | 0.72765    |   0.0 |  0.19
Other   |            | 0.09894    |            |       |  0.03

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

Total # of neighbors = 529314
Ave neighs/atom = 132.32850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.4828609001, Press = -1.42447530547448
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13840.065   -13840.065   -13998.423   -13998.423    306.35499    306.35499    47918.337    47918.337    1527.1823    1527.1823 
   22000   -13831.252   -13831.252   -13999.437   -13999.437    325.36541    325.36541    47999.683    47999.683   -673.20077   -673.20077 
Loop time of 428.367 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.991 hours/ns, 2.334 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    | 427.27     | 427.27     | 427.27     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16349    | 0.16349    | 0.16349    |   0.0 |  0.04
Output  | 0.00022678 | 0.00022678 | 0.00022678 |   0.0 |  0.00
Modify  | 0.83017    | 0.83017    | 0.83017    |   0.0 |  0.19
Other   |            | 0.1068     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      530192.0 ave      530192 max      530192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530192
Ave neighs/atom = 132.54800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.543259392565, Press = 1.52784933316787
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13831.252   -13831.252   -13999.437   -13999.437    325.36541    325.36541    47999.683    47999.683   -673.20077   -673.20077 
   23000   -13837.106   -13837.106   -13998.596   -13998.596    312.41426    312.41426    48011.224    48011.224   -1114.3484   -1114.3484 
Loop time of 419.265 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.462 hours/ns, 2.385 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    | 418.18     | 418.18     | 418.18     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16315    | 0.16315    | 0.16315    |   0.0 |  0.04
Output  | 0.00028184 | 0.00028184 | 0.00028184 |   0.0 |  0.00
Modify  | 0.81182    | 0.81182    | 0.81182    |   0.0 |  0.19
Other   |            | 0.1062     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      529830.0 ave      529830 max      529830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529830
Ave neighs/atom = 132.45750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.563287073407, Press = -2.55354211076842
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13837.106   -13837.106   -13998.596   -13998.596    312.41426    312.41426    48011.224    48011.224   -1114.3484   -1114.3484 
   24000   -13828.361   -13828.361    -13994.66    -13994.66    321.71642    321.71642      47947.5      47947.5    1243.4278    1243.4278 
Loop time of 401.602 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.556 hours/ns, 2.490 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    | 400.59     | 400.59     | 400.59     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1568     | 0.1568     | 0.1568     |   0.0 |  0.04
Output  | 0.00023294 | 0.00023294 | 0.00023294 |   0.0 |  0.00
Modify  | 0.75713    | 0.75713    | 0.75713    |   0.0 |  0.19
Other   |            | 0.1024     |            |       |  0.03

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

Total # of neighbors = 529390
Ave neighs/atom = 132.34750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.623383768482, Press = -2.90620992336961
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13828.361   -13828.361    -13994.66    -13994.66    321.71642    321.71642      47947.5      47947.5    1243.4278    1243.4278 
   25000   -13837.057   -13837.057   -13996.874   -13996.874    309.17743    309.17743    47959.554    47959.554    336.11066    336.11066 
Loop time of 431.208 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.780 hours/ns, 2.319 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    | 430.1      | 430.1      | 430.1      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16448    | 0.16448    | 0.16448    |   0.0 |  0.04
Output  | 0.00018119 | 0.00018119 | 0.00018119 |   0.0 |  0.00
Modify  | 0.83175    | 0.83175    | 0.83175    |   0.0 |  0.19
Other   |            | 0.1074     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      529302.0 ave      529302 max      529302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529302
Ave neighs/atom = 132.32550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.647018252238, Press = 1.42971931993957
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13837.057   -13837.057   -13996.874   -13996.874    309.17743    309.17743    47959.554    47959.554    336.11066    336.11066 
   26000    -13841.66    -13841.66   -13999.065   -13999.065    304.51036    304.51036    47996.199    47996.199   -874.99831   -874.99831 
Loop time of 424.898 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.027 hours/ns, 2.354 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    | 423.81     | 423.81     | 423.81     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16334    | 0.16334    | 0.16334    |   0.0 |  0.04
Output  | 0.00018335 | 0.00018335 | 0.00018335 |   0.0 |  0.00
Modify  | 0.81739    | 0.81739    | 0.81739    |   0.0 |  0.19
Other   |            | 0.1064     |            |       |  0.03

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

Total # of neighbors = 529612
Ave neighs/atom = 132.40300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.610592063695, Press = -0.626882669822509
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -13841.66    -13841.66   -13999.065   -13999.065    304.51036    304.51036    47996.199    47996.199   -874.99831   -874.99831 
   27000   -13835.502   -13835.502   -13998.399   -13998.399    315.13445    315.13445    47957.624    47957.624    405.25661    405.25661 
Loop time of 407.913 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.309 hours/ns, 2.452 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    | 406.87     | 406.87     | 406.87     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15929    | 0.15929    | 0.15929    |   0.0 |  0.04
Output  | 0.00022796 | 0.00022796 | 0.00022796 |   0.0 |  0.00
Modify  | 0.77819    | 0.77819    | 0.77819    |   0.0 |  0.19
Other   |            | 0.1018     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      529638.0 ave      529638 max      529638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529638
Ave neighs/atom = 132.40950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.543847577535, Press = -2.51641945644449
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13835.502   -13835.502   -13998.399   -13998.399    315.13445    315.13445    47957.624    47957.624    405.25661    405.25661 
   28000   -13835.583   -13835.583   -14000.543   -14000.543    319.12526    319.12526    47964.764    47964.764    60.653576    60.653576 
Loop time of 431.374 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.826 hours/ns, 2.318 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    | 430.25     | 430.25     | 430.25     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16613    | 0.16613    | 0.16613    |   0.0 |  0.04
Output  | 0.0001815  | 0.0001815  | 0.0001815  |   0.0 |  0.00
Modify  | 0.84841    | 0.84841    | 0.84841    |   0.0 |  0.20
Other   |            | 0.1072     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5846.00 ave        5846 max        5846 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:      529636.0 ave      529636 max      529636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529636
Ave neighs/atom = 132.40900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.472957698555, Press = 0.795585610198959
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13835.583   -13835.583   -14000.543   -14000.543    319.12526    319.12526    47964.764    47964.764    60.653576    60.653576 
   29000   -13837.189   -13837.189    -14001.08    -14001.08    317.05737    317.05737     48023.67     48023.67   -1660.2911   -1660.2911 
Loop time of 379.091 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.303 hours/ns, 2.638 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    | 378.15     | 378.15     | 378.15     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14821    | 0.14821    | 0.14821    |   0.0 |  0.04
Output  | 0.00017602 | 0.00017602 | 0.00017602 |   0.0 |  0.00
Modify  | 0.69617    | 0.69617    | 0.69617    |   0.0 |  0.18
Other   |            | 0.09965    |            |       |  0.03

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

Total # of neighbors = 530042
Ave neighs/atom = 132.51050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.490082311334, Press = -0.906642952065726
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13837.189   -13837.189    -14001.08    -14001.08    317.05737    317.05737     48023.67     48023.67   -1660.2911   -1660.2911 
   30000   -13837.659   -13837.659   -14002.096   -14002.096    318.11524    318.11524    47950.573    47950.573    220.01143    220.01143 
Loop time of 414.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.126 hours/ns, 2.413 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    | 413.4      | 413.4      | 413.4      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15803    | 0.15803    | 0.15803    |   0.0 |  0.04
Output  | 0.0001816  | 0.0001816  | 0.0001816  |   0.0 |  0.00
Modify  | 0.78854    | 0.78854    | 0.78854    |   0.0 |  0.19
Other   |            | 0.1062     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5844.00 ave        5844 max        5844 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:      529608.0 ave      529608 max      529608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529608
Ave neighs/atom = 132.40200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.392152924888, Press = -2.24218004164077
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13837.659   -13837.659   -14002.096   -14002.096    318.11524    318.11524    47950.573    47950.573    220.01143    220.01143 
   31000   -13832.491   -13832.491   -13997.893   -13997.893    319.98208    319.98208      47945.8      47945.8    902.53593    902.53593 
Loop time of 393.421 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.284 hours/ns, 2.542 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    | 392.42     | 392.42     | 392.42     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15288    | 0.15288    | 0.15288    |   0.0 |  0.04
Output  | 0.00024786 | 0.00024786 | 0.00024786 |   0.0 |  0.00
Modify  | 0.74213    | 0.74213    | 0.74213    |   0.0 |  0.19
Other   |            | 0.1013     |            |       |  0.03

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

Total # of neighbors = 530218
Ave neighs/atom = 132.55450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.382072224689, Press = 0.664602931356307
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13832.491   -13832.491   -13997.893   -13997.893    319.98208    319.98208      47945.8      47945.8    902.53593    902.53593 
   32000   -13837.507   -13837.507   -13998.595   -13998.595    311.63641    311.63641    47989.679    47989.679   -484.82588   -484.82588 
Loop time of 400.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.118 hours/ns, 2.500 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    | 399.02     | 399.02     | 399.02     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15438    | 0.15438    | 0.15438    |   0.0 |  0.04
Output  | 0.00018012 | 0.00018012 | 0.00018012 |   0.0 |  0.00
Modify  | 0.75062    | 0.75062    | 0.75062    |   0.0 |  0.19
Other   |            | 0.1033     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      529918.0 ave      529918 max      529918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529918
Ave neighs/atom = 132.47950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.478492444634, Press = -0.802110801672122
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13837.507   -13837.507   -13998.595   -13998.595    311.63641    311.63641    47989.679    47989.679   -484.82588   -484.82588 
   33000   -13834.577   -13834.577   -13997.005   -13997.005    314.22742    314.22742     47970.48     47970.48    178.43678    178.43678 
Loop time of 429.335 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.260 hours/ns, 2.329 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    | 428.22     | 428.22     | 428.22     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1658     | 0.1658     | 0.1658     |   0.0 |  0.04
Output  | 0.00018038 | 0.00018038 | 0.00018038 |   0.0 |  0.00
Modify  | 0.84264    | 0.84264    | 0.84264    |   0.0 |  0.20
Other   |            | 0.109      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      529500.0 ave      529500 max      529500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529500
Ave neighs/atom = 132.37500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.45611488357, Press = -1.2983641861499
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13834.577   -13834.577   -13997.005   -13997.005    314.22742    314.22742     47970.48     47970.48    178.43678    178.43678 
   34000   -13838.877   -13838.877   -13999.516   -13999.516    310.76699    310.76699    47963.985    47963.985    106.35862    106.35862 
Loop time of 418.884 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.357 hours/ns, 2.387 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    | 417.83     | 417.83     | 417.83     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15946    | 0.15946    | 0.15946    |   0.0 |  0.04
Output  | 0.00022596 | 0.00022596 | 0.00022596 |   0.0 |  0.00
Modify  | 0.79249    | 0.79249    | 0.79249    |   0.0 |  0.19
Other   |            | 0.1039     |            |       |  0.02

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

Total # of neighbors = 529680
Ave neighs/atom = 132.42000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.377588003561, Press = -0.323995120782156
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13838.877   -13838.877   -13999.516   -13999.516    310.76699    310.76699    47963.985    47963.985    106.35862    106.35862 
   35000   -13837.822   -13837.822   -13998.648   -13998.648     311.1293     311.1293    48022.583    48022.583   -1489.2188   -1489.2188 
Loop time of 430.996 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.721 hours/ns, 2.320 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    | 429.88     | 429.88     | 429.88     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16433    | 0.16433    | 0.16433    |   0.0 |  0.04
Output  | 0.00017871 | 0.00017871 | 0.00017871 |   0.0 |  0.00
Modify  | 0.84249    | 0.84249    | 0.84249    |   0.0 |  0.20
Other   |            | 0.108      |            |       |  0.03

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

Total # of neighbors = 529852
Ave neighs/atom = 132.46300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.334920164816, Press = -1.358077846915
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13837.822   -13837.822   -13998.648   -13998.648     311.1293     311.1293    48022.583    48022.583   -1489.2188   -1489.2188 
   36000   -13833.376   -13833.376   -13998.785   -13998.785    319.99617    319.99617    47923.236    47923.236    1459.4962    1459.4962 
Loop time of 430.812 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.670 hours/ns, 2.321 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    | 429.7      | 429.7      | 429.7      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16525    | 0.16525    | 0.16525    |   0.0 |  0.04
Output  | 0.00022887 | 0.00022887 | 0.00022887 |   0.0 |  0.00
Modify  | 0.83781    | 0.83781    | 0.83781    |   0.0 |  0.19
Other   |            | 0.1075     |            |       |  0.02

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

Total # of neighbors = 529292
Ave neighs/atom = 132.32300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.269144177854, Press = -2.94481506946008
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13833.376   -13833.376   -13998.785   -13998.785    319.99617    319.99617    47923.236    47923.236    1459.4962    1459.4962 
   37000    -13838.11    -13838.11   -13999.011   -13999.011    311.27411    311.27411    47943.568    47943.568    741.78553    741.78553 
Loop time of 433.012 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.281 hours/ns, 2.309 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    | 431.88     | 431.88     | 431.88     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16798    | 0.16798    | 0.16798    |   0.0 |  0.04
Output  | 0.0001796  | 0.0001796  | 0.0001796  |   0.0 |  0.00
Modify  | 0.85764    | 0.85764    | 0.85764    |   0.0 |  0.20
Other   |            | 0.1092     |            |       |  0.03

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

Total # of neighbors = 529970
Ave neighs/atom = 132.49250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.258092818365, Press = 0.869180459781062
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000    -13838.11    -13838.11   -13999.011   -13999.011    311.27411    311.27411    47943.568    47943.568    741.78553    741.78553 
   38000   -13837.779   -13837.779   -13999.868   -13999.868     313.5706     313.5706    48004.927    48004.927   -947.05505   -947.05505 
Loop time of 400.522 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.256 hours/ns, 2.497 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    | 399.51     | 399.51     | 399.51     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1552     | 0.1552     | 0.1552     |   0.0 |  0.04
Output  | 0.00017991 | 0.00017991 | 0.00017991 |   0.0 |  0.00
Modify  | 0.75441    | 0.75441    | 0.75441    |   0.0 |  0.19
Other   |            | 0.1025     |            |       |  0.03

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

Total # of neighbors = 529928
Ave neighs/atom = 132.48200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.270838529968, Press = -0.81011536097313
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13837.779   -13837.779   -13999.868   -13999.868     313.5706     313.5706    48004.927    48004.927   -947.05505   -947.05505 
   39000   -13836.012   -13836.012   -13996.829   -13996.829      311.111      311.111    47961.635    47961.635    428.98323    428.98323 
Loop time of 434.106 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.585 hours/ns, 2.304 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    | 432.99     | 432.99     | 432.99     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16469    | 0.16469    | 0.16469    |   0.0 |  0.04
Output  | 0.00023933 | 0.00023933 | 0.00023933 |   0.0 |  0.00
Modify  | 0.84081    | 0.84081    | 0.84081    |   0.0 |  0.19
Other   |            | 0.1089     |            |       |  0.03

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

Total # of neighbors = 529744
Ave neighs/atom = 132.43600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.259955841138, Press = -1.24806747684037
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13836.012   -13836.012   -13996.829   -13996.829      311.111      311.111    47961.635    47961.635    428.98323    428.98323 
   40000   -13835.421   -13835.421   -13997.163   -13997.163    312.90233    312.90233    47926.022    47926.022    1494.3565    1494.3565 
Loop time of 417.195 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 115.888 hours/ns, 2.397 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    | 416.14     | 416.14     | 416.14     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16022    | 0.16022    | 0.16022    |   0.0 |  0.04
Output  | 0.00023294 | 0.00023294 | 0.00023294 |   0.0 |  0.00
Modify  | 0.78865    | 0.78865    | 0.78865    |   0.0 |  0.19
Other   |            | 0.1053     |            |       |  0.03

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

Total # of neighbors = 529614
Ave neighs/atom = 132.40350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.256038908961, Press = 0.759721863036476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13835.421   -13835.421   -13997.163   -13997.163    312.90233    312.90233    47926.022    47926.022    1494.3565    1494.3565 
   41000   -13838.755   -13838.755   -13997.154   -13997.154    306.43265    306.43265    48077.968    48077.968   -2917.3591   -2917.3591 
Loop time of 385.478 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.077 hours/ns, 2.594 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    | 384.5      | 384.5      | 384.5      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15013    | 0.15013    | 0.15013    |   0.0 |  0.04
Output  | 0.00017849 | 0.00017849 | 0.00017849 |   0.0 |  0.00
Modify  | 0.72274    | 0.72274    | 0.72274    |   0.0 |  0.19
Other   |            | 0.1012     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      529910.0 ave      529910 max      529910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529910
Ave neighs/atom = 132.47750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.242513889107, Press = 0.281115753043358
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13838.755   -13838.755   -13997.154   -13997.154    306.43265    306.43265    48077.968    48077.968   -2917.3591   -2917.3591 
   42000   -13834.215   -13834.215   -13999.007   -13999.007    318.80092    318.80092    47982.767    47982.767   -256.74824   -256.74824 
Loop time of 366.153 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.709 hours/ns, 2.731 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    | 365.25     | 365.25     | 365.25     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14319    | 0.14319    | 0.14319    |   0.0 |  0.04
Output  | 0.00017921 | 0.00017921 | 0.00017921 |   0.0 |  0.00
Modify  | 0.66248    | 0.66248    | 0.66248    |   0.0 |  0.18
Other   |            | 0.09716    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      528908.0 ave      528908 max      528908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528908
Ave neighs/atom = 132.22700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.226211052379, Press = -1.6198156723507
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13834.215   -13834.215   -13999.007   -13999.007    318.80092    318.80092    47982.767    47982.767   -256.74824   -256.74824 
   43000   -13838.864   -13838.864   -13997.925   -13997.925    307.71506    307.71506    47922.322    47922.322    1404.5785    1404.5785 
Loop time of 404.699 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.416 hours/ns, 2.471 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    | 403.66     | 403.66     | 403.66     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1574     | 0.1574     | 0.1574     |   0.0 |  0.04
Output  | 0.00018011 | 0.00018011 | 0.00018011 |   0.0 |  0.00
Modify  | 0.77841    | 0.77841    | 0.77841    |   0.0 |  0.19
Other   |            | 0.1046     |            |       |  0.03

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0