# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.620386697351933*${_u_distance}
variable latticeconst_converted equal 3.620386697351933*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.62038669735193
Lattice spacing in x,y,z = 3.6203867 3.6203867 3.6203867
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.203867 36.203867 36.203867)
  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 (36.203867 36.203867 36.203867)
  create_atoms CPU = 0.007 seconds

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

kim_interactions Cu

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

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


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_390178379548_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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14008.467     -14008.467     -14160         -14160          293.15         293.15         47453.132      47453.132      3410.8486      3410.8486    
      1000  -13845.958     -13845.958     -14003.802     -14003.802      305.36028      305.36028      48207.383      48207.383     -2717.767      -2717.767     
Loop time of 194.071 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.909 hours/ns, 5.153 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.16     | 193.16     | 193.16     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14626    | 0.14626    | 0.14626    |   0.0 |  0.08
Output  | 0.00024929 | 0.00024929 | 0.00024929 |   0.0 |  0.00
Modify  | 0.66624    | 0.66624    | 0.66624    |   0.0 |  0.34
Other   |            | 0.09483    |            |       |  0.05

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

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13845.958     -13845.958     -14003.802     -14003.802      305.36028      305.36028      48207.383      48207.383     -2717.767      -2717.767     
      2000  -13857.951     -13857.951     -14013.039     -14013.039      300.02884      300.02884      48087.375      48087.375      83.714708      83.714708    
Loop time of 206.186 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.274 hours/ns, 4.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.28     | 205.28     | 205.28     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14514    | 0.14514    | 0.14514    |   0.0 |  0.07
Output  | 0.00029956 | 0.00029956 | 0.00029956 |   0.0 |  0.00
Modify  | 0.66895    | 0.66895    | 0.66895    |   0.0 |  0.32
Other   |            | 0.09614    |            |       |  0.05

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

Total # of neighbors = 310740
Ave neighs/atom = 77.685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13857.951     -13857.951     -14013.039     -14013.039      300.02884      300.02884      48087.375      48087.375      83.714708      83.714708    
      3000  -13852.148     -13852.148     -14008.734     -14008.734      302.92583      302.92583      48126.288      48126.288     -552.07808     -552.07808    
Loop time of 235.584 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.440 hours/ns, 4.245 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.5      | 234.5      | 234.5      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16266    | 0.16266    | 0.16266    |   0.0 |  0.07
Output  | 0.00023251 | 0.00023251 | 0.00023251 |   0.0 |  0.00
Modify  | 0.81161    | 0.81161    | 0.81161    |   0.0 |  0.34
Other   |            | 0.1062     |            |       |  0.05

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

Total # of neighbors = 311132
Ave neighs/atom = 77.783
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13852.148     -13852.148     -14008.734     -14008.734      302.92583      302.92583      48126.288      48126.288     -552.07808     -552.07808    
      4000  -13856.434     -13856.434     -14009.051     -14009.051      295.24884      295.24884      48126.144      48126.144     -681.09484     -681.09484    
Loop time of 235.113 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.309 hours/ns, 4.253 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.05     | 234.05     | 234.05     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16101    | 0.16101    | 0.16101    |   0.0 |  0.07
Output  | 0.00027312 | 0.00027312 | 0.00027312 |   0.0 |  0.00
Modify  | 0.79721    | 0.79721    | 0.79721    |   0.0 |  0.34
Other   |            | 0.1054     |            |       |  0.04

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

Total # of neighbors = 310906
Ave neighs/atom = 77.7265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13856.434     -13856.434     -14009.051     -14009.051      295.24884      295.24884      48126.144      48126.144     -681.09484     -681.09484    
      5000  -13855.18      -13855.18      -14009.555     -14009.555      298.64876      298.64876      48070.68       48070.68       877.21139      877.21139    
Loop time of 204.398 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.777 hours/ns, 4.892 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.48     | 203.48     | 203.48     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14389    | 0.14389    | 0.14389    |   0.0 |  0.07
Output  | 0.00018924 | 0.00018924 | 0.00018924 |   0.0 |  0.00
Modify  | 0.67421    | 0.67421    | 0.67421    |   0.0 |  0.33
Other   |            | 0.09678    |            |       |  0.05

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

Total # of neighbors = 310916
Ave neighs/atom = 77.729
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 296.64975474448, Press = -156.133178065837
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13855.18      -13855.18      -14009.555     -14009.555      298.64876      298.64876      48070.68       48070.68       877.21139      877.21139    
      6000  -13852.799     -13852.799     -14006.413     -14006.413      297.17565      297.17565      48191.171      48191.171     -2199.2176     -2199.2176    
Loop time of 204.904 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.918 hours/ns, 4.880 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.96     | 203.96     | 203.96     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14286    | 0.14286    | 0.14286    |   0.0 |  0.07
Output  | 0.00019214 | 0.00019214 | 0.00019214 |   0.0 |  0.00
Modify  | 0.69712    | 0.69712    | 0.69712    |   0.0 |  0.34
Other   |            | 0.09933    |            |       |  0.05

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

Total # of neighbors = 310908
Ave neighs/atom = 77.727
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.622748965349, Press = -29.5232328517232
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13852.799     -13852.799     -14006.413     -14006.413      297.17565      297.17565      48191.171      48191.171     -2199.2176     -2199.2176    
      7000  -13858.721     -13858.721     -14008.886     -14008.886      290.50393      290.50393      48051.903      48051.903      1442.1866      1442.1866    
Loop time of 200.483 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.690 hours/ns, 4.988 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.56     | 199.56     | 199.56     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14545    | 0.14545    | 0.14545    |   0.0 |  0.07
Output  | 0.00023948 | 0.00023948 | 0.00023948 |   0.0 |  0.00
Modify  | 0.67967    | 0.67967    | 0.67967    |   0.0 |  0.34
Other   |            | 0.09455    |            |       |  0.05

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

Total # of neighbors = 310946
Ave neighs/atom = 77.7365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.078664709268, Press = 23.7583314893872
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13858.721     -13858.721     -14008.886     -14008.886      290.50393      290.50393      48051.903      48051.903      1442.1866      1442.1866    
      8000  -13850.881     -13850.881     -14004.559     -14004.559      297.30118      297.30118      48127.784      48127.784     -231.45886     -231.45886    
Loop time of 200.453 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.682 hours/ns, 4.989 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.54     | 199.54     | 199.54     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14323    | 0.14323    | 0.14323    |   0.0 |  0.07
Output  | 0.00023281 | 0.00023281 | 0.00023281 |   0.0 |  0.00
Modify  | 0.67858    | 0.67858    | 0.67858    |   0.0 |  0.34
Other   |            | 0.09474    |            |       |  0.05

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

Total # of neighbors = 311136
Ave neighs/atom = 77.784
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.306029184408, Press = -15.0738292797344
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13850.881     -13850.881     -14004.559     -14004.559      297.30118      297.30118      48127.784      48127.784     -231.45886     -231.45886    
      9000  -13855.058     -13855.058     -14005.002     -14005.002      290.07667      290.07667      48120.883      48120.883     -248.97451     -248.97451    
Loop time of 200.245 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.624 hours/ns, 4.994 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.33     | 199.33     | 199.33     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14579    | 0.14579    | 0.14579    |   0.0 |  0.07
Output  | 0.00019436 | 0.00019436 | 0.00019436 |   0.0 |  0.00
Modify  | 0.67982    | 0.67982    | 0.67982    |   0.0 |  0.34
Other   |            | 0.09364    |            |       |  0.05

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

Total # of neighbors = 310742
Ave neighs/atom = 77.6855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.427142181958, Press = 4.65403597101004
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13855.058     -13855.058     -14005.002     -14005.002      290.07667      290.07667      48120.883      48120.883     -248.97451     -248.97451    
     10000  -13855.333     -13855.333     -14006.755     -14006.755      292.93566      292.93566      48099.503      48099.503      265.15677      265.15677    
Loop time of 200.183 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.607 hours/ns, 4.995 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.26     | 199.26     | 199.26     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14504    | 0.14504    | 0.14504    |   0.0 |  0.07
Output  | 0.00019448 | 0.00019448 | 0.00019448 |   0.0 |  0.00
Modify  | 0.67904    | 0.67904    | 0.67904    |   0.0 |  0.34
Other   |            | 0.09434    |            |       |  0.05

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

Total # of neighbors = 310804
Ave neighs/atom = 77.701
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.65323514044, Press = -3.90911328570083
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13855.333     -13855.333     -14006.755     -14006.755      292.93566      292.93566      48099.503      48099.503      265.15677      265.15677    
     11000  -13849.271     -13849.271     -14006.978     -14006.978      305.09372      305.09372      48158.197      48158.197     -1322.1817     -1322.1817    
Loop time of 200.291 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.636 hours/ns, 4.993 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.37     | 199.37     | 199.37     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14506    | 0.14506    | 0.14506    |   0.0 |  0.07
Output  | 0.00019207 | 0.00019207 | 0.00019207 |   0.0 |  0.00
Modify  | 0.67802    | 0.67802    | 0.67802    |   0.0 |  0.34
Other   |            | 0.09412    |            |       |  0.05

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

Total # of neighbors = 310976
Ave neighs/atom = 77.744
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.671481279591, Press = 1.77157820809222
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13849.271     -13849.271     -14006.978     -14006.978      305.09372      305.09372      48158.197      48158.197     -1322.1817     -1322.1817    
     12000  -13855.801     -13855.801     -14009.941     -14009.941      298.19397      298.19397      48038.573      48038.573      1809.6466      1809.6466    
Loop time of 200.608 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.724 hours/ns, 4.985 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.69     | 199.69     | 199.69     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14525    | 0.14525    | 0.14525    |   0.0 |  0.07
Output  | 0.00019301 | 0.00019301 | 0.00019301 |   0.0 |  0.00
Modify  | 0.67878    | 0.67878    | 0.67878    |   0.0 |  0.34
Other   |            | 0.09387    |            |       |  0.05

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

Total # of neighbors = 310904
Ave neighs/atom = 77.726
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.867048674679, Press = -0.507067284027507
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13855.801     -13855.801     -14009.941     -14009.941      298.19397      298.19397      48038.573      48038.573      1809.6466      1809.6466    
     13000  -13853.503     -13853.503     -14005.738     -14005.738      294.50977      294.50977      48184.759      48184.759     -2049.1177     -2049.1177    
Loop time of 235.31 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.364 hours/ns, 4.250 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.2      | 234.2      | 234.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16272    | 0.16272    | 0.16272    |   0.0 |  0.07
Output  | 0.00019037 | 0.00019037 | 0.00019037 |   0.0 |  0.00
Modify  | 0.84394    | 0.84394    | 0.84394    |   0.0 |  0.36
Other   |            | 0.1071     |            |       |  0.05

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

Total # of neighbors = 311164
Ave neighs/atom = 77.791
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.710884673851, Press = -4.73903529337362
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13853.503     -13853.503     -14005.738     -14005.738      294.50977      294.50977      48184.759      48184.759     -2049.1177     -2049.1177    
     14000  -13859.249     -13859.249     -14009.047     -14009.047      289.79296      289.79296      48076.938      48076.938      770.5747       770.5747     
Loop time of 235.047 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.368 ns/day, 65.291 hours/ns, 4.254 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.95     | 233.95     | 233.95     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16082    | 0.16082    | 0.16082    |   0.0 |  0.07
Output  | 0.00058119 | 0.00058119 | 0.00058119 |   0.0 |  0.00
Modify  | 0.83003    | 0.83003    | 0.83003    |   0.0 |  0.35
Other   |            | 0.1056     |            |       |  0.04

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

Total # of neighbors = 310830
Ave neighs/atom = 77.7075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.693161992893, Press = 2.96464189246678
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13859.249     -13859.249     -14009.047     -14009.047      289.79296      289.79296      48076.938      48076.938      770.5747       770.5747     
     15000  -13852.529     -13852.529     -14006.31      -14006.31       297.49932      297.49932      48110.416      48110.416      79.910053      79.910053    
Loop time of 233.993 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 64.998 hours/ns, 4.274 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.86     | 232.86     | 232.86     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16394    | 0.16394    | 0.16394    |   0.0 |  0.07
Output  | 0.00023694 | 0.00023694 | 0.00023694 |   0.0 |  0.00
Modify  | 0.86335    | 0.86335    | 0.86335    |   0.0 |  0.37
Other   |            | 0.1083     |            |       |  0.05

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

Total # of neighbors = 311028
Ave neighs/atom = 77.757
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.569901085637, Press = -3.05497782048786
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13852.529     -13852.529     -14006.31      -14006.31       297.49932      297.49932      48110.416      48110.416      79.910053      79.910053    
     16000  -13857.92      -13857.92      -14008.496     -14008.496      291.29919      291.29919      48142.648      48142.648     -1111.3729     -1111.3729    
Loop time of 234.155 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.043 hours/ns, 4.271 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.03     | 233.03     | 233.03     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1612     | 0.1612     | 0.1612     |   0.0 |  0.07
Output  | 0.00029085 | 0.00029085 | 0.00029085 |   0.0 |  0.00
Modify  | 0.85378    | 0.85378    | 0.85378    |   0.0 |  0.36
Other   |            | 0.1074     |            |       |  0.05

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

Total # of neighbors = 310974
Ave neighs/atom = 77.7435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.451862783202, Press = 1.80894924120875
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13857.92      -13857.92      -14008.496     -14008.496      291.29919      291.29919      48142.648      48142.648     -1111.3729     -1111.3729    
     17000  -13852.673     -13852.673     -14006.35      -14006.35       297.29829      297.29829      48054.74       48054.74       1729.7564      1729.7564    
Loop time of 234.156 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.043 hours/ns, 4.271 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.04     | 233.04     | 233.04     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16185    | 0.16185    | 0.16185    |   0.0 |  0.07
Output  | 0.00019256 | 0.00019256 | 0.00019256 |   0.0 |  0.00
Modify  | 0.84704    | 0.84704    | 0.84704    |   0.0 |  0.36
Other   |            | 0.1071     |            |       |  0.05

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

Total # of neighbors = 310958
Ave neighs/atom = 77.7395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.427608555028, Press = -0.796535856710868
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13852.673     -13852.673     -14006.35      -14006.35       297.29829      297.29829      48054.74       48054.74       1729.7564      1729.7564    
     18000  -13856.476     -13856.476     -14007.805     -14007.805      292.75597      292.75597      48181.497      48181.497     -2087.8682     -2087.8682    
Loop time of 234.404 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.112 hours/ns, 4.266 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.26     | 233.26     | 233.26     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16457    | 0.16457    | 0.16457    |   0.0 |  0.07
Output  | 0.00019314 | 0.00019314 | 0.00019314 |   0.0 |  0.00
Modify  | 0.87172    | 0.87172    | 0.87172    |   0.0 |  0.37
Other   |            | 0.1085     |            |       |  0.05

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

Total # of neighbors = 311024
Ave neighs/atom = 77.756
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.421317230637, Press = -1.76261468613322
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13856.476     -13856.476     -14007.805     -14007.805      292.75597      292.75597      48181.497      48181.497     -2087.8682     -2087.8682    
     19000  -13856.285     -13856.285     -14008.319     -14008.319      294.121        294.121        48073.326      48073.326      1029.1672      1029.1672    
Loop time of 224.865 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.462 hours/ns, 4.447 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    | 223.82     | 223.82     | 223.82     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15436    | 0.15436    | 0.15436    |   0.0 |  0.07
Output  | 0.00026908 | 0.00026908 | 0.00026908 |   0.0 |  0.00
Modify  | 0.78644    | 0.78644    | 0.78644    |   0.0 |  0.35
Other   |            | 0.1039     |            |       |  0.05

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

Total # of neighbors = 310864
Ave neighs/atom = 77.716
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.479686865559, Press = 1.38005768659277
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13856.285     -13856.285     -14008.319     -14008.319      294.121        294.121        48073.326      48073.326      1029.1672      1029.1672    
     20000  -13854.328     -13854.328     -14004.408     -14004.408      290.34008      290.34008      48110.343      48110.343      211.65349      211.65349    
Loop time of 227.862 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.295 hours/ns, 4.389 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    | 226.78     | 226.78     | 226.78     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15947    | 0.15947    | 0.15947    |   0.0 |  0.07
Output  | 0.00018969 | 0.00018969 | 0.00018969 |   0.0 |  0.00
Modify  | 0.82095    | 0.82095    | 0.82095    |   0.0 |  0.36
Other   |            | 0.1055     |            |       |  0.05

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

Total # of neighbors = 311076
Ave neighs/atom = 77.769
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.442408755526, Press = -1.75282463258937
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13854.328     -13854.328     -14004.408     -14004.408      290.34008      290.34008      48110.343      48110.343      211.65349      211.65349    
     21000  -13858.277     -13858.277     -14004.775     -14004.775      283.40991      283.40991      48110.601      48110.601      83.345893      83.345893    
Loop time of 235.23 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.342 hours/ns, 4.251 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    | 234.11     | 234.11     | 234.11     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16206    | 0.16206    | 0.16206    |   0.0 |  0.07
Output  | 0.00019393 | 0.00019393 | 0.00019393 |   0.0 |  0.00
Modify  | 0.84701    | 0.84701    | 0.84701    |   0.0 |  0.36
Other   |            | 0.1073     |            |       |  0.05

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

Total # of neighbors = 310972
Ave neighs/atom = 77.743
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.54194859302, Press = 0.401639200067624
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13858.277     -13858.277     -14004.775     -14004.775      283.40991      283.40991      48110.601      48110.601      83.345893      83.345893    
     22000  -13849.841     -13849.841     -14004.947     -14004.947      300.06169      300.06169      48090.636      48090.636      854.73479      854.73479    
Loop time of 235.203 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.334 hours/ns, 4.252 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    | 234.1      | 234.1      | 234.1      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16198    | 0.16198    | 0.16198    |   0.0 |  0.07
Output  | 0.00019499 | 0.00019499 | 0.00019499 |   0.0 |  0.00
Modify  | 0.8332     | 0.8332     | 0.8332     |   0.0 |  0.35
Other   |            | 0.1068     |            |       |  0.05

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

Total # of neighbors = 310958
Ave neighs/atom = 77.7395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.543559230529, Press = -1.11278829635078
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13849.841     -13849.841     -14004.947     -14004.947      300.06169      300.06169      48090.636      48090.636      854.73479      854.73479    
     23000  -13855.49      -13855.49      -14006.562     -14006.562      292.26009      292.26009      48222.849      48222.849     -3199.3619     -3199.3619    
Loop time of 235.852 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.514 hours/ns, 4.240 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    | 234.75     | 234.75     | 234.75     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16194    | 0.16194    | 0.16194    |   0.0 |  0.07
Output  | 0.00024301 | 0.00024301 | 0.00024301 |   0.0 |  0.00
Modify  | 0.83576    | 0.83576    | 0.83576    |   0.0 |  0.35
Other   |            | 0.1067     |            |       |  0.05

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

Total # of neighbors = 310868
Ave neighs/atom = 77.717
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.564013808941, Press = 1.39742936906378
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13855.49      -13855.49      -14006.562     -14006.562      292.26009      292.26009      48222.849      48222.849     -3199.3619     -3199.3619    
     24000  -13853.071     -13853.071     -14007.158     -14007.158      298.09275      298.09275      48043.244      48043.244      2029.3241      2029.3241    
Loop time of 222.625 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.840 hours/ns, 4.492 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    | 221.6      | 221.6      | 221.6      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15487    | 0.15487    | 0.15487    |   0.0 |  0.07
Output  | 0.00019311 | 0.00019311 | 0.00019311 |   0.0 |  0.00
Modify  | 0.76791    | 0.76791    | 0.76791    |   0.0 |  0.34
Other   |            | 0.1023     |            |       |  0.05

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

Total # of neighbors = 310928
Ave neighs/atom = 77.732
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.592072226614, Press = 0.0647116469229598
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13853.071     -13853.071     -14007.158     -14007.158      298.09275      298.09275      48043.244      48043.244      2029.3241      2029.3241    
     25000  -13858.283     -13858.283     -14009.188     -14009.188      291.93572      291.93572      48149.099      48149.099     -1308.3718     -1308.3718    
Loop time of 199.225 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.340 hours/ns, 5.019 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.32     | 198.32     | 198.32     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14169    | 0.14169    | 0.14169    |   0.0 |  0.07
Output  | 0.00018983 | 0.00018983 | 0.00018983 |   0.0 |  0.00
Modify  | 0.67315    | 0.67315    | 0.67315    |   0.0 |  0.34
Other   |            | 0.09393    |            |       |  0.05

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

Total # of neighbors = 310998
Ave neighs/atom = 77.7495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.529610437845, Press = -1.15315057683663
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13858.283     -13858.283     -14009.188     -14009.188      291.93572      291.93572      48149.099      48149.099     -1308.3718     -1308.3718    
     26000  -13851.46      -13851.46      -14005.387     -14005.387      297.78119      297.78119      48098.631      48098.631      527.51228      527.51228    
Loop time of 203.863 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.629 hours/ns, 4.905 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.93     | 202.93     | 202.93     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14441    | 0.14441    | 0.14441    |   0.0 |  0.07
Output  | 0.00019874 | 0.00019874 | 0.00019874 |   0.0 |  0.00
Modify  | 0.69418    | 0.69418    | 0.69418    |   0.0 |  0.34
Other   |            | 0.09496    |            |       |  0.05

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

Total # of neighbors = 311030
Ave neighs/atom = 77.7575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.505134843829, Press = 0.851845035131914
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13851.46      -13851.46      -14005.387     -14005.387      297.78119      297.78119      48098.631      48098.631      527.51228      527.51228    
     27000  -13858.701     -13858.701     -14009.071     -14009.071      290.90101      290.90101      48110.426      48110.426     -234.74138     -234.74138    
Loop time of 229.437 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.733 hours/ns, 4.358 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.36     | 228.36     | 228.36     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16009    | 0.16009    | 0.16009    |   0.0 |  0.07
Output  | 0.00027024 | 0.00027024 | 0.00027024 |   0.0 |  0.00
Modify  | 0.8108     | 0.8108     | 0.8108     |   0.0 |  0.35
Other   |            | 0.1051     |            |       |  0.05

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

Total # of neighbors = 310998
Ave neighs/atom = 77.7495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.488710593113, Press = -1.72458738955686
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13858.701     -13858.701     -14009.071     -14009.071      290.90101      290.90101      48110.426      48110.426     -234.74138     -234.74138    
     28000  -13855.759     -13855.759     -14006.81      -14006.81       292.21915      292.21915      48122.373      48122.373     -278.88415     -278.88415    
Loop time of 234.349 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.097 hours/ns, 4.267 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.24     | 233.24     | 233.24     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16349    | 0.16349    | 0.16349    |   0.0 |  0.07
Output  | 0.00025823 | 0.00025823 | 0.00025823 |   0.0 |  0.00
Modify  | 0.84007    | 0.84007    | 0.84007    |   0.0 |  0.36
Other   |            | 0.107      |            |       |  0.05

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

Total # of neighbors = 311054
Ave neighs/atom = 77.7635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.507250987919, Press = 1.62240128086941
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13855.759     -13855.759     -14006.81      -14006.81       292.21915      292.21915      48122.373      48122.373     -278.88415     -278.88415    
     29000  -13849.173     -13849.173     -14002.64      -14002.64       296.89284      296.89284      48051.161      48051.161      2235.2249      2235.2249    
Loop time of 235.152 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.320 hours/ns, 4.253 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.05     | 234.05     | 234.05     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16266    | 0.16266    | 0.16266    |   0.0 |  0.07
Output  | 0.00025178 | 0.00025178 | 0.00025178 |   0.0 |  0.00
Modify  | 0.83329    | 0.83329    | 0.83329    |   0.0 |  0.35
Other   |            | 0.1063     |            |       |  0.05

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

Total # of neighbors = 311044
Ave neighs/atom = 77.761
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.523620150846, Press = -2.20569109637339
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13849.173     -13849.173     -14002.64      -14002.64       296.89284      296.89284      48051.161      48051.161      2235.2249      2235.2249    
     30000  -13855.317     -13855.317     -14005.511     -14005.511      290.55989      290.55989      48170.444      48170.444     -1702.768      -1702.768     
Loop time of 235.305 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.362 hours/ns, 4.250 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.2      | 234.2      | 234.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16205    | 0.16205    | 0.16205    |   0.0 |  0.07
Output  | 0.00025532 | 0.00025532 | 0.00025532 |   0.0 |  0.00
Modify  | 0.83332    | 0.83332    | 0.83332    |   0.0 |  0.35
Other   |            | 0.106      |            |       |  0.05

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

Total # of neighbors = 311010
Ave neighs/atom = 77.7525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.540374769977, Press = 0.285927706194222
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13855.317     -13855.317     -14005.511     -14005.511      290.55989      290.55989      48170.444      48170.444     -1702.768      -1702.768     
     31000  -13849.365     -13849.365     -14003.365     -14003.365      297.92447      297.92447      48077.862      48077.862      1364.1625      1364.1625    
Loop time of 235.662 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.462 hours/ns, 4.243 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.55     | 234.55     | 234.55     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16367    | 0.16367    | 0.16367    |   0.0 |  0.07
Output  | 0.00019671 | 0.00019671 | 0.00019671 |   0.0 |  0.00
Modify  | 0.84541    | 0.84541    | 0.84541    |   0.0 |  0.36
Other   |            | 0.1072     |            |       |  0.05

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

Total # of neighbors = 310888
Ave neighs/atom = 77.722
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.625466283968, Press = 0.159069556775401
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13849.365     -13849.365     -14003.365     -14003.365      297.92447      297.92447      48077.862      48077.862      1364.1625      1364.1625    
     32000  -13854.189     -13854.189     -14007.537     -14007.537      296.66289      296.66289      48155.968      48155.968     -1360.9301     -1360.9301    
Loop time of 218.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.811 hours/ns, 4.568 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 217.89     | 217.89     | 217.89     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15291    | 0.15291    | 0.15291    |   0.0 |  0.07
Output  | 0.0001956  | 0.0001956  | 0.0001956  |   0.0 |  0.00
Modify  | 0.77303    | 0.77303    | 0.77303    |   0.0 |  0.35
Other   |            | 0.103      |            |       |  0.05

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

Total # of neighbors = 310922
Ave neighs/atom = 77.7305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.610497318976, Press = -0.715598980168454
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13854.189     -13854.189     -14007.537     -14007.537      296.66289      296.66289      48155.968      48155.968     -1360.9301     -1360.9301    
     33000  -13858.357     -13858.357     -14010.319     -14010.319      293.98107      293.98107      48082.026      48082.026      490.30307      490.30307    
Loop time of 235.819 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.505 hours/ns, 4.241 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    | 234.71     | 234.71     | 234.71     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16475    | 0.16475    | 0.16475    |   0.0 |  0.07
Output  | 0.00019934 | 0.00019934 | 0.00019934 |   0.0 |  0.00
Modify  | 0.84069    | 0.84069    | 0.84069    |   0.0 |  0.36
Other   |            | 0.1079     |            |       |  0.05

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

Total # of neighbors = 310952
Ave neighs/atom = 77.738
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.575984422179, Press = 1.11819831221302
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13858.357     -13858.357     -14010.319     -14010.319      293.98107      293.98107      48082.026      48082.026      490.30307      490.30307    
     34000  -13856.099     -13856.099     -14010.213     -14010.213      298.14559      298.14559      48116.497      48116.497     -417.75124     -417.75124    
Loop time of 235.674 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.465 hours/ns, 4.243 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    | 234.57     | 234.57     | 234.57     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16284    | 0.16284    | 0.16284    |   0.0 |  0.07
Output  | 0.00025227 | 0.00025227 | 0.00025227 |   0.0 |  0.00
Modify  | 0.8311     | 0.8311     | 0.8311     |   0.0 |  0.35
Other   |            | 0.1074     |            |       |  0.05

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

Total # of neighbors = 311030
Ave neighs/atom = 77.7575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.533013203657, Press = -1.77954127070025
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13856.099     -13856.099     -14010.213     -14010.213      298.14559      298.14559      48116.497      48116.497     -417.75124     -417.75124    
     35000  -13855.406     -13855.406     -14006.658     -14006.658      292.60684      292.60684      48134.52       48134.52      -642.0918      -642.0918     
Loop time of 235.728 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.480 hours/ns, 4.242 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    | 234.61     | 234.61     | 234.61     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16488    | 0.16488    | 0.16488    |   0.0 |  0.07
Output  | 0.00019416 | 0.00019416 | 0.00019416 |   0.0 |  0.00
Modify  | 0.84371    | 0.84371    | 0.84371    |   0.0 |  0.36
Other   |            | 0.1084     |            |       |  0.05

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

Total # of neighbors = 311098
Ave neighs/atom = 77.7745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.544785249255, Press = 2.93254454741977
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13855.406     -13855.406     -14006.658     -14006.658      292.60684      292.60684      48134.52       48134.52      -642.0918      -642.0918     
     36000  -13857.359     -13857.359     -14006.481     -14006.481      288.48683      288.48683      48076.039      48076.039      971.06428      971.06428    
Loop time of 228.062 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.351 hours/ns, 4.385 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.99     | 226.99     | 226.99     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16127    | 0.16127    | 0.16127    |   0.0 |  0.07
Output  | 0.00019784 | 0.00019784 | 0.00019784 |   0.0 |  0.00
Modify  | 0.80926    | 0.80926    | 0.80926    |   0.0 |  0.35
Other   |            | 0.105      |            |       |  0.05

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

Total # of neighbors = 310882
Ave neighs/atom = 77.7205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.449192430161, Press = -0.764929902252671
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13857.359     -13857.359     -14006.481     -14006.481      288.48683      288.48683      48076.039      48076.039      971.06428      971.06428    
     37000  -13853.42      -13853.42      -14005.031     -14005.031      293.30237      293.30237      48136.372      48136.372     -543.00878     -543.00878    
Loop time of 199.486 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.413 hours/ns, 5.013 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.58     | 198.58     | 198.58     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13939    | 0.13939    | 0.13939    |   0.0 |  0.07
Output  | 0.0001945  | 0.0001945  | 0.0001945  |   0.0 |  0.00
Modify  | 0.67528    | 0.67528    | 0.67528    |   0.0 |  0.34
Other   |            | 0.0954     |            |       |  0.05

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

Total # of neighbors = 310928
Ave neighs/atom = 77.732
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.441838551247, Press = 0.526763891351179
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13853.42      -13853.42      -14005.031     -14005.031      293.30237      293.30237      48136.372      48136.372     -543.00878     -543.00878    
     38000  -13854.636     -13854.636     -14007.902     -14007.902      296.50284      296.50284      48087.691      48087.691      604.94165      604.94165    
Loop time of 213.357 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.266 hours/ns, 4.687 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    | 212.37     | 212.37     | 212.37     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14824    | 0.14824    | 0.14824    |   0.0 |  0.07
Output  | 0.00019418 | 0.00019418 | 0.00019418 |   0.0 |  0.00
Modify  | 0.74212    | 0.74212    | 0.74212    |   0.0 |  0.35
Other   |            | 0.101      |            |       |  0.05

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

Total # of neighbors = 310874
Ave neighs/atom = 77.7185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.42596620158, Press = -0.372716381537903
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13854.636     -13854.636     -14007.902     -14007.902      296.50284      296.50284      48087.691      48087.691      604.94165      604.94165    
     39000  -13859.76      -13859.76      -14007.631     -14007.631      286.06703      286.06703      48190.319      48190.319     -2373.44       -2373.44      
Loop time of 199.521 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.423 hours/ns, 5.012 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.61     | 198.61     | 198.61     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14242    | 0.14242    | 0.14242    |   0.0 |  0.07
Output  | 0.00019998 | 0.00019998 | 0.00019998 |   0.0 |  0.00
Modify  | 0.67663    | 0.67663    | 0.67663    |   0.0 |  0.34
Other   |            | 0.09313    |            |       |  0.05

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

Total # of neighbors = 311038
Ave neighs/atom = 77.7595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.384944395929, Press = 0.748718939721989
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13859.76      -13859.76      -14007.631     -14007.631      286.06703      286.06703      48190.319      48190.319     -2373.44       -2373.44      
     40000  -13854.885     -13854.885     -14009.24      -14009.24       298.61072      298.61072      48003.592      48003.592      2999.5593      2999.5593    
Loop time of 215.399 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.401 ns/day, 59.833 hours/ns, 4.643 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 214.4      | 214.4      | 214.4      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15216    | 0.15216    | 0.15216    |   0.0 |  0.07
Output  | 0.00025061 | 0.00025061 | 0.00025061 |   0.0 |  0.00
Modify  | 0.74615    | 0.74615    | 0.74615    |   0.0 |  0.35
Other   |            | 0.09955    |            |       |  0.05

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

Total # of neighbors = 310924
Ave neighs/atom = 77.731
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.38323630188, Press = 0.115637787160412
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13854.885     -13854.885     -14009.24      -14009.24       298.61072      298.61072      48003.592      48003.592      2999.5593      2999.5593    
     41000  -13859.309     -13859.309     -14011.861     -14011.861      295.12045      295.12045      48159.317      48159.317     -1801.5824     -1801.5824    
Loop time of 234.975 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.368 ns/day, 65.271 hours/ns, 4.256 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.89     | 233.89     | 233.89     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16046    | 0.16046    | 0.16046    |   0.0 |  0.07
Output  | 0.00019273 | 0.00019273 | 0.00019273 |   0.0 |  0.00
Modify  | 0.8202     | 0.8202     | 0.8202     |   0.0 |  0.35
Other   |            | 0.1055     |            |       |  0.04

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

Total # of neighbors = 311144
Ave neighs/atom = 77.786
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.381557993758, Press = -0.266252494200642
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13859.309     -13859.309     -14011.861     -14011.861      295.12045      295.12045      48159.317      48159.317     -1801.5824     -1801.5824    
     42000  -13853.422     -13853.422     -14006.374     -14006.374      295.89507      295.89507      48088.608      48088.608      720.82192      720.82192    
Loop time of 234.401 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.111 hours/ns, 4.266 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.31     | 233.31     | 233.31     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16121    | 0.16121    | 0.16121    |   0.0 |  0.07
Output  | 0.00025222 | 0.00025222 | 0.00025222 |   0.0 |  0.00
Modify  | 0.82423    | 0.82423    | 0.82423    |   0.0 |  0.35
Other   |            | 0.1039     |            |       |  0.04

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

Total # of neighbors = 311128
Ave neighs/atom = 77.782
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.339147212991, Press = 1.38632960912456
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13853.422     -13853.422     -14006.374     -14006.374      295.89507      295.89507      48088.608      48088.608      720.82192      720.82192    
     43000  -13859.282     -13859.282     -14009.514     -14009.514      290.63431      290.63431      48088.693      48088.693      272.79953      272.79953    
Loop time of 234.258 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.072 hours/ns, 4.269 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.13     | 233.13     | 233.13     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16222    | 0.16222    | 0.16222    |   0.0 |  0.07
Output  | 0.00019434 | 0.00019434 | 0.00019434 |   0.0 |  0.00
Modify  | 0.85944    | 0.85944    | 0.85944    |   0.0 |  0.37
Other   |            | 0.106      |            |       |  0.05

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

Total # of neighbors = 310794
Ave neighs/atom = 77.6985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.292841415554, Press = -0.285077816826999
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13859.282     -13859.282     -14009.514     -14009.514      290.63431      290.63431      48088.693      48088.693      272.79953      272.79953    
     44000  -13855.278     -13855.278     -14006.513     -14006.513      292.57356      292.57356      48120.038      48120.038     -262.77353     -262.77353    
Loop time of 234.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.087 hours/ns, 4.268 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.17     | 233.17     | 233.17     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16526    | 0.16526    | 0.16526    |   0.0 |  0.07
Output  | 0.00023667 | 0.00023667 | 0.00023667 |   0.0 |  0.00
Modify  | 0.86855    | 0.86855    | 0.86855    |   0.0 |  0.37
Other   |            | 0.1087     |            |       |  0.05

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0