# 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 4.525483399629593*${_u_distance}
variable latticeconst_converted equal 4.525483399629593*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.52548339962959
Lattice spacing in x,y,z = 4.5254834 4.5254834 4.5254834
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (45.254834 45.254834 45.254834)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (45.254834 45.254834 45.254834)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Ca

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

kim interactions Ca
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimJeonLee_2015_MgCa__MO_611309973581_002
pair_coeff * * Ca
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 40.078

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -6048.4674     -6048.4674     -6200          -6200           293.15         293.15         92681.9        92681.9        1746.3431      1746.3431    
      1000  -5897.3488     -5897.3488     -6050.19       -6050.19        295.68169      295.68169      95186.572      95186.572     -635.21884     -635.21884    
Loop time of 123.469 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.700 ns/day, 34.297 hours/ns, 8.099 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.16     | 123.16     | 123.16     |   0.0 | 99.75
Neigh   | 0.15832    | 0.15832    | 0.15832    |   0.0 |  0.13
Comm    | 0.024811   | 0.024811   | 0.024811   |   0.0 |  0.02
Output  | 0.00013135 | 0.00013135 | 0.00013135 |   0.0 |  0.00
Modify  | 0.11918    | 0.11918    | 0.11918    |   0.0 |  0.10
Other   |            | 0.01119    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6299 ave        6299 max        6299 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539220 ave      539220 max      539220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539220
Ave neighs/atom = 134.805
Neighbor list builds = 9
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -5897.3488     -5897.3488     -6050.19       -6050.19        295.68169      295.68169      95186.572      95186.572     -635.21884     -635.21884    
      2000  -5907.4836     -5907.4836     -6059.0938     -6059.0938      293.30026      293.30026      94791.376      94791.376      218.68779      218.68779    
Loop time of 127.126 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.680 ns/day, 35.313 hours/ns, 7.866 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.83     | 126.83     | 126.83     |   0.0 | 99.77
Neigh   | 0.14108    | 0.14108    | 0.14108    |   0.0 |  0.11
Comm    | 0.024711   | 0.024711   | 0.024711   |   0.0 |  0.02
Output  | 6.1165e-05 | 6.1165e-05 | 6.1165e-05 |   0.0 |  0.00
Modify  | 0.11877    | 0.11877    | 0.11877    |   0.0 |  0.09
Other   |            | 0.01067    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6354 ave        6354 max        6354 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540296 ave      540296 max      540296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540296
Ave neighs/atom = 135.074
Neighbor list builds = 8
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -5907.4836     -5907.4836     -6059.0938     -6059.0938      293.30026      293.30026      94791.376      94791.376      218.68779      218.68779    
      3000  -5895.1428     -5895.1428     -6051.2312     -6051.2312      301.96363      301.96363      95050.917      95050.917     -220.34957     -220.34957    
Loop time of 127.932 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.537 hours/ns, 7.817 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.64     | 127.64     | 127.64     |   0.0 | 99.77
Neigh   | 0.14225    | 0.14225    | 0.14225    |   0.0 |  0.11
Comm    | 0.024507   | 0.024507   | 0.024507   |   0.0 |  0.02
Output  | 6.2487e-05 | 6.2487e-05 | 6.2487e-05 |   0.0 |  0.00
Modify  | 0.1188     | 0.1188     | 0.1188     |   0.0 |  0.09
Other   |            | 0.01077    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6376 ave        6376 max        6376 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540156 ave      540156 max      540156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540156
Ave neighs/atom = 135.039
Neighbor list builds = 8
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -5895.1428     -5895.1428     -6051.2312     -6051.2312      301.96363      301.96363      95050.917      95050.917     -220.34957     -220.34957    
      4000  -5906.813      -5906.813      -6056.5295     -6056.5295      289.63667      289.63667      94851.005      94851.005      121.13191      121.13191    
Loop time of 127.366 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.678 ns/day, 35.379 hours/ns, 7.851 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.07     | 127.07     | 127.07     |   0.0 | 99.77
Neigh   | 0.14129    | 0.14129    | 0.14129    |   0.0 |  0.11
Comm    | 0.024605   | 0.024605   | 0.024605   |   0.0 |  0.02
Output  | 6.2638e-05 | 6.2638e-05 | 6.2638e-05 |   0.0 |  0.00
Modify  | 0.1187     | 0.1187     | 0.1187     |   0.0 |  0.09
Other   |            | 0.01072    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6292 ave        6292 max        6292 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540200 ave      540200 max      540200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540200
Ave neighs/atom = 135.05
Neighbor list builds = 8
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -5906.813      -5906.813      -6056.5295     -6056.5295      289.63667      289.63667      94851.005      94851.005      121.13191      121.13191    
      5000  -5898.2063     -5898.2063     -6051.1733     -6051.1733      295.92492      295.92492      95017.661      95017.661     -180.53271     -180.53271    
Loop time of 127.799 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.500 hours/ns, 7.825 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.5      | 127.5      | 127.5      |   0.0 | 99.77
Neigh   | 0.14182    | 0.14182    | 0.14182    |   0.0 |  0.11
Comm    | 0.024655   | 0.024655   | 0.024655   |   0.0 |  0.02
Output  | 4.9142e-05 | 4.9142e-05 | 4.9142e-05 |   0.0 |  0.00
Modify  | 0.11905    | 0.11905    | 0.11905    |   0.0 |  0.09
Other   |            | 0.01068    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6327 ave        6327 max        6327 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539692 ave      539692 max      539692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539692
Ave neighs/atom = 134.923
Neighbor list builds = 8
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 = 294.871383664368, Press = -106.897698149979
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -5898.2063     -5898.2063     -6051.1733     -6051.1733      295.92492      295.92492      95017.661      95017.661     -180.53271     -180.53271    
      6000  -5903.7538     -5903.7538     -6053.8504     -6053.8504      290.37198      290.37198      94853.372      94853.372      268.28317      268.28317    
Loop time of 127.212 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.679 ns/day, 35.337 hours/ns, 7.861 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.91     | 126.91     | 126.91     |   0.0 | 99.76
Neigh   | 0.14112    | 0.14112    | 0.14112    |   0.0 |  0.11
Comm    | 0.024558   | 0.024558   | 0.024558   |   0.0 |  0.02
Output  | 4.809e-05  | 4.809e-05  | 4.809e-05  |   0.0 |  0.00
Modify  | 0.1229     | 0.1229     | 0.1229     |   0.0 |  0.10
Other   |            | 0.0107     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6329 ave        6329 max        6329 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540218 ave      540218 max      540218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540218
Ave neighs/atom = 135.0545
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.45265660649, Press = -11.4958710936504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -5903.7538     -5903.7538     -6053.8504     -6053.8504      290.37198      290.37198      94853.372      94853.372      268.28317      268.28317    
      7000  -5897.9677     -5897.9677     -6050.2751     -6050.2751      294.64912      294.64912      95081.898      95081.898     -377.25468     -377.25468    
Loop time of 127.631 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.677 ns/day, 35.453 hours/ns, 7.835 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.33     | 127.33     | 127.33     |   0.0 | 99.76
Neigh   | 0.14207    | 0.14207    | 0.14207    |   0.0 |  0.11
Comm    | 0.024642   | 0.024642   | 0.024642   |   0.0 |  0.02
Output  | 5.1747e-05 | 5.1747e-05 | 5.1747e-05 |   0.0 |  0.00
Modify  | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.10
Other   |            | 0.01084    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6385 ave        6385 max        6385 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539916 ave      539916 max      539916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539916
Ave neighs/atom = 134.979
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.135446603003, Press = 3.69544045771025
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -5897.9677     -5897.9677     -6050.2751     -6050.2751      294.64912      294.64912      95081.898      95081.898     -377.25468     -377.25468    
      8000  -5901.2957     -5901.2957     -6052.9026     -6052.9026      293.29377      293.29377      94810.092      94810.092      391.53091      391.53091    
Loop time of 127.334 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.679 ns/day, 35.371 hours/ns, 7.853 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.02     | 127.02     | 127.02     |   0.0 | 99.75
Neigh   | 0.15918    | 0.15918    | 0.15918    |   0.0 |  0.13
Comm    | 0.02485    | 0.02485    | 0.02485    |   0.0 |  0.02
Output  | 4.804e-05  | 4.804e-05  | 4.804e-05  |   0.0 |  0.00
Modify  | 0.12311    | 0.12311    | 0.12311    |   0.0 |  0.10
Other   |            | 0.01074    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6294 ave        6294 max        6294 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540326 ave      540326 max      540326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540326
Ave neighs/atom = 135.0815
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.232037911008, Press = -12.3640088291346
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -5901.2957     -5901.2957     -6052.9026     -6052.9026      293.29377      293.29377      94810.092      94810.092      391.53091      391.53091    
      9000  -5900.5101     -5900.5101     -6052.0488     -6052.0488      293.16188      293.16188      95044.007      95044.007     -233.49945     -233.49945    
Loop time of 127.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.483 hours/ns, 7.829 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.4      | 127.4      | 127.4      |   0.0 | 99.74
Neigh   | 0.17758    | 0.17758    | 0.17758    |   0.0 |  0.14
Comm    | 0.024986   | 0.024986   | 0.024986   |   0.0 |  0.02
Output  | 5.5484e-05 | 5.5484e-05 | 5.5484e-05 |   0.0 |  0.00
Modify  | 0.12301    | 0.12301    | 0.12301    |   0.0 |  0.10
Other   |            | 0.01068    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6354 ave        6354 max        6354 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540008 ave      540008 max      540008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540008
Ave neighs/atom = 135.002
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.093145162172, Press = 5.86038604408628
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -5900.5101     -5900.5101     -6052.0488     -6052.0488      293.16188      293.16188      95044.007      95044.007     -233.49945     -233.49945    
     10000  -5902.2069     -5902.2069     -6053.0375     -6053.0375      291.79206      291.79206      94884.238      94884.238      188.22931      188.22931    
Loop time of 127.76 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.489 hours/ns, 7.827 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.44     | 127.44     | 127.44     |   0.0 | 99.75
Neigh   | 0.16006    | 0.16006    | 0.16006    |   0.0 |  0.13
Comm    | 0.024681   | 0.024681   | 0.024681   |   0.0 |  0.02
Output  | 4.7209e-05 | 4.7209e-05 | 4.7209e-05 |   0.0 |  0.00
Modify  | 0.12301    | 0.12301    | 0.12301    |   0.0 |  0.10
Other   |            | 0.01074    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6394 ave        6394 max        6394 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540054 ave      540054 max      540054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540054
Ave neighs/atom = 135.0135
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.427101261804, Press = -3.81936800774035
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -5902.2069     -5902.2069     -6053.0375     -6053.0375      291.79206      291.79206      94884.238      94884.238      188.22931      188.22931    
     11000  -5899.6776     -5899.6776     -6052.1075     -6052.1075      294.88593      294.88593      95008.921      95008.921     -163.15544     -163.15544    
Loop time of 127.443 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.678 ns/day, 35.401 hours/ns, 7.847 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.14     | 127.14     | 127.14     |   0.0 | 99.77
Neigh   | 0.14107    | 0.14107    | 0.14107    |   0.0 |  0.11
Comm    | 0.024646   | 0.024646   | 0.024646   |   0.0 |  0.02
Output  | 4.8871e-05 | 4.8871e-05 | 4.8871e-05 |   0.0 |  0.00
Modify  | 0.12281    | 0.12281    | 0.12281    |   0.0 |  0.10
Other   |            | 0.01071    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6351 ave        6351 max        6351 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540212 ave      540212 max      540212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540212
Ave neighs/atom = 135.053
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.528367119517, Press = 0.574879416307854
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -5899.6776     -5899.6776     -6052.1075     -6052.1075      294.88593      294.88593      95008.921      95008.921     -163.15544     -163.15544    
     12000  -5901.8959     -5901.8959     -6051.9585     -6051.9585      290.3064       290.3064       94945.163      94945.163      45.087679      45.087679    
Loop time of 127.534 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.677 ns/day, 35.426 hours/ns, 7.841 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.23     | 127.23     | 127.23     |   0.0 | 99.76
Neigh   | 0.14213    | 0.14213    | 0.14213    |   0.0 |  0.11
Comm    | 0.024607   | 0.024607   | 0.024607   |   0.0 |  0.02
Output  | 4.7719e-05 | 4.7719e-05 | 4.7719e-05 |   0.0 |  0.00
Modify  | 0.12273    | 0.12273    | 0.12273    |   0.0 |  0.10
Other   |            | 0.01079    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6290 ave        6290 max        6290 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540298 ave      540298 max      540298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540298
Ave neighs/atom = 135.0745
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.692403638849, Press = -2.17802850464435
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -5901.8959     -5901.8959     -6051.9585     -6051.9585      290.3064       290.3064       94945.163      94945.163      45.087679      45.087679    
     13000  -5900.5679     -5900.5679     -6050.5975     -6050.5975      290.2423       290.2423       94953.705      94953.705      53.724842      53.724842    
Loop time of 127.483 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.678 ns/day, 35.412 hours/ns, 7.844 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.18     | 127.18     | 127.18     |   0.0 | 99.76
Neigh   | 0.14168    | 0.14168    | 0.14168    |   0.0 |  0.11
Comm    | 0.024527   | 0.024527   | 0.024527   |   0.0 |  0.02
Output  | 4.9282e-05 | 4.9282e-05 | 4.9282e-05 |   0.0 |  0.00
Modify  | 0.12272    | 0.12272    | 0.12272    |   0.0 |  0.10
Other   |            | 0.01069    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6442 ave        6442 max        6442 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540456 ave      540456 max      540456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540456
Ave neighs/atom = 135.114
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.696492582616, Press = 0.51056532981705
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -5900.5679     -5900.5679     -6050.5975     -6050.5975      290.2423       290.2423       94953.705      94953.705      53.724842      53.724842    
     14000  -5897.6858     -5897.6858     -6050.7463     -6050.7463      296.10592      296.10592      95045.655      95045.655     -230.8134      -230.8134     
Loop time of 127.761 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.489 hours/ns, 7.827 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.46     | 127.46     | 127.46     |   0.0 | 99.76
Neigh   | 0.14231    | 0.14231    | 0.14231    |   0.0 |  0.11
Comm    | 0.024506   | 0.024506   | 0.024506   |   0.0 |  0.02
Output  | 0.00010723 | 0.00010723 | 0.00010723 |   0.0 |  0.00
Modify  | 0.12273    | 0.12273    | 0.12273    |   0.0 |  0.10
Other   |            | 0.01072    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6308 ave        6308 max        6308 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540162 ave      540162 max      540162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540162
Ave neighs/atom = 135.0405
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.52376023201, Press = -2.68843833369749
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -5897.6858     -5897.6858     -6050.7463     -6050.7463      296.10592      296.10592      95045.655      95045.655     -230.8134      -230.8134     
     15000  -5901.8878     -5901.8878     -6055.7712     -6055.7712      297.69778      297.69778      94884.385      94884.385      172.60376      172.60376    
Loop time of 127.521 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.678 ns/day, 35.422 hours/ns, 7.842 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.22     | 127.22     | 127.22     |   0.0 | 99.76
Neigh   | 0.14132    | 0.14132    | 0.14132    |   0.0 |  0.11
Comm    | 0.024664   | 0.024664   | 0.024664   |   0.0 |  0.02
Output  | 4.7429e-05 | 4.7429e-05 | 4.7429e-05 |   0.0 |  0.00
Modify  | 0.12277    | 0.12277    | 0.12277    |   0.0 |  0.10
Other   |            | 0.01088    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6323 ave        6323 max        6323 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540442 ave      540442 max      540442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540442
Ave neighs/atom = 135.1105
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.605576954307, Press = 1.38725500927919
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -5901.8878     -5901.8878     -6055.7712     -6055.7712      297.69778      297.69778      94884.385      94884.385      172.60376      172.60376    
     16000  -5897.5102     -5897.5102     -6052.5206     -6052.5206      299.87812      299.87812      95097.239      95097.239     -377.7503      -377.7503     
Loop time of 127.697 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.677 ns/day, 35.471 hours/ns, 7.831 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.4      | 127.4      | 127.4      |   0.0 | 99.76
Neigh   | 0.14217    | 0.14217    | 0.14217    |   0.0 |  0.11
Comm    | 0.024654   | 0.024654   | 0.024654   |   0.0 |  0.02
Output  | 4.7018e-05 | 4.7018e-05 | 4.7018e-05 |   0.0 |  0.00
Modify  | 0.1227     | 0.1227     | 0.1227     |   0.0 |  0.10
Other   |            | 0.01083    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6378 ave        6378 max        6378 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540000 ave      540000 max      540000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540000
Ave neighs/atom = 135
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.544103216894, Press = -2.89399093690054
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -5897.5102     -5897.5102     -6052.5206     -6052.5206      299.87812      299.87812      95097.239      95097.239     -377.7503      -377.7503     
     17000  -5902.409      -5902.409      -6052.8772     -6052.8772      291.09089      291.09089      94901.331      94901.331      112.98331      112.98331    
Loop time of 127.549 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.677 ns/day, 35.430 hours/ns, 7.840 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.25     | 127.25     | 127.25     |   0.0 | 99.77
Neigh   | 0.14182    | 0.14182    | 0.14182    |   0.0 |  0.11
Comm    | 0.024502   | 0.024502   | 0.024502   |   0.0 |  0.02
Output  | 4.8821e-05 | 4.8821e-05 | 4.8821e-05 |   0.0 |  0.00
Modify  | 0.1225     | 0.1225     | 0.1225     |   0.0 |  0.10
Other   |            | 0.01071    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6264 ave        6264 max        6264 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540104 ave      540104 max      540104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540104
Ave neighs/atom = 135.026
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.621990545528, Press = 0.205943772237698
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -5902.409      -5902.409      -6052.8772     -6052.8772      291.09089      291.09089      94901.331      94901.331      112.98331      112.98331    
     18000  -5900.4292     -5900.4292     -6054.5495     -6054.5495      298.1563       298.1563       95003.893      95003.893     -184.62982     -184.62982    
Loop time of 127.78 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.495 hours/ns, 7.826 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    | 127.48     | 127.48     | 127.48     |   0.0 | 99.77
Neigh   | 0.14219    | 0.14219    | 0.14219    |   0.0 |  0.11
Comm    | 0.024379   | 0.024379   | 0.024379   |   0.0 |  0.02
Output  | 4.6938e-05 | 4.6938e-05 | 4.6938e-05 |   0.0 |  0.00
Modify  | 0.12189    | 0.12189    | 0.12189    |   0.0 |  0.10
Other   |            | 0.01082    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6263 ave        6263 max        6263 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540038 ave      540038 max      540038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540038
Ave neighs/atom = 135.0095
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.609145732516, Press = -1.13859051136322
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -5900.4292     -5900.4292     -6054.5495     -6054.5495      298.1563       298.1563       95003.893      95003.893     -184.62982     -184.62982    
     19000  -5900.6448     -5900.6448     -6051.5184     -6051.5184      291.87511      291.87511      94873.357      94873.357      240.15338      240.15338    
Loop time of 127.638 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.677 ns/day, 35.455 hours/ns, 7.835 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    | 127.34     | 127.34     | 127.34     |   0.0 | 99.77
Neigh   | 0.14192    | 0.14192    | 0.14192    |   0.0 |  0.11
Comm    | 0.024585   | 0.024585   | 0.024585   |   0.0 |  0.02
Output  | 4.803e-05  | 4.803e-05  | 4.803e-05  |   0.0 |  0.00
Modify  | 0.12194    | 0.12194    | 0.12194    |   0.0 |  0.10
Other   |            | 0.01071    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6330 ave        6330 max        6330 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539826 ave      539826 max      539826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539826
Ave neighs/atom = 134.9565
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.768660495188, Press = -0.853841052455696
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -5900.6448     -5900.6448     -6051.5184     -6051.5184      291.87511      291.87511      94873.357      94873.357      240.15338      240.15338    
     20000  -5900.026      -5900.026      -6050.2623     -6050.2623      290.64237      290.64237      95107.702      95107.702     -398.82619     -398.82619    
Loop time of 127.904 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.529 hours/ns, 7.818 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    | 127.6      | 127.6      | 127.6      |   0.0 | 99.77
Neigh   | 0.14202    | 0.14202    | 0.14202    |   0.0 |  0.11
Comm    | 0.024555   | 0.024555   | 0.024555   |   0.0 |  0.02
Output  | 4.8531e-05 | 4.8531e-05 | 4.8531e-05 |   0.0 |  0.00
Modify  | 0.12206    | 0.12206    | 0.12206    |   0.0 |  0.10
Other   |            | 0.01076    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6371 ave        6371 max        6371 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540168 ave      540168 max      540168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540168
Ave neighs/atom = 135.042
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.663728692844, Press = -0.396596630586596
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -5900.026      -5900.026      -6050.2623     -6050.2623      290.64237      290.64237      95107.702      95107.702     -398.82619     -398.82619    
     21000  -5906.3192     -5906.3192     -6055.4272     -6055.4272      288.45955      288.45955      94594.022      94594.022      914.83076      914.83076    
Loop time of 127.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.485 hours/ns, 7.828 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    | 127.44     | 127.44     | 127.44     |   0.0 | 99.77
Neigh   | 0.14236    | 0.14236    | 0.14236    |   0.0 |  0.11
Comm    | 0.024548   | 0.024548   | 0.024548   |   0.0 |  0.02
Output  | 4.793e-05  | 4.793e-05  | 4.793e-05  |   0.0 |  0.00
Modify  | 0.12213    | 0.12213    | 0.12213    |   0.0 |  0.10
Other   |            | 0.0108     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6398 ave        6398 max        6398 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540264 ave      540264 max      540264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540264
Ave neighs/atom = 135.066
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.556160712212, Press = -0.343315742985754
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -5906.3192     -5906.3192     -6055.4272     -6055.4272      288.45955      288.45955      94594.022      94594.022      914.83076      914.83076    
     22000  -5900.9092     -5900.9092     -6052.9934     -6052.9934      294.21725      294.21725      95118.855      95118.855     -505.38011     -505.38011    
Loop time of 127.911 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.531 hours/ns, 7.818 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    | 127.61     | 127.61     | 127.61     |   0.0 | 99.77
Neigh   | 0.14215    | 0.14215    | 0.14215    |   0.0 |  0.11
Comm    | 0.02457    | 0.02457    | 0.02457    |   0.0 |  0.02
Output  | 4.7158e-05 | 4.7158e-05 | 4.7158e-05 |   0.0 |  0.00
Modify  | 0.12224    | 0.12224    | 0.12224    |   0.0 |  0.10
Other   |            | 0.01085    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6324 ave        6324 max        6324 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540022 ave      540022 max      540022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540022
Ave neighs/atom = 135.0055
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.46833074835, Press = -0.222290749352096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -5900.9092     -5900.9092     -6052.9934     -6052.9934      294.21725      294.21725      95118.855      95118.855     -505.38011     -505.38011    
     23000  -5899.0156     -5899.0156     -6050.0183     -6050.0183      292.12487      292.12487      94867.256      94867.256      303.79718      303.79718    
Loop time of 127.884 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.523 hours/ns, 7.820 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    | 127.58     | 127.58     | 127.58     |   0.0 | 99.77
Neigh   | 0.14257    | 0.14257    | 0.14257    |   0.0 |  0.11
Comm    | 0.024542   | 0.024542   | 0.024542   |   0.0 |  0.02
Output  | 4.5856e-05 | 4.5856e-05 | 4.5856e-05 |   0.0 |  0.00
Modify  | 0.12217    | 0.12217    | 0.12217    |   0.0 |  0.10
Other   |            | 0.01082    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6340 ave        6340 max        6340 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539806 ave      539806 max      539806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539806
Ave neighs/atom = 134.9515
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.463861059748, Press = -0.734579218747035
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -5899.0156     -5899.0156     -6050.0183     -6050.0183      292.12487      292.12487      94867.256      94867.256      303.79718      303.79718    
     24000  -5899.7994     -5899.7994     -6051.9369     -6051.9369      294.32027      294.32027      94972.096      94972.096     -43.499267     -43.499267    
Loop time of 127.888 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.524 hours/ns, 7.819 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    | 127.59     | 127.59     | 127.59     |   0.0 | 99.77
Neigh   | 0.14226    | 0.14226    | 0.14226    |   0.0 |  0.11
Comm    | 0.024598   | 0.024598   | 0.024598   |   0.0 |  0.02
Output  | 4.7619e-05 | 4.7619e-05 | 4.7619e-05 |   0.0 |  0.00
Modify  | 0.12225    | 0.12225    | 0.12225    |   0.0 |  0.10
Other   |            | 0.01077    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6359 ave        6359 max        6359 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540150 ave      540150 max      540150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540150
Ave neighs/atom = 135.0375
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.444434751682, Press = 0.0674470894948473
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -5899.7994     -5899.7994     -6051.9369     -6051.9369      294.32027      294.32027      94972.096      94972.096     -43.499267     -43.499267    
     25000  -5905.5174     -5905.5174     -6055.5345     -6055.5345      290.21822      290.21822      94875.144      94875.144      77.164565      77.164565    
Loop time of 127.828 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.508 hours/ns, 7.823 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.53     | 127.53     | 127.53     |   0.0 | 99.77
Neigh   | 0.14188    | 0.14188    | 0.14188    |   0.0 |  0.11
Comm    | 0.024663   | 0.024663   | 0.024663   |   0.0 |  0.02
Output  | 4.6658e-05 | 4.6658e-05 | 4.6658e-05 |   0.0 |  0.00
Modify  | 0.12212    | 0.12212    | 0.12212    |   0.0 |  0.10
Other   |            | 0.01095    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6363 ave        6363 max        6363 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540528 ave      540528 max      540528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540528
Ave neighs/atom = 135.132
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.467114011479, Press = -0.6945671259529
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -5905.5174     -5905.5174     -6055.5345     -6055.5345      290.21822      290.21822      94875.144      94875.144      77.164565      77.164565    
     26000  -5900.7315     -5900.7315     -6053.6823     -6053.6823      295.89375      295.89375      94912.757      94912.757      64.71231       64.71231     
Loop time of 127.859 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.516 hours/ns, 7.821 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    | 127.56     | 127.56     | 127.56     |   0.0 | 99.77
Neigh   | 0.1419     | 0.1419     | 0.1419     |   0.0 |  0.11
Comm    | 0.02466    | 0.02466    | 0.02466    |   0.0 |  0.02
Output  | 4.798e-05  | 4.798e-05  | 4.798e-05  |   0.0 |  0.00
Modify  | 0.12211    | 0.12211    | 0.12211    |   0.0 |  0.10
Other   |            | 0.01088    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6383 ave        6383 max        6383 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540328 ave      540328 max      540328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540328
Ave neighs/atom = 135.082
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.391559036077, Press = 0.661501508290216
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -5900.7315     -5900.7315     -6053.6823     -6053.6823      295.89375      295.89375      94912.757      94912.757      64.71231       64.71231     
     27000  -5900.8491     -5900.8491     -6053.9648     -6053.9648      296.21272      296.21272      95048.267      95048.267     -314.34051     -314.34051    
Loop time of 127.784 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.496 hours/ns, 7.826 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    | 127.47     | 127.47     | 127.47     |   0.0 | 99.75
Neigh   | 0.15995    | 0.15995    | 0.15995    |   0.0 |  0.13
Comm    | 0.024699   | 0.024699   | 0.024699   |   0.0 |  0.02
Output  | 4.7098e-05 | 4.7098e-05 | 4.7098e-05 |   0.0 |  0.00
Modify  | 0.12206    | 0.12206    | 0.12206    |   0.0 |  0.10
Other   |            | 0.01066    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6328 ave        6328 max        6328 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539522 ave      539522 max      539522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539522
Ave neighs/atom = 134.8805
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.404785146447, Press = -1.673735263106
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -5900.8491     -5900.8491     -6053.9648     -6053.9648      296.21272      296.21272      95048.267      95048.267     -314.34051     -314.34051    
     28000  -5899.2068     -5899.2068     -6053.7703     -6053.7703      299.01367      299.01367      94843.339      94843.339      309.10043      309.10043    
Loop time of 127.894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.526 hours/ns, 7.819 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    | 127.58     | 127.58     | 127.58     |   0.0 | 99.75
Neigh   | 0.15959    | 0.15959    | 0.15959    |   0.0 |  0.12
Comm    | 0.024715   | 0.024715   | 0.024715   |   0.0 |  0.02
Output  | 4.795e-05  | 4.795e-05  | 4.795e-05  |   0.0 |  0.00
Modify  | 0.1222     | 0.1222     | 0.1222     |   0.0 |  0.10
Other   |            | 0.01074    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6378 ave        6378 max        6378 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540306 ave      540306 max      540306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540306
Ave neighs/atom = 135.0765
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.428132869167, Press = 0.431865393791711
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -5899.2068     -5899.2068     -6053.7703     -6053.7703      299.01367      299.01367      94843.339      94843.339      309.10043      309.10043    
     29000  -5902.7542     -5902.7542     -6054.3209     -6054.3209      293.21602      293.21602      94988.579      94988.579     -163.54587     -163.54587    
Loop time of 128.072 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.576 hours/ns, 7.808 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.77     | 127.77     | 127.77     |   0.0 | 99.77
Neigh   | 0.14178    | 0.14178    | 0.14178    |   0.0 |  0.11
Comm    | 0.024747   | 0.024747   | 0.024747   |   0.0 |  0.02
Output  | 4.8311e-05 | 4.8311e-05 | 4.8311e-05 |   0.0 |  0.00
Modify  | 0.12231    | 0.12231    | 0.12231    |   0.0 |  0.10
Other   |            | 0.01074    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6366 ave        6366 max        6366 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539852 ave      539852 max      539852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539852
Ave neighs/atom = 134.963
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.365539691679, Press = -0.924741961946447
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -5902.7542     -5902.7542     -6054.3209     -6054.3209      293.21602      293.21602      94988.579      94988.579     -163.54587     -163.54587    
     30000  -5900.3018     -5900.3018     -6052.3673     -6052.3673      294.18105      294.18105      94894.187      94894.187      137.08181      137.08181    
Loop time of 128.166 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.602 hours/ns, 7.802 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.87     | 127.87     | 127.87     |   0.0 | 99.77
Neigh   | 0.14206    | 0.14206    | 0.14206    |   0.0 |  0.11
Comm    | 0.024733   | 0.024733   | 0.024733   |   0.0 |  0.02
Output  | 4.1277e-05 | 4.1277e-05 | 4.1277e-05 |   0.0 |  0.00
Modify  | 0.1223     | 0.1223     | 0.1223     |   0.0 |  0.10
Other   |            | 0.01079    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6438 ave        6438 max        6438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540158 ave      540158 max      540158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540158
Ave neighs/atom = 135.0395
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.354524953918, Press = 0.197290152559692
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -5900.3018     -5900.3018     -6052.3673     -6052.3673      294.18105      294.18105      94894.187      94894.187      137.08181      137.08181    
     31000  -5906.9172     -5906.9172     -6055.555      -6055.555       287.54977      287.54977      94950.658      94950.658     -132.98272     -132.98272    
Loop time of 127.849 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.513 hours/ns, 7.822 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.53     | 127.53     | 127.53     |   0.0 | 99.75
Neigh   | 0.15939    | 0.15939    | 0.15939    |   0.0 |  0.12
Comm    | 0.024783   | 0.024783   | 0.024783   |   0.0 |  0.02
Output  | 4.4844e-05 | 4.4844e-05 | 4.4844e-05 |   0.0 |  0.00
Modify  | 0.12227    | 0.12227    | 0.12227    |   0.0 |  0.10
Other   |            | 0.01069    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6378 ave        6378 max        6378 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539890 ave      539890 max      539890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539890
Ave neighs/atom = 134.9725
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.277449783179, Press = -0.909094368730325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -5906.9172     -5906.9172     -6055.555      -6055.555       287.54977      287.54977      94950.658      94950.658     -132.98272     -132.98272    
     32000  -5903.9689     -5903.9689     -6054.2076     -6054.2076      290.64712      290.64712      94786.326      94786.326      401.14289      401.14289    
Loop time of 127.966 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.546 hours/ns, 7.815 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.67     | 127.67     | 127.67     |   0.0 | 99.77
Neigh   | 0.14231    | 0.14231    | 0.14231    |   0.0 |  0.11
Comm    | 0.02471    | 0.02471    | 0.02471    |   0.0 |  0.02
Output  | 4.7038e-05 | 4.7038e-05 | 4.7038e-05 |   0.0 |  0.00
Modify  | 0.12225    | 0.12225    | 0.12225    |   0.0 |  0.10
Other   |            | 0.01076    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6313 ave        6313 max        6313 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540236 ave      540236 max      540236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540236
Ave neighs/atom = 135.059
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.267858961154, Press = 0.569906239752557
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -5903.9689     -5903.9689     -6054.2076     -6054.2076      290.64712      290.64712      94786.326      94786.326      401.14289      401.14289    
     33000  -5900.7298     -5900.7298     -6053.7914     -6053.7914      296.10819      296.10819      95098.659      95098.659     -439.76295     -439.76295    
Loop time of 127.964 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.546 hours/ns, 7.815 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.65     | 127.65     | 127.65     |   0.0 | 99.75
Neigh   | 0.15966    | 0.15966    | 0.15966    |   0.0 |  0.12
Comm    | 0.024665   | 0.024665   | 0.024665   |   0.0 |  0.02
Output  | 4.6568e-05 | 4.6568e-05 | 4.6568e-05 |   0.0 |  0.00
Modify  | 0.12236    | 0.12236    | 0.12236    |   0.0 |  0.10
Other   |            | 0.01072    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6311 ave        6311 max        6311 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539474 ave      539474 max      539474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539474
Ave neighs/atom = 134.8685
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.244631016706, Press = -1.20299216893297
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -5900.7298     -5900.7298     -6053.7914     -6053.7914      296.10819      296.10819      95098.659      95098.659     -439.76295     -439.76295    
     34000  -5904.2153     -5904.2153     -6056.0024     -6056.0024      293.64244      293.64244      94836.355      94836.355      189.69934      189.69934    
Loop time of 128.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.574 hours/ns, 7.808 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.75     | 127.75     | 127.75     |   0.0 | 99.75
Neigh   | 0.1594     | 0.1594     | 0.1594     |   0.0 |  0.12
Comm    | 0.024766   | 0.024766   | 0.024766   |   0.0 |  0.02
Output  | 4.7429e-05 | 4.7429e-05 | 4.7429e-05 |   0.0 |  0.00
Modify  | 0.12211    | 0.12211    | 0.12211    |   0.0 |  0.10
Other   |            | 0.01069    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6358 ave        6358 max        6358 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540378 ave      540378 max      540378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540378
Ave neighs/atom = 135.0945
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.247866591719, Press = 0.258298975447679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -5904.2153     -5904.2153     -6056.0024     -6056.0024      293.64244      293.64244      94836.355      94836.355      189.69934      189.69934    
     35000  -5901.0878     -5901.0878     -6052.6947     -6052.6947      293.29379      293.29379      94988.429      94988.429     -99.96845      -99.96845     
Loop time of 127.731 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.481 hours/ns, 7.829 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.41     | 127.41     | 127.41     |   0.0 | 99.75
Neigh   | 0.15905    | 0.15905    | 0.15905    |   0.0 |  0.12
Comm    | 0.024767   | 0.024767   | 0.024767   |   0.0 |  0.02
Output  | 5.1727e-05 | 5.1727e-05 | 5.1727e-05 |   0.0 |  0.00
Modify  | 0.12215    | 0.12215    | 0.12215    |   0.0 |  0.10
Other   |            | 0.01076    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6376 ave        6376 max        6376 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539856 ave      539856 max      539856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539856
Ave neighs/atom = 134.964
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.233090709012, Press = -0.794564858402977
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.376 | 5.376 | 5.376 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -5901.0878     -5901.0878     -6052.6947     -6052.6947      293.29379      293.29379      94988.429      94988.429     -99.96845      -99.96845     
     36000  -5901.296      -5901.296      -6053.0823     -6053.0823      293.641        293.641        94927.654      94927.654      31.630283      31.630283    
Loop time of 128.06 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.572 hours/ns, 7.809 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.76     | 127.76     | 127.76     |   0.0 | 99.77
Neigh   | 0.14173    | 0.14173    | 0.14173    |   0.0 |  0.11
Comm    | 0.02466    | 0.02466    | 0.02466    |   0.0 |  0.02
Output  | 5.1557e-05 | 5.1557e-05 | 5.1557e-05 |   0.0 |  0.00
Modify  | 0.12241    | 0.12241    | 0.12241    |   0.0 |  0.10
Other   |            | 0.01076    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6349 ave        6349 max        6349 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540370 ave      540370 max      540370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0