# 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 333.15*${_u_temperature}
variable temp_converted equal 333.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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  -6027.791      -6027.791      -6200          -6200           333.15         333.15         92681.9        92681.9        1984.63        1984.63      
      1000  -5854.9758     -5854.9758     -6029.5066     -6029.5066      337.64162      337.64162      95308.013      95308.013     -77.642017     -77.642017    
Loop time of 124.448 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.694 ns/day, 34.569 hours/ns, 8.036 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    | 124.11     | 124.11     | 124.11     |   0.0 | 99.73
Neigh   | 0.17689    | 0.17689    | 0.17689    |   0.0 |  0.14
Comm    | 0.026414   | 0.026414   | 0.026414   |   0.0 |  0.02
Output  | 0.00022338 | 0.00022338 | 0.00022338 |   0.0 |  0.00
Modify  | 0.12134    | 0.12134    | 0.12134    |   0.0 |  0.10
Other   |            | 0.01157    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6341 ave        6341 max        6341 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:       537890 ave      537890 max      537890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 537890
Ave neighs/atom = 134.4725
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 = 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   
      1000  -5854.9758     -5854.9758     -6029.5066     -6029.5066      337.64162      337.64162      95308.013      95308.013     -77.642017     -77.642017    
      2000  -5868.1266     -5868.1266     -6040.3468     -6040.3468      333.17167      333.17167      95242.587      95242.587     -236.08983     -236.08983    
Loop time of 127.661 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.677 ns/day, 35.461 hours/ns, 7.833 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.35     | 127.35     | 127.35     |   0.0 | 99.75
Neigh   | 0.15908    | 0.15908    | 0.15908    |   0.0 |  0.12
Comm    | 0.025955   | 0.025955   | 0.025955   |   0.0 |  0.02
Output  | 0.00011818 | 0.00011818 | 0.00011818 |   0.0 |  0.00
Modify  | 0.12019    | 0.12019    | 0.12019    |   0.0 |  0.09
Other   |            | 0.01063    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6399 ave        6399 max        6399 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:       538958 ave      538958 max      538958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538958
Ave neighs/atom = 134.7395
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.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  -5868.1266     -5868.1266     -6040.3468     -6040.3468      333.17167      333.17167      95242.587      95242.587     -236.08983     -236.08983    
      3000  -5853.2663     -5853.2663     -6031.1947     -6031.1947      344.21438      344.21438      95312.173      95312.173     -80.880822     -80.880822    
Loop time of 128.285 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.635 hours/ns, 7.795 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.97     | 127.97     | 127.97     |   0.0 | 99.75
Neigh   | 0.16015    | 0.16015    | 0.16015    |   0.0 |  0.12
Comm    | 0.025833   | 0.025833   | 0.025833   |   0.0 |  0.02
Output  | 9.1933e-05 | 9.1933e-05 | 9.1933e-05 |   0.0 |  0.00
Modify  | 0.11973    | 0.11973    | 0.11973    |   0.0 |  0.09
Other   |            | 0.01071    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6357 ave        6357 max        6357 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:       538362 ave      538362 max      538362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538362
Ave neighs/atom = 134.5905
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.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  -5853.2663     -5853.2663     -6031.1947     -6031.1947      344.21438      344.21438      95312.173      95312.173     -80.880822     -80.880822    
      4000  -5866.2262     -5866.2262     -6037.4671     -6037.4671      331.27731      331.27731      95134.492      95134.492      174.37619      174.37619    
Loop time of 127.866 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.518 hours/ns, 7.821 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.51     | 127.51     | 127.51     |   0.0 | 99.72
Neigh   | 0.18571    | 0.18571    | 0.18571    |   0.0 |  0.15
Comm    | 0.029731   | 0.029731   | 0.029731   |   0.0 |  0.02
Output  | 9.5098e-05 | 9.5098e-05 | 9.5098e-05 |   0.0 |  0.00
Modify  | 0.1246     | 0.1246     | 0.1246     |   0.0 |  0.10
Other   |            | 0.01214    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6302 ave        6302 max        6302 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:       538712 ave      538712 max      538712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538712
Ave neighs/atom = 134.678
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 = 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  -5866.2262     -5866.2262     -6037.4671     -6037.4671      331.27731      331.27731      95134.492      95134.492      174.37619      174.37619    
      5000  -5856.7757     -5856.7757     -6030.4207     -6030.4207      335.92808      335.92808      95375.408      95375.408     -294.38108     -294.38108    
Loop time of 127.965 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.64     | 127.64     | 127.64     |   0.0 | 99.75
Neigh   | 0.16342    | 0.16342    | 0.16342    |   0.0 |  0.13
Comm    | 0.027439   | 0.027439   | 0.027439   |   0.0 |  0.02
Output  | 7.999e-05  | 7.999e-05  | 7.999e-05  |   0.0 |  0.00
Modify  | 0.12275    | 0.12275    | 0.12275    |   0.0 |  0.10
Other   |            | 0.01146    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6353 ave        6353 max        6353 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:       538440 ave      538440 max      538440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538440
Ave neighs/atom = 134.61
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 = 335.661810914043, Press = 0.74392748351778
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  -5856.7757     -5856.7757     -6030.4207     -6030.4207      335.92808      335.92808      95375.408      95375.408     -294.38108     -294.38108    
      6000  -5865.2843     -5865.2843     -6032.6736     -6032.6736      323.8258       323.8258       95365.194      95365.194     -321.59229     -321.59229    
Loop time of 127.762 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.490 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.42     | 127.42     | 127.42     |   0.0 | 99.73
Neigh   | 0.16834    | 0.16834    | 0.16834    |   0.0 |  0.13
Comm    | 0.030679   | 0.030679   | 0.030679   |   0.0 |  0.02
Output  | 6.6445e-05 | 6.6445e-05 | 6.6445e-05 |   0.0 |  0.00
Modify  | 0.13131    | 0.13131    | 0.13131    |   0.0 |  0.10
Other   |            | 0.01264    |            |       |  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:       538034 ave      538034 max      538034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538034
Ave neighs/atom = 134.5085
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 = 333.371431889728, Press = -31.7634563740709
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  -5865.2843     -5865.2843     -6032.6736     -6032.6736      323.8258       323.8258       95365.194      95365.194     -321.59229     -321.59229    
      7000  -5856.4978     -5856.4978     -6029.6123     -6029.6123      334.90173      334.90173      95036.355      95036.355      699.57229      699.57229    
Loop time of 128.058 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.71     | 127.71     | 127.71     |   0.0 | 99.73
Neigh   | 0.18286    | 0.18286    | 0.18286    |   0.0 |  0.14
Comm    | 0.027867   | 0.027867   | 0.027867   |   0.0 |  0.02
Output  | 7.9128e-05 | 7.9128e-05 | 7.9128e-05 |   0.0 |  0.00
Modify  | 0.12866    | 0.12866    | 0.12866    |   0.0 |  0.10
Other   |            | 0.01177    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6319 ave        6319 max        6319 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:       537812 ave      537812 max      537812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 537812
Ave neighs/atom = 134.453
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 = 333.268791491773, Press = -13.4011142431117
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  -5856.4978     -5856.4978     -6029.6123     -6029.6123      334.90173      334.90173      95036.355      95036.355      699.57229      699.57229    
      8000  -5861.3675     -5861.3675     -6033.0816     -6033.0816      332.19267      332.19267      95147.66       95147.66       303.88215      303.88215    
Loop time of 127.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.539 hours/ns, 7.816 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.62     | 127.62     | 127.62     |   0.0 | 99.75
Neigh   | 0.16158    | 0.16158    | 0.16158    |   0.0 |  0.13
Comm    | 0.026427   | 0.026427   | 0.026427   |   0.0 |  0.02
Output  | 7.8928e-05 | 7.8928e-05 | 7.8928e-05 |   0.0 |  0.00
Modify  | 0.12496    | 0.12496    | 0.12496    |   0.0 |  0.10
Other   |            | 0.01094    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6322 ave        6322 max        6322 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:       538748 ave      538748 max      538748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538748
Ave neighs/atom = 134.687
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 = 333.511777883421, Press = 4.72710279834045
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  -5861.3675     -5861.3675     -6033.0816     -6033.0816      332.19267      332.19267      95147.66       95147.66       303.88215      303.88215    
      9000  -5857.5935     -5857.5935     -6033.0764     -6033.0764      339.48369      339.48369      95409.059      95409.059     -466.60394     -466.60394    
Loop time of 127.79 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.497 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.44     | 127.44     | 127.44     |   0.0 | 99.73
Neigh   | 0.17991    | 0.17991    | 0.17991    |   0.0 |  0.14
Comm    | 0.027873   | 0.027873   | 0.027873   |   0.0 |  0.02
Output  | 6.2357e-05 | 6.2357e-05 | 6.2357e-05 |   0.0 |  0.00
Modify  | 0.12659    | 0.12659    | 0.12659    |   0.0 |  0.10
Other   |            | 0.01175    |            |       |  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:       537914 ave      537914 max      537914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 537914
Ave neighs/atom = 134.4785
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 = 333.450557538329, Press = 0.120732980195619
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   
      9000  -5857.5935     -5857.5935     -6033.0764     -6033.0764      339.48369      339.48369      95409.059      95409.059     -466.60394     -466.60394    
     10000  -5861.1273     -5861.1273     -6034.0048     -6034.0048      334.44318      334.44318      95246.889      95246.889     -44.78442      -44.78442     
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.16026    | 0.16026    | 0.16026    |   0.0 |  0.13
Comm    | 0.025468   | 0.025468   | 0.025468   |   0.0 |  0.02
Output  | 6.8559e-05 | 6.8559e-05 | 6.8559e-05 |   0.0 |  0.00
Modify  | 0.12466    | 0.12466    | 0.12466    |   0.0 |  0.10
Other   |            | 0.01089    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6361 ave        6361 max        6361 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:       538448 ave      538448 max      538448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538448
Ave neighs/atom = 134.612
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 = 333.448970443357, Press = -4.61505123376936
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  -5861.1273     -5861.1273     -6034.0048     -6034.0048      334.44318      334.44318      95246.889      95246.889     -44.78442      -44.78442     
     11000  -5862.4073     -5862.4073     -6035.4491     -6035.4491      334.761        334.761        95113.371      95113.371      333.78624      333.78624    
Loop time of 127.861 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.517 hours/ns, 7.821 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.54     | 127.54     | 127.54     |   0.0 | 99.75
Neigh   | 0.15978    | 0.15978    | 0.15978    |   0.0 |  0.12
Comm    | 0.025532   | 0.025532   | 0.025532   |   0.0 |  0.02
Output  | 6.3759e-05 | 6.3759e-05 | 6.3759e-05 |   0.0 |  0.00
Modify  | 0.12422    | 0.12422    | 0.12422    |   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:           6287 ave        6287 max        6287 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:       538978 ave      538978 max      538978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538978
Ave neighs/atom = 134.7445
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 = 333.386539319055, Press = 0.336069501593973
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   
     11000  -5862.4073     -5862.4073     -6035.4491     -6035.4491      334.761        334.761        95113.371      95113.371      333.78624      333.78624    
     12000  -5857.7084     -5857.7084     -6032.5784     -6032.5784      338.29791      338.29791      95459.045      95459.045     -548.55343     -548.55343    
Loop time of 127.971 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.547 hours/ns, 7.814 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.63     | 127.63     | 127.63     |   0.0 | 99.74
Neigh   | 0.17744    | 0.17744    | 0.17744    |   0.0 |  0.14
Comm    | 0.025705   | 0.025705   | 0.025705   |   0.0 |  0.02
Output  | 6.373e-05  | 6.373e-05  | 6.373e-05  |   0.0 |  0.00
Modify  | 0.12423    | 0.12423    | 0.12423    |   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:           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:       538252 ave      538252 max      538252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538252
Ave neighs/atom = 134.563
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 = 333.574052983265, Press = 1.56035871375931
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   
     12000  -5857.7084     -5857.7084     -6032.5784     -6032.5784      338.29791      338.29791      95459.045      95459.045     -548.55343     -548.55343    
     13000  -5859.4813     -5859.4813     -6029.8971     -6029.8971      329.6809       329.6809       95462.723      95462.723     -513.5757      -513.5757     
Loop time of 127.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.488 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.42     | 127.42     | 127.42     |   0.0 | 99.74
Neigh   | 0.17697    | 0.17697    | 0.17697    |   0.0 |  0.14
Comm    | 0.025784   | 0.025784   | 0.025784   |   0.0 |  0.02
Output  | 7.2345e-05 | 7.2345e-05 | 7.2345e-05 |   0.0 |  0.00
Modify  | 0.12419    | 0.12419    | 0.12419    |   0.0 |  0.10
Other   |            | 0.01073    |            |       |  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:       537458 ave      537458 max      537458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 537458
Ave neighs/atom = 134.3645
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 = 333.406377580638, Press = -3.58120655837164
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  -5859.4813     -5859.4813     -6029.8971     -6029.8971      329.6809       329.6809       95462.723      95462.723     -513.5757      -513.5757     
     14000  -5857.8564     -5857.8564     -6031.8946     -6031.8946      336.68871      336.68871      95182.852      95182.852      262.03599      262.03599    
Loop time of 128.018 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.561 hours/ns, 7.811 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.68     | 127.68     | 127.68     |   0.0 | 99.74
Neigh   | 0.17766    | 0.17766    | 0.17766    |   0.0 |  0.14
Comm    | 0.025706   | 0.025706   | 0.025706   |   0.0 |  0.02
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.12438    | 0.12438    | 0.12438    |   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:           6397 ave        6397 max        6397 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:       538648 ave      538648 max      538648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538648
Ave neighs/atom = 134.662
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 = 333.503932607579, Press = -2.24870458786315
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   
     14000  -5857.8564     -5857.8564     -6031.8946     -6031.8946      336.68871      336.68871      95182.852      95182.852      262.03599      262.03599    
     15000  -5863.6462     -5863.6462     -6033.9037     -6033.9037      329.37476      329.37476      95136.591      95136.591      301.4297       301.4297     
Loop time of 127.895 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.526 hours/ns, 7.819 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.58     | 127.58     | 127.58     |   0.0 | 99.75
Neigh   | 0.15941    | 0.15941    | 0.15941    |   0.0 |  0.12
Comm    | 0.025697   | 0.025697   | 0.025697   |   0.0 |  0.02
Output  | 7.4159e-05 | 7.4159e-05 | 7.4159e-05 |   0.0 |  0.00
Modify  | 0.12425    | 0.12425    | 0.12425    |   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:           6288 ave        6288 max        6288 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:       538778 ave      538778 max      538778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538778
Ave neighs/atom = 134.6945
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 = 333.394812288131, Press = -0.0363292437233055
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  -5863.6462     -5863.6462     -6033.9037     -6033.9037      329.37476      329.37476      95136.591      95136.591      301.4297       301.4297     
     16000  -5862.2152     -5862.2152     -6037.3794     -6037.3794      338.86704      338.86704      95251.503      95251.503     -84.658171     -84.658171    
Loop time of 127.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.552 hours/ns, 7.813 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.75
Neigh   | 0.15976    | 0.15976    | 0.15976    |   0.0 |  0.12
Comm    | 0.025771   | 0.025771   | 0.025771   |   0.0 |  0.02
Output  | 8.5361e-05 | 8.5361e-05 | 8.5361e-05 |   0.0 |  0.00
Modify  | 0.12429    | 0.12429    | 0.12429    |   0.0 |  0.10
Other   |            | 0.01081    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6341 ave        6341 max        6341 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:       538408 ave      538408 max      538408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538408
Ave neighs/atom = 134.602
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 = 333.501177049447, Press = 0.0609615891532643
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   
     16000  -5862.2152     -5862.2152     -6037.3794     -6037.3794      338.86704      338.86704      95251.503      95251.503     -84.658171     -84.658171    
     17000  -5859.7755     -5859.7755     -6032.8478     -6032.8478      334.82005      334.82005      95424.749      95424.749     -504.80277     -504.80277    
Loop time of 128.076 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.577 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.74     | 127.74     | 127.74     |   0.0 | 99.74
Neigh   | 0.17764    | 0.17764    | 0.17764    |   0.0 |  0.14
Comm    | 0.025513   | 0.025513   | 0.025513   |   0.0 |  0.02
Output  | 6.7727e-05 | 6.7727e-05 | 6.7727e-05 |   0.0 |  0.00
Modify  | 0.12431    | 0.12431    | 0.12431    |   0.0 |  0.10
Other   |            | 0.01073    |            |       |  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:       538290 ave      538290 max      538290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538290
Ave neighs/atom = 134.5725
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 = 333.429220347485, Press = -0.967308153595433
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   
     17000  -5859.7755     -5859.7755     -6032.8478     -6032.8478      334.82005      334.82005      95424.749      95424.749     -504.80277     -504.80277    
     18000  -5858.9017     -5858.9017     -6032.1728     -6032.1728      335.20478      335.20478      95205.853      95205.853      189.28961      189.28961    
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.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.83     | 127.83     | 127.83     |   0.0 | 99.74
Neigh   | 0.17756    | 0.17756    | 0.17756    |   0.0 |  0.14
Comm    | 0.02569    | 0.02569    | 0.02569    |   0.0 |  0.02
Output  | 6.8959e-05 | 6.8959e-05 | 6.8959e-05 |   0.0 |  0.00
Modify  | 0.12434    | 0.12434    | 0.12434    |   0.0 |  0.10
Other   |            | 0.01081    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6176 ave        6176 max        6176 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:       537226 ave      537226 max      537226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 537226
Ave neighs/atom = 134.3065
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 = 333.567098860187, Press = -6.0313421875047
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  -5858.9017     -5858.9017     -6032.1728     -6032.1728      335.20478      335.20478      95205.853      95205.853      189.28961      189.28961    
     19000  -5863.0614     -5863.0614     -6033.8079     -6033.8079      330.32063      330.32063      95011.525      95011.525      602.41805      602.41805    
Loop time of 127.981 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.550 hours/ns, 7.814 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.64     | 127.64     | 127.64     |   0.0 | 99.74
Neigh   | 0.17727    | 0.17727    | 0.17727    |   0.0 |  0.14
Comm    | 0.025815   | 0.025815   | 0.025815   |   0.0 |  0.02
Output  | 7.4089e-05 | 7.4089e-05 | 7.4089e-05 |   0.0 |  0.00
Modify  | 0.12442    | 0.12442    | 0.12442    |   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:           6343 ave        6343 max        6343 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:       538486 ave      538486 max      538486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538486
Ave neighs/atom = 134.6215
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 = 333.571602832397, Press = -0.232147125704954
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  -5863.0614     -5863.0614     -6033.8079     -6033.8079      330.32063      330.32063      95011.525      95011.525      602.41805      602.41805    
     20000  -5861.5239     -5861.5239     -6033.3844     -6033.3844      332.47581      332.47581      95232.53       95232.53       6.9636441      6.9636441    
Loop time of 127.906 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 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.59     | 127.59     | 127.59     |   0.0 | 99.75
Neigh   | 0.15919    | 0.15919    | 0.15919    |   0.0 |  0.12
Comm    | 0.025498   | 0.025498   | 0.025498   |   0.0 |  0.02
Output  | 7.505e-05  | 7.505e-05  | 7.505e-05  |   0.0 |  0.00
Modify  | 0.12428    | 0.12428    | 0.12428    |   0.0 |  0.10
Other   |            | 0.01092    |            |       |  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:       538862 ave      538862 max      538862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538862
Ave neighs/atom = 134.7155
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 = 333.522550834403, Press = 0.954203230312467
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   
     20000  -5861.5239     -5861.5239     -6033.3844     -6033.3844      332.47581      332.47581      95232.53       95232.53       6.9636441      6.9636441    
     21000  -5863.0818     -5863.0818     -6033.0339     -6033.0339      328.78382      328.78382      95311.841      95311.841     -199.59159     -199.59159    
Loop time of 127.906 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.530 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.59     | 127.59     | 127.59     |   0.0 | 99.75
Neigh   | 0.16026    | 0.16026    | 0.16026    |   0.0 |  0.13
Comm    | 0.025616   | 0.025616   | 0.025616   |   0.0 |  0.02
Output  | 7.2175e-05 | 7.2175e-05 | 7.2175e-05 |   0.0 |  0.00
Modify  | 0.12426    | 0.12426    | 0.12426    |   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:           6275 ave        6275 max        6275 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:       538734 ave      538734 max      538734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538734
Ave neighs/atom = 134.6835
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 = 333.557824663649, Press = -0.171292710439169
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  -5863.0818     -5863.0818     -6033.0339     -6033.0339      328.78382      328.78382      95311.841      95311.841     -199.59159     -199.59159    
     22000  -5859.5058     -5859.5058     -6032.8948     -6032.8948      335.43283      335.43283      95255.343      95255.343      50.638984      50.638984    
Loop time of 128.078 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.577 hours/ns, 7.808 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.76     | 127.76     | 127.76     |   0.0 | 99.75
Neigh   | 0.15967    | 0.15967    | 0.15967    |   0.0 |  0.12
Comm    | 0.025675   | 0.025675   | 0.025675   |   0.0 |  0.02
Output  | 8.3917e-05 | 8.3917e-05 | 8.3917e-05 |   0.0 |  0.00
Modify  | 0.12437    | 0.12437    | 0.12437    |   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:           6305 ave        6305 max        6305 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:       538554 ave      538554 max      538554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538554
Ave neighs/atom = 134.6385
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 = 333.554870421895, Press = -1.37801395168578
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  -5859.5058     -5859.5058     -6032.8948     -6032.8948      335.43283      335.43283      95255.343      95255.343      50.638984      50.638984    
     23000  -5861.5239     -5861.5239     -6035.5483     -6035.5483      336.66189      336.66189      94998.607      94998.607      640.70331      640.70331    
Loop time of 128.165 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.601 hours/ns, 7.802 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.83     | 127.83     | 127.83     |   0.0 | 99.74
Neigh   | 0.17768    | 0.17768    | 0.17768    |   0.0 |  0.14
Comm    | 0.02575    | 0.02575    | 0.02575    |   0.0 |  0.02
Output  | 7.5872e-05 | 7.5872e-05 | 7.5872e-05 |   0.0 |  0.00
Modify  | 0.1243     | 0.1243     | 0.1243     |   0.0 |  0.10
Other   |            | 0.01093    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6413 ave        6413 max        6413 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:       539278 ave      539278 max      539278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539278
Ave neighs/atom = 134.8195
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 = 333.483457534095, Press = 0.181877121175305
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   
     23000  -5861.5239     -5861.5239     -6035.5483     -6035.5483      336.66189      336.66189      94998.607      94998.607      640.70331      640.70331    
     24000  -5857.0014     -5857.0014     -6032.6081     -6032.6081      339.72301      339.72301      95290.316      95290.316     -10.290065     -10.290065    
Loop time of 127.808 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.502 hours/ns, 7.824 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.49     | 127.49     | 127.49     |   0.0 | 99.75
Neigh   | 0.15957    | 0.15957    | 0.15957    |   0.0 |  0.12
Comm    | 0.025466   | 0.025466   | 0.025466   |   0.0 |  0.02
Output  | 7.482e-05  | 7.482e-05  | 7.482e-05  |   0.0 |  0.00
Modify  | 0.12432    | 0.12432    | 0.12432    |   0.0 |  0.10
Other   |            | 0.01089    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6362 ave        6362 max        6362 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:       538936 ave      538936 max      538936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538936
Ave neighs/atom = 134.734
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 = 333.527988828466, Press = 1.82180676195159
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  -5857.0014     -5857.0014     -6032.6081     -6032.6081      339.72301      339.72301      95290.316      95290.316     -10.290065     -10.290065    
     25000  -5861.8604     -5861.8604     -6031.7206     -6031.7206      328.60596      328.60596      95430.799      95430.799     -479.79746     -479.79746    
Loop time of 128.126 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.591 hours/ns, 7.805 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.81     | 127.81     | 127.81     |   0.0 | 99.75
Neigh   | 0.1599     | 0.1599     | 0.1599     |   0.0 |  0.12
Comm    | 0.025547   | 0.025547   | 0.025547   |   0.0 |  0.02
Output  | 6.4742e-05 | 6.4742e-05 | 6.4742e-05 |   0.0 |  0.00
Modify  | 0.1243     | 0.1243     | 0.1243     |   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:           6298 ave        6298 max        6298 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:       538558 ave      538558 max      538558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538558
Ave neighs/atom = 134.6395
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 = 333.496891716889, Press = -0.51862464682675
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   
     25000  -5861.8604     -5861.8604     -6031.7206     -6031.7206      328.60596      328.60596      95430.799      95430.799     -479.79746     -479.79746    
     26000  -5853.4014     -5853.4014     -6030.9982     -6030.9982      343.57304      343.57304      95287.524      95287.524     -6.1860504     -6.1860504    
Loop time of 127.827 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.507 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.51     | 127.51     | 127.51     |   0.0 | 99.75
Neigh   | 0.15912    | 0.15912    | 0.15912    |   0.0 |  0.12
Comm    | 0.025475   | 0.025475   | 0.025475   |   0.0 |  0.02
Output  | 7.3378e-05 | 7.3378e-05 | 7.3378e-05 |   0.0 |  0.00
Modify  | 0.12423    | 0.12423    | 0.12423    |   0.0 |  0.10
Other   |            | 0.01081    |            |       |  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:       538314 ave      538314 max      538314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538314
Ave neighs/atom = 134.5785
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 = 333.472781331237, Press = -0.750994535295204
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   
     26000  -5853.4014     -5853.4014     -6030.9982     -6030.9982      343.57304      343.57304      95287.524      95287.524     -6.1860504     -6.1860504    
     27000  -5861.5399     -5861.5399     -6033.5165     -6033.5165      332.70035      332.70035      95120.483      95120.483      362.02715      362.02715    
Loop time of 127.822 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.506 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.48     | 127.48     | 127.48     |   0.0 | 99.74
Neigh   | 0.17792    | 0.17792    | 0.17792    |   0.0 |  0.14
Comm    | 0.025723   | 0.025723   | 0.025723   |   0.0 |  0.02
Output  | 7.6934e-05 | 7.6934e-05 | 7.6934e-05 |   0.0 |  0.00
Modify  | 0.12421    | 0.12421    | 0.12421    |   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:           6374 ave        6374 max        6374 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:       538916 ave      538916 max      538916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538916
Ave neighs/atom = 134.729
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 = 333.546242959246, Press = 0.364509542673888
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  -5861.5399     -5861.5399     -6033.5165     -6033.5165      332.70035      332.70035      95120.483      95120.483      362.02715      362.02715    
     28000  -5858.4538     -5858.4538     -6032.4557     -6032.4557      336.61867      336.61867      95348.674      95348.674     -252.30806     -252.30806    
Loop time of 127.68 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.677 ns/day, 35.467 hours/ns, 7.832 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.36     | 127.36     | 127.36     |   0.0 | 99.75
Neigh   | 0.15925    | 0.15925    | 0.15925    |   0.0 |  0.12
Comm    | 0.02541    | 0.02541    | 0.02541    |   0.0 |  0.02
Output  | 7.1264e-05 | 7.1264e-05 | 7.1264e-05 |   0.0 |  0.00
Modify  | 0.12406    | 0.12406    | 0.12406    |   0.0 |  0.10
Other   |            | 0.01078    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6312 ave        6312 max        6312 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:       538638 ave      538638 max      538638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538638
Ave neighs/atom = 134.6595
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 = 333.576886357935, Press = 0.502765685538993
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  -5858.4538     -5858.4538     -6032.4557     -6032.4557      336.61867      336.61867      95348.674      95348.674     -252.30806     -252.30806    
     29000  -5856.8124     -5856.8124     -6030.6413     -6030.6413      336.28378      336.28378      95499.405      95499.405     -638.63076     -638.63076    
Loop time of 127.947 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.541 hours/ns, 7.816 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.63     | 127.63     | 127.63     |   0.0 | 99.75
Neigh   | 0.15998    | 0.15998    | 0.15998    |   0.0 |  0.13
Comm    | 0.025531   | 0.025531   | 0.025531   |   0.0 |  0.02
Output  | 7.8067e-05 | 7.8067e-05 | 7.8067e-05 |   0.0 |  0.00
Modify  | 0.12427    | 0.12427    | 0.12427    |   0.0 |  0.10
Other   |            | 0.01075    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6274 ave        6274 max        6274 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:       538150 ave      538150 max      538150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538150
Ave neighs/atom = 134.5375
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 = 333.575504300937, Press = -1.12766223910191
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   
     29000  -5856.8124     -5856.8124     -6030.6413     -6030.6413      336.28378      336.28378      95499.405      95499.405     -638.63076     -638.63076    
     30000  -5862.7354     -5862.7354     -6030.924      -6030.924       325.37225      325.37225      95077.356      95077.356      481.45927      481.45927    
Loop time of 128.191 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.609 hours/ns, 7.801 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.85     | 127.85     | 127.85     |   0.0 | 99.74
Neigh   | 0.17826    | 0.17826    | 0.17826    |   0.0 |  0.14
Comm    | 0.025636   | 0.025636   | 0.025636   |   0.0 |  0.02
Output  | 8.0131e-05 | 8.0131e-05 | 8.0131e-05 |   0.0 |  0.00
Modify  | 0.12431    | 0.12431    | 0.12431    |   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:           6389 ave        6389 max        6389 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:       538332 ave      538332 max      538332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538332
Ave neighs/atom = 134.583
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 = 333.596345376628, Press = -0.844658438251789
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  -5862.7354     -5862.7354     -6030.924      -6030.924       325.37225      325.37225      95077.356      95077.356      481.45927      481.45927    
     31000  -5862.075      -5862.075      -6033.2773     -6033.2773      331.20258      331.20258      95218.233      95218.233      42.982221      42.982221    
Loop time of 128.128 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.591 hours/ns, 7.805 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.81     | 127.81     | 127.81     |   0.0 | 99.75
Neigh   | 0.15929    | 0.15929    | 0.15929    |   0.0 |  0.12
Comm    | 0.025425   | 0.025425   | 0.025425   |   0.0 |  0.02
Output  | 8.0982e-05 | 8.0982e-05 | 8.0982e-05 |   0.0 |  0.00
Modify  | 0.12425    | 0.12425    | 0.12425    |   0.0 |  0.10
Other   |            | 0.01086    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6312 ave        6312 max        6312 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:       538342 ave      538342 max      538342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538342
Ave neighs/atom = 134.5855
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 = 333.615303648205, Press = 0.171767764472126
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   
     31000  -5862.075      -5862.075      -6033.2773     -6033.2773      331.20258      331.20258      95218.233      95218.233      42.982221      42.982221    
     32000  -5858.3969     -5858.3969     -6029.8924     -6029.8924      331.76972      331.76972      95394.911      95394.911     -336.35349     -336.35349    
Loop time of 128.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.614 hours/ns, 7.800 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.89     | 127.89     | 127.89     |   0.0 | 99.75
Neigh   | 0.1601     | 0.1601     | 0.1601     |   0.0 |  0.12
Comm    | 0.02563    | 0.02563    | 0.02563    |   0.0 |  0.02
Output  | 6.0374e-05 | 6.0374e-05 | 6.0374e-05 |   0.0 |  0.00
Modify  | 0.12424    | 0.12424    | 0.12424    |   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:           6262 ave        6262 max        6262 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:       538240 ave      538240 max      538240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538240
Ave neighs/atom = 134.56
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 = 333.528004645207, Press = -0.214079537754325
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  -5858.3969     -5858.3969     -6029.8924     -6029.8924      331.76972      331.76972      95394.911      95394.911     -336.35349     -336.35349    
     33000  -5860.4112     -5860.4112     -6033.7272     -6033.7272      335.29144      335.29144      95238.968      95238.968     -26.614706     -26.614706    
Loop time of 128.048 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.569 hours/ns, 7.810 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.73     | 127.73     | 127.73     |   0.0 | 99.75
Neigh   | 0.16045    | 0.16045    | 0.16045    |   0.0 |  0.13
Comm    | 0.025555   | 0.025555   | 0.025555   |   0.0 |  0.02
Output  | 6.9471e-05 | 6.9471e-05 | 6.9471e-05 |   0.0 |  0.00
Modify  | 0.12422    | 0.12422    | 0.12422    |   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:           6420 ave        6420 max        6420 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:       538310 ave      538310 max      538310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538310
Ave neighs/atom = 134.5775
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 = 333.504885656535, Press = -0.541477702276434
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   
     33000  -5860.4112     -5860.4112     -6033.7272     -6033.7272      335.29144      335.29144      95238.968      95238.968     -26.614706     -26.614706    
     34000  -5859.2543     -5859.2543     -6031.0462     -6031.0462      332.34301      332.34301      95201.613      95201.613      169.05736      169.05736    
Loop time of 127.997 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.555 hours/ns, 7.813 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.66     | 127.66     | 127.66     |   0.0 | 99.74
Neigh   | 0.17676    | 0.17676    | 0.17676    |   0.0 |  0.14
Comm    | 0.025749   | 0.025749   | 0.025749   |   0.0 |  0.02
Output  | 7.979e-05  | 7.979e-05  | 7.979e-05  |   0.0 |  0.00
Modify  | 0.12427    | 0.12427    | 0.12427    |   0.0 |  0.10
Other   |            | 0.01075    |            |       |  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:       538246 ave      538246 max      538246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538246
Ave neighs/atom = 134.5615
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 = 333.592279712872, Press = -0.659768271255713
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   
     34000  -5859.2543     -5859.2543     -6031.0462     -6031.0462      332.34301      332.34301      95201.613      95201.613      169.05736      169.05736    
     35000  -5857.8383     -5857.8383     -6032.4963     -6032.4963      337.88787      337.88787      95008.942      95008.942      680.4103       680.4103     
Loop time of 128.048 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.569 hours/ns, 7.810 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.73     | 127.73     | 127.73     |   0.0 | 99.75
Neigh   | 0.15984    | 0.15984    | 0.15984    |   0.0 |  0.12
Comm    | 0.02564    | 0.02564    | 0.02564    |   0.0 |  0.02
Output  | 6.9531e-05 | 6.9531e-05 | 6.9531e-05 |   0.0 |  0.00
Modify  | 0.12426    | 0.12426    | 0.12426    |   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:           6261 ave        6261 max        6261 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:       539024 ave      539024 max      539024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539024
Ave neighs/atom = 134.756
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 = 333.60641256385, Press = 0.612411470765276
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   
     35000  -5857.8383     -5857.8383     -6032.4963     -6032.4963      337.88787      337.88787      95008.942      95008.942      680.4103       680.4103     
     36000  -5862.3436     -5862.3436     -6035.0933     -6035.0933      334.19594      334.19594      95363.105      95363.105     -403.5976      -403.5976     
Loop time of 128.286 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.635 hours/ns, 7.795 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.95     | 127.95     | 127.95     |   0.0 | 99.74
Neigh   | 0.17771    | 0.17771    | 0.17771    |   0.0 |  0.14
Comm    | 0.025716   | 0.025716   | 0.025716   |   0.0 |  0.02
Output  | 6.7917e-05 | 6.7917e-05 | 6.7917e-05 |   0.0 |  0.00
Modify  | 0.12439    | 0.12439    | 0.12439    |   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:           6356 ave        6356 max        6356 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:       538836 ave      538836 max      538836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538836
Ave neighs/atom = 134.709
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 = 333.605093620683, Press = 1.01614864832961
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   
     36000  -5862.3436     -5862.3436     -6035.0933     -6035.0933      334.19594      334.19594      95363.105      95363.105     -403.5976      -403.5976     
     37000  -5859.4535     -5859.4535     -6031.6212     -6031.6212      333.07006      333.07006      95405.849      95405.849     -395.64311     -395.64311    
Loop time of 128.16 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.600 hours/ns, 7.803 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.82     | 127.82     | 127.82     |   0.0 | 99.74
Neigh   | 0.17765    | 0.17765    | 0.17765    |   0.0 |  0.14
Comm    | 0.025655   | 0.025655   | 0.025655   |   0.0 |  0.02
Output  | 8.023e-05  | 8.023e-05  | 8.023e-05  |   0.0 |  0.00
Modify  | 0.12435    | 0.12435    | 0.12435    |   0.0 |  0.10
Other   |            | 0.01078    |            |       |  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:       538502 ave      538502 max      538502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538502
Ave neighs/atom = 134.6255
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 = 333.563871163565, Press = -0.462862556727854
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   
     37000  -5859.4535     -5859.4535     -6031.6212     -6031.6212      333.07006      333.07006      95405.849      95405.849     -395.64311     -395.64311    
     38000  -5864.9092     -5864.9092     -6036.5475     -6036.5475      332.04599      332.04599      95172.701      95172.701      162.6755       162.6755     
Loop time of 128.152 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.598 hours/ns, 7.803 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.83     | 127.83     | 127.83     |   0.0 | 99.75
Neigh   | 0.15964    | 0.15964    | 0.15964    |   0.0 |  0.12
Comm    | 0.02567    | 0.02567    | 0.02567    |   0.0 |  0.02
Output  | 7.985e-05  | 7.985e-05  | 7.985e-05  |   0.0 |  0.00
Modify  | 0.12443    | 0.12443    | 0.12443    |   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:           6318 ave        6318 max        6318 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:       538938 ave      538938 max      538938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538938
Ave neighs/atom = 134.7345
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 = 333.546150712508, Press = -0.598613510630417
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   
     38000  -5864.9092     -5864.9092     -6036.5475     -6036.5475      332.04599      332.04599      95172.701      95172.701      162.6755       162.6755     
     39000  -5858.9805     -5858.9805     -6028.4894     -6028.4894      327.92648      327.92648      95113.535      95113.535      523.05934      523.05934    
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.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.74     | 127.74     | 127.74     |   0.0 | 99.75
Neigh   | 0.16013    | 0.16013    | 0.16013    |   0.0 |  0.13
Comm    | 0.025583   | 0.025583   | 0.025583   |   0.0 |  0.02
Output  | 7.8527e-05 | 7.8527e-05 | 7.8527e-05 |   0.0 |  0.00
Modify  | 0.12439    | 0.12439    | 0.12439    |   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:           6316 ave        6316 max        6316 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:       538682 ave      538682 max      538682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538682
Ave neighs/atom = 134.6705
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 = 333.502352290434, Press = 0.2341604345734
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   
     39000  -5858.9805     -5858.9805     -6028.4894     -6028.4894      327.92648      327.92648      95113.535      95113.535      523.05934      523.05934    
     40000  -5862.6585     -5862.6585     -6033.711      -6033.711       330.91266      330.91266      95347.474      95347.474     -328.5168      -328.5168     
Loop time of 128.215 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.615 hours/ns, 7.799 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.88     | 127.88     | 127.88     |   0.0 | 99.74
Neigh   | 0.17792    | 0.17792    | 0.17792    |   0.0 |  0.14
Comm    | 0.025778   | 0.025778   | 0.025778   |   0.0 |  0.02
Output  | 6.413e-05  | 6.413e-05  | 6.413e-05  |   0.0 |  0.00
Modify  | 0.12399    | 0.12399    | 0.12399    |   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:           6377 ave        6377 max        6377 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:       538798 ave      538798 max      538798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538798
Ave neighs/atom = 134.6995
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 = 333.466670563518, Press = 0.527036687667777
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   
     40000  -5862.6585     -5862.6585     -6033.711      -6033.711       330.91266      330.91266      95347.474      95347.474     -328.5168      -328.5168     
     41000  -5857.7482     -5857.7482     -6029.607      -6029.607       332.47253      332.47253      95419.618      95419.618     -438.49852     -438.49852    
Loop time of 127.974 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.548 hours/ns, 7.814 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.65     | 127.65     | 127.65     |   0.0 | 99.75
Neigh   | 0.1595     | 0.1595     | 0.1595     |   0.0 |  0.12
Comm    | 0.025506   | 0.025506   | 0.025506   |   0.0 |  0.02
Output  | 6.7327e-05 | 6.7327e-05 | 6.7327e-05 |   0.0 |  0.00
Modify  | 0.12409    | 0.12409    | 0.12409    |   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:           6342 ave        6342 max        6342 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:       537904 ave      537904 max      537904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 537904
Ave neighs/atom = 134.476
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 = 333.439472650914, Press = -0.754898407128799
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   
     41000  -5857.7482     -5857.7482     -6029.607      -6029.607       332.47253      332.47253      95419.618      95419.618     -438.49852     -438.49852    
     42000  -5859.7119     -5859.7119     -6032.7145     -6032.7145      334.68514      334.68514      95133.49       95133.49       317.71126      317.71126    
Loop time of 128.39 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.664 hours/ns, 7.789 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    | 128.05     | 128.05     | 128.05     |   0.0 | 99.74
Neigh   | 0.17762    | 0.17762    | 0.17762    |   0.0 |  0.14
Comm    | 0.025737   | 0.025737   | 0.025737   |   0.0 |  0.02
Output  | 6.5613e-05 | 6.5613e-05 | 6.5613e-05 |   0.0 |  0.00
Modify  | 0.12397    | 0.12397    | 0.12397    |   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:           6314 ave        6314 max        6314 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:       538604 ave      538604 max      538604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538604
Ave neighs/atom = 134.651
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 = 333.51300093655, Press = -0.310500655435752
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   
     42000  -5859.7119     -5859.7119     -6032.7145     -6032.7145      334.68514      334.68514      95133.49       95133.49       317.71126      317.71126    
     43000  -5859.4458     -5859.4458     -6032.6487     -6032.6487      335.07266      335.07266      95308.041      95308.041     -133.78072     -133.78072    
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.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.75     | 127.75     | 127.75     |   0.0 | 99.75
Neigh   | 0.1598     | 0.1598     | 0.1598     |   0.0 |  0.12
Comm    | 0.025694   | 0.025694   | 0.025694   |   0.0 |  0.02
Output  | 7.5973e-05 | 7.5973e-05 | 7.5973e-05 |   0.0 |  0.00
Modify  | 0.12416    | 0.12416    | 0.12416    |   0.0 |  0.10
Other   |            | 0.01087    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6361 ave        6361 max        6361 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:       538546 ave      538546 max      538546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538546
Ave neighs/atom = 134.6365
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 = 333.469755341946, Press = 0.239470026557879
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   
     43000  -5859.4458     -5859.4458     -6032.6487     -6032.6487      335.07266      335.07266      95308.041      95308.041     -133.78072     -133.78072    
     44000  -5862.9085     -5862.9085     -6032.4968     -6032.4968      328.08002      328.08002      95265.601      95265.601     -79.113141     -79.113141    
Loop time of 128.319 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.644 hours/ns, 7.793 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128        | 128        | 128        |   0.0 | 99.75
Neigh   | 0.15932    | 0.15932    | 0.15932    |   0.0 |  0.12
Comm    | 0.025533   | 0.025533   | 0.025533   |   0.0 |  0.02
Output  | 7.0963e-05 | 7.0963e-05 | 7.0963e-05 |   0.0 |  0.00
Modify  | 0.12415    | 0.12415    | 0.12415    |   0.0 |  0.10
Other   |            | 0.01087    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6357 ave        6357 max        6357 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:       538188 ave      538188 max      538188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538188
Ave neighs/atom = 134.547
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 = 333.488913898215, Press = -0.209897997914762
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   
     44000  -5862.9085     -5862.9085     -6032.4968     -6032.4968      328.08002      328.08002      95265.601      95265.601     -79.113141     -79.113141    
     45000  -5859.799      -5859.799      -6034.4187     -6034.4187      337.81364      337.81364      95240.538      95240.538      35.966745      35.966745    
Loop time of 128.118 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.588 hours/ns, 7.805 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.8      | 127.8      | 127.8      |   0.0 | 99.75
Neigh   | 0.15994    | 0.15994    | 0.15994    |   0.0 |  0.12
Comm    | 0.025514   | 0.025514   | 0.025514   |   0.0 |  0.02
Output  | 0.00016217 | 0.00016217 | 0.00016217 |   0.0 |  0.00
Modify  | 0.12399    | 0.12399    | 0.12399    |   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:           6230 ave        6230 max        6230 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:       538270 ave      538270 max      538270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538270
Ave neighs/atom = 134.5675
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 = 333.494828108712, Press = -0.32651761910672
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   
     45000  -5859.799      -5859.799      -6034.4187     -6034.4187      337.81364      337.81364      95240.538      95240.538      35.966745      35.966745    
     46000  -5860.6854     -5860.6854     -6033.6645     -6033.6645      334.63985      334.63985      95119.063      95119.063      411.02082      411.02082    
Loop time of 128.184 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.607 hours/ns, 7.801 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.87     | 127.87     | 127.87     |   0.0 | 99.75
Neigh   | 0.15989    | 0.15989    | 0.15989    |   0.0 |  0.12
Comm    | 0.024995   | 0.024995   | 0.024995   |   0.0 |  0.02
Output  | 8.4889e-05 | 8.4889e-05 | 8.4889e-05 |   0.0 |  0.00
Modify  | 0.12296    | 0.12296    | 0.12296    |   0.0 |  0.10
Other   |            | 0.01063    |            |       |  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:       538496 ave      538496 max      538496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538496
Ave neighs/atom = 134.624
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 = 333.518776807234, Press = -0.21939317910862
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   
     46000  -5860.6854     -5860.6854     -6033.6645     -6033.6645      334.63985      334.63985      95119.063      95119.063      411.02082      411.02082    
     47000  -5861.2079     -5861.2079     -6034.2689     -6034.2689      334.79827      334.79827      95201.615      95201.615      98.003122      98.003122    
Loop time of 127.849 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.514 hours/ns, 7.822 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.75
Neigh   | 0.16012    | 0.16012    | 0.16012    |   0.0 |  0.13
Comm    | 0.024548   | 0.024548   | 0.024548   |   0.0 |  0.02
Output  | 5.868e-05  | 5.868e-05  | 5.868e-05  |   0.0 |  0.00
Modify  | 0.1224     | 0.1224     | 0.1224     |   0.0 |  0.10
Other   |            | 0.01065    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6458 ave        6458 max        6458 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:       539318 ave      539318 max      539318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539318
Ave neighs/atom = 134.8295
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 = 333.474455678799, Press = 0.696074496491489
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   
     47000  -5861.2079     -5861.2079     -6034.2689     -6034.2689      334.79827      334.79827      95201.615      95201.615      98.003122      98.003122    
     48000  -5862.4166     -5862.4166     -6031.3765     -6031.3765      326.8644       326.8644       95470.265      95470.265     -588.00801     -588.00801    
Loop time of 127.993 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.554 hours/ns, 7.813 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.66     | 127.66     | 127.66     |   0.0 | 99.74
Neigh   | 0.1774     | 0.1774     | 0.1774     |   0.0 |  0.14
Comm    | 0.024691   | 0.024691   | 0.024691   |   0.0 |  0.02
Output  | 6.1556e-05 | 6.1556e-05 | 6.1556e-05 |   0.0 |  0.00
Modify  | 0.12264    | 0.12264    | 0.12264    |   0.0 |  0.10
Other   |            | 0.0106     |            |       |  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:       537970 ave      537970 max      537970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 537970
Ave neighs/atom = 134.4925
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 = 333.44749241156, Press = -0.230121370575891
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   
     48000  -5862.4166     -5862.4166     -6031.3765     -6031.3765      326.8644       326.8644       95470.265      95470.265     -588.00801     -588.00801    
     49000  -5860.8358     -5860.8358     -6033.9576     -6033.9576      334.91589      334.91589      95250.239      95250.239     -6.4744389     -6.4744389    
Loop time of 127.954 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.543 hours/ns, 7.815 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.64     | 127.64     | 127.64     |   0.0 | 99.75
Neigh   | 0.15969    | 0.15969    | 0.15969    |   0.0 |  0.12
Comm    | 0.024644   | 0.024644   | 0.024644   |   0.0 |  0.02
Output  | 6.377e-05  | 6.377e-05  | 6.377e-05  |   0.0 |  0.00
Modify  | 0.12269    | 0.12269    | 0.12269    |   0.0 |  0.10
Other   |            | 0.01059    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6230 ave        6230 max        6230 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:       538198 ave      538198 max      538198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538198
Ave neighs/atom = 134.5495
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 = 333.386864736794, Press = -0.521976471773497
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   
     49000  -5860.8358     -5860.8358     -6033.9576     -6033.9576      334.91589      334.91589      95250.239      95250.239     -6.4744389     -6.4744389    
     50000  -5864.5561     -5864.5561     -6037.3238     -6037.3238      334.23086      334.23086      95140.067      95140.067      187.64684      187.64684    
Loop time of 127.958 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.64     | 127.64     | 127.64     |   0.0 | 99.75
Neigh   | 0.16023    | 0.16023    | 0.16023    |   0.0 |  0.13
Comm    | 0.024746   | 0.024746   | 0.024746   |   0.0 |  0.02
Output  | 7.3097e-05 | 7.3097e-05 | 7.3097e-05 |   0.0 |  0.00
Modify  | 0.12269    | 0.12269    | 0.12269    |   0.0 |  0.10
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6312 ave        6312 max        6312 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:       538748 ave      538748 max      538748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538748
Ave neighs/atom = 134.687
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 = 333.380380246035, Press = -0.158515620417392
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   
     50000  -5864.5561     -5864.5561     -6037.3238     -6037.3238      334.23086      334.23086      95140.067      95140.067      187.64684      187.64684    
     51000  -5860.5747     -5860.5747     -6033.9258     -6033.9258      335.35943      335.35943      95235.999      95235.999      25.773391      25.773391    
Loop time of 128.001 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.556 hours/ns, 7.812 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.68     | 127.68     | 127.68     |   0.0 | 99.75
Neigh   | 0.16023    | 0.16023    | 0.16023    |   0.0 |  0.13
Comm    | 0.024513   | 0.024513   | 0.024513   |   0.0 |  0.02
Output  | 7.3137e-05 | 7.3137e-05 | 7.3137e-05 |   0.0 |  0.00
Modify  | 0.12255    | 0.12255    | 0.12255    |   0.0 |  0.10
Other   |            | 0.01056    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6425 ave        6425 max        6425 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:       538820 ave      538820 max      538820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538820
Ave neighs/atom = 134.705
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 = 333.36813064708, Press = 0.071677193529976
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   
     51000  -5860.5747     -5860.5747     -6033.9258     -6033.9258      335.35943      335.35943      95235.999      95235.999      25.773391      25.773391    
     52000  -5861.0844     -5861.0844     -6034.0759     -6034.0759      334.66378      334.66378      95298.212      95298.212     -132.85937     -132.85937    
Loop time of 127.8 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.48     | 127.48     | 127.48     |   0.0 | 99.75
Neigh   | 0.15986    | 0.15986    | 0.15986    |   0.0 |  0.13
Comm    | 0.024569   | 0.024569   | 0.024569   |   0.0 |  0.02
Output  | 7.0001e-05 | 7.0001e-05 | 7.0001e-05 |   0.0 |  0.00
Modify  | 0.12266    | 0.12266    | 0.12266    |   0.0 |  0.10
Other   |            | 0.01046    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6314 ave        6314 max        6314 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:       538272 ave      538272 max      538272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538272
Ave neighs/atom = 134.568
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 = 333.396654536617, Press = -0.189105674698943
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   
     52000  -5861.0844     -5861.0844     -6034.0759     -6034.0759      334.66378      334.66378      95298.212      95298.212     -132.85937     -132.85937    
     53000  -5857.8863     -5857.8863     -6032.0879     -6032.0879      337.00492      337.00492      95236.939      95236.939      122.85905      122.85905    
Loop time of 127.941 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.539 hours/ns, 7.816 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.62     | 127.62     | 127.62     |   0.0 | 99.75
Neigh   | 0.16051    | 0.16051    | 0.16051    |   0.0 |  0.13
Comm    | 0.024666   | 0.024666   | 0.024666   |   0.0 |  0.02
Output  | 7.3638e-05 | 7.3638e-05 | 7.3638e-05 |   0.0 |  0.00
Modify  | 0.12268    | 0.12268    | 0.12268    |   0.0 |  0.10
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6267 ave        6267 max        6267 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:       538616 ave      538616 max      538616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538616
Ave neighs/atom = 134.654
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 = 333.407020141304, Press = -0.211433767063165
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   
     53000  -5857.8863     -5857.8863     -6032.0879     -6032.0879      337.00492      337.00492      95236.939      95236.939      122.85905      122.85905    
     54000  -5856.7824     -5856.7824     -6032.1918     -6032.1918      339.34142      339.34142      95211.993      95211.993      156.59559      156.59559    
Loop time of 127.956 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.543 hours/ns, 7.815 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.64     | 127.64     | 127.64     |   0.0 | 99.75
Neigh   | 0.16027    | 0.16027    | 0.16027    |   0.0 |  0.13
Comm    | 0.024623   | 0.024623   | 0.024623   |   0.0 |  0.02
Output  | 7.9249e-05 | 7.9249e-05 | 7.9249e-05 |   0.0 |  0.00
Modify  | 0.12251    | 0.12251    | 0.12251    |   0.0 |  0.10
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6336 ave        6336 max        6336 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:       538014 ave      538014 max      538014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538014
Ave neighs/atom = 134.5035
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 = 333.440650826679, Press = -0.156323603436985
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   
     54000  -5856.7824     -5856.7824     -6032.1918     -6032.1918      339.34142      339.34142      95211.993      95211.993      156.59559      156.59559    
     55000  -5864.3245     -5864.3245     -6033.785      -6033.785       327.83294      327.83294      95250.797      95250.797     -67.787899     -67.787899    
Loop time of 128.013 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.559 hours/ns, 7.812 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.7      | 127.7      | 127.7      |   0.0 | 99.75
Neigh   | 0.15971    | 0.15971    | 0.15971    |   0.0 |  0.12
Comm    | 0.024598   | 0.024598   | 0.024598   |   0.0 |  0.02
Output  | 6.1235e-05 | 6.1235e-05 | 6.1235e-05 |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.10
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6382 ave        6382 max        6382 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:       538658 ave      538658 max      538658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538658
Ave neighs/atom = 134.6645
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 = 333.466836771929, Press = -0.145899845055731
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   
     55000  -5864.3245     -5864.3245     -6033.785      -6033.785       327.83294      327.83294      95250.797      95250.797     -67.787899     -67.787899    
     56000  -5857.3103     -5857.3103     -6030.4848     -6030.4848      335.01786      335.01786      95339.273      95339.273     -179.22157     -179.22157    
Loop time of 128.122 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.589 hours/ns, 7.805 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.8      | 127.8      | 127.8      |   0.0 | 99.75
Neigh   | 0.16024    | 0.16024    | 0.16024    |   0.0 |  0.13
Comm    | 0.024714   | 0.024714   | 0.024714   |   0.0 |  0.02
Output  | 6.2728e-05 | 6.2728e-05 | 6.2728e-05 |   0.0 |  0.00
Modify  | 0.12284    | 0.12284    | 0.12284    |   0.0 |  0.10
Other   |            | 0.01056    |            |       |  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:       537786 ave      537786 max      537786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 537786
Ave neighs/atom = 134.4465
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 = 333.45055724436, Press = -0.541859198513293
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   
     56000  -5857.3103     -5857.3103     -6030.4848     -6030.4848      335.01786      335.01786      95339.273      95339.273     -179.22157     -179.22157    
     57000  -5862.3896     -5862.3896     -6035.6333     -6035.6333      335.15167      335.15167      95069.452      95069.452      434.44145      434.44145    
Loop time of 128.301 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.639 hours/ns, 7.794 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.98     | 127.98     | 127.98     |   0.0 | 99.75
Neigh   | 0.15948    | 0.15948    | 0.15948    |   0.0 |  0.12
Comm    | 0.024798   | 0.024798   | 0.024798   |   0.0 |  0.02
Output  | 6.4982e-05 | 6.4982e-05 | 6.4982e-05 |   0.0 |  0.00
Modify  | 0.12301    | 0.12301    | 0.12301    |   0.0 |  0.10
Other   |            | 0.01061    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6332 ave        6332 max        6332 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:       538156 ave      538156 max      538156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538156
Ave neighs/atom = 134.539
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 = 333.442742296881, Press = -0.288835305353278
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   
     57000  -5862.3896     -5862.3896     -6035.6333     -6035.6333      335.15167      335.15167      95069.452      95069.452      434.44145      434.44145    
     58000  -5862.2737     -5862.2737     -6036.7501     -6036.7501      337.5363       337.5363       95210.388      95210.388     -17.725481     -17.725481    
Loop time of 128.199 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.611 hours/ns, 7.800 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.88     | 127.88     | 127.88     |   0.0 | 99.75
Neigh   | 0.16036    | 0.16036    | 0.16036    |   0.0 |  0.13
Comm    | 0.024796   | 0.024796   | 0.024796   |   0.0 |  0.02
Output  | 7.3448e-05 | 7.3448e-05 | 7.3448e-05 |   0.0 |  0.00
Modify  | 0.12307    | 0.12307    | 0.12307    |   0.0 |  0.10
Other   |            | 0.01055    |            |       |  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:       538960 ave      538960 max      538960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538960
Ave neighs/atom = 134.74
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 = 333.406702665799, Press = 0.401841579539226
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   
     58000  -5862.2737     -5862.2737     -6036.7501     -6036.7501      337.5363       337.5363       95210.388      95210.388     -17.725481     -17.725481    
     59000  -5858.957      -5858.957      -6032.143      -6032.143       335.04002      335.04002      95413.812      95413.812     -421.69684     -421.69684    
Loop time of 128.146 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.596 hours/ns, 7.804 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.81     | 127.81     | 127.81     |   0.0 | 99.74
Neigh   | 0.17743    | 0.17743    | 0.17743    |   0.0 |  0.14
Comm    | 0.024933   | 0.024933   | 0.024933   |   0.0 |  0.02
Output  | 8.7905e-05 | 8.7905e-05 | 8.7905e-05 |   0.0 |  0.00
Modify  | 0.12284    | 0.12284    | 0.12284    |   0.0 |  0.10
Other   |            | 0.01056    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6296 ave        6296 max        6296 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:       538094 ave      538094 max      538094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538094
Ave neighs/atom = 134.5235
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 = 333.381802109781, Press = -0.176209642616902
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   
     59000  -5858.957      -5858.957      -6032.143      -6032.143       335.04002      335.04002      95413.812      95413.812     -421.69684     -421.69684    
     60000  -5862.7526     -5862.7526     -6034.8967     -6034.8967      333.02439      333.02439      95250.439      95250.439     -79.939599     -79.939599    
Loop time of 128.082 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.578 hours/ns, 7.808 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.75     | 127.75     | 127.75     |   0.0 | 99.74
Neigh   | 0.17682    | 0.17682    | 0.17682    |   0.0 |  0.14
Comm    | 0.024914   | 0.024914   | 0.024914   |   0.0 |  0.02
Output  | 8.6211e-05 | 8.6211e-05 | 8.6211e-05 |   0.0 |  0.00
Modify  | 0.12274    | 0.12274    | 0.12274    |   0.0 |  0.10
Other   |            | 0.01049    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6298 ave        6298 max        6298 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:       538656 ave      538656 max      538656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538656
Ave neighs/atom = 134.664
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 = 333.356292379537, Press = -0.541550207023803
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   
     60000  -5862.7526     -5862.7526     -6034.8967     -6034.8967      333.02439      333.02439      95250.439      95250.439     -79.939599     -79.939599    
     61000  -5866.4289     -5866.4289     -6038.1313     -6038.1313      332.16991      332.16991      94950.881      94950.881      682.58524      682.58524    
Loop time of 128.212 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.614 hours/ns, 7.800 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.88     | 127.88     | 127.88     |   0.0 | 99.74
Neigh   | 0.1773     | 0.1773     | 0.1773     |   0.0 |  0.14
Comm    | 0.025008   | 0.025008   | 0.025008   |   0.0 |  0.02
Output  | 7.6163e-05 | 7.6163e-05 | 7.6163e-05 |   0.0 |  0.00
Modify  | 0.123      | 0.123      | 0.123      |   0.0 |  0.10
Other   |            | 0.01058    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6415 ave        6415 max        6415 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:       539266 ave      539266 max      539266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539266
Ave neighs/atom = 134.8165
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 = 333.353573369868, Press = -0.314219585005274
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   
     61000  -5866.4289     -5866.4289     -6038.1313     -6038.1313      332.16991      332.16991      94950.881      94950.881      682.58524      682.58524    
     62000  -5864.2363     -5864.2363     -6036.1995     -6036.1995      332.67456      332.67456      95008.642      95008.642      579.52326      579.52326    
Loop time of 128.304 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.640 hours/ns, 7.794 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.99     | 127.99     | 127.99     |   0.0 | 99.75
Neigh   | 0.15985    | 0.15985    | 0.15985    |   0.0 |  0.12
Comm    | 0.024925   | 0.024925   | 0.024925   |   0.0 |  0.02
Output  | 5.6346e-05 | 5.6346e-05 | 5.6346e-05 |   0.0 |  0.00
Modify  | 0.12288    | 0.12288    | 0.12288    |   0.0 |  0.10
Other   |            | 0.01054    |            |       |  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:       538830 ave      538830 max      538830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538830
Ave neighs/atom = 134.7075
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 = 333.347782501965, Press = 0.602871418637148
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   
     62000  -5864.2363     -5864.2363     -6036.1995     -6036.1995      332.67456      332.67456      95008.642      95008.642      579.52326      579.52326    
     63000  -5863.5483     -5863.5483     -6032.6165     -6032.6165      327.07394      327.07394      95393.424      95393.424     -431.88647     -431.88647    
Loop time of 128.262 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.628 hours/ns, 7.797 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.93     | 127.93     | 127.93     |   0.0 | 99.74
Neigh   | 0.17702    | 0.17702    | 0.17702    |   0.0 |  0.14
Comm    | 0.024982   | 0.024982   | 0.024982   |   0.0 |  0.02
Output  | 6.7787e-05 | 6.7787e-05 | 6.7787e-05 |   0.0 |  0.00
Modify  | 0.12314    | 0.12314    | 0.12314    |   0.0 |  0.10
Other   |            | 0.01059    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6229 ave        6229 max        6229 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:       538090 ave      538090 max      538090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538090
Ave neighs/atom = 134.5225
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"
jump SELF break

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0