# 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.619999974966049*${_u_distance}
variable latticeconst_converted equal 3.619999974966049*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61999997496605
Lattice spacing in x,y,z = 3.62 3.62 3.62
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.2 36.2 36.2)
  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.2 36.2 36.2)
  create_atoms CPU = 0.004 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_EtesamiAsadi_2018_Cu__MO_227887284491_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 47437.9270158353    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47437.9270158353/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47437.9270158353/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 47437.9270158353/(1*1*${_u_distance})
variable      V0_metal equal 47437.9270158353/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 47437.9270158353*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47437.9270158353 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_227887284491_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  -14018.806     -14018.806     -14160         -14160          273.15         273.15         47437.927      47437.927      3179.1711      3179.1711    
      1000  -13867.232     -13867.232     -14007.82      -14007.82       271.97679      271.97679      48112.105      48112.105      543.42572      543.42572    
Loop time of 354.331 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.244 ns/day, 98.425 hours/ns, 2.822 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    | 353.35     | 353.35     | 353.35     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15479    | 0.15479    | 0.15479    |   0.0 |  0.04
Output  | 0.00037779 | 0.00037779 | 0.00037779 |   0.0 |  0.00
Modify  | 0.72432    | 0.72432    | 0.72432    |   0.0 |  0.20
Other   |            | 0.1022     |            |       |  0.03

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  -13867.232     -13867.232     -14007.82      -14007.82       271.97679      271.97679      48112.105      48112.105      543.42572      543.42572    
      2000  -13879.377     -13879.377     -14017.028     -14017.028      266.29485      266.29485      48085.192      48085.192      167.60693      167.60693    
Loop time of 379.221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.339 hours/ns, 2.637 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    | 378.21     | 378.21     | 378.21     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15674    | 0.15674    | 0.15674    |   0.0 |  0.04
Output  | 0.00026263 | 0.00026263 | 0.00026263 |   0.0 |  0.00
Modify  | 0.74503    | 0.74503    | 0.74503    |   0.0 |  0.20
Other   |            | 0.1042     |            |       |  0.03

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

Total # of neighbors = 310816
Ave neighs/atom = 77.704
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  -13879.377     -13879.377     -14017.028     -14017.028      266.29485      266.29485      48085.192      48085.192      167.60693      167.60693    
      3000  -13871.548     -13871.548     -14016.379     -14016.379      280.18466      280.18466      48110.538      48110.538     -138.01998     -138.01998    
Loop time of 382.863 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.351 hours/ns, 2.612 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    | 381.86     | 381.86     | 381.86     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15554    | 0.15554    | 0.15554    |   0.0 |  0.04
Output  | 0.00022721 | 0.00022721 | 0.00022721 |   0.0 |  0.00
Modify  | 0.74592    | 0.74592    | 0.74592    |   0.0 |  0.19
Other   |            | 0.1042     |            |       |  0.03

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

Total # of neighbors = 311014
Ave neighs/atom = 77.7535
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  -13871.548     -13871.548     -14016.379     -14016.379      280.18466      280.18466      48110.538      48110.538     -138.01998     -138.01998    
      4000  -13878.671     -13878.671     -14016.715     -14016.715      267.05445      267.05445      48094.097      48094.097     -33.749089     -33.749089    
Loop time of 381.237 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.899 hours/ns, 2.623 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    | 380.23     | 380.23     | 380.23     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15607    | 0.15607    | 0.15607    |   0.0 |  0.04
Output  | 0.00022978 | 0.00022978 | 0.00022978 |   0.0 |  0.00
Modify  | 0.74338    | 0.74338    | 0.74338    |   0.0 |  0.19
Other   |            | 0.1038     |            |       |  0.03

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

Total # of neighbors = 310960
Ave neighs/atom = 77.74
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  -13878.671     -13878.671     -14016.715     -14016.715      267.05445      267.05445      48094.097      48094.097     -33.749089     -33.749089    
      5000  -13873.535     -13873.535     -14014.271     -14014.271      272.26234      272.26234      48109.478      48109.478     -226.23122     -226.23122    
Loop time of 385.783 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.162 hours/ns, 2.592 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    | 384.76     | 384.76     | 384.76     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15877    | 0.15877    | 0.15877    |   0.0 |  0.04
Output  | 0.00018832 | 0.00018832 | 0.00018832 |   0.0 |  0.00
Modify  | 0.76381    | 0.76381    | 0.76381    |   0.0 |  0.20
Other   |            | 0.1044     |            |       |  0.03

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

Total # of neighbors = 311000
Ave neighs/atom = 77.75
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 = 277.607844482475, Press = -146.698146073707
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  -13873.535     -13873.535     -14014.271     -14014.271      272.26234      272.26234      48109.478      48109.478     -226.23122     -226.23122    
      6000  -13874.785     -13874.785     -14016.408     -14016.408      273.98045      273.98045      48061.173      48061.173      1086.6826      1086.6826    
Loop time of 383.898 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.638 hours/ns, 2.605 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    | 382.85     | 382.85     | 382.85     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15931    | 0.15931    | 0.15931    |   0.0 |  0.04
Output  | 0.00018596 | 0.00018596 | 0.00018596 |   0.0 |  0.00
Modify  | 0.78223    | 0.78223    | 0.78223    |   0.0 |  0.20
Other   |            | 0.1042     |            |       |  0.03

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 = 272.957766345829, Press = 54.9249858979229
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  -13874.785     -13874.785     -14016.408     -14016.408      273.98045      273.98045      48061.173      48061.173      1086.6826      1086.6826    
      7000  -13877.2       -13877.2       -14019.643     -14019.643      275.56506      275.56506      48018.848      48018.848      2008.7528      2008.7528    
Loop time of 387.239 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.566 hours/ns, 2.582 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    | 386.18     | 386.18     | 386.18     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16013    | 0.16013    | 0.16013    |   0.0 |  0.04
Output  | 0.00018654 | 0.00018654 | 0.00018654 |   0.0 |  0.00
Modify  | 0.79649    | 0.79649    | 0.79649    |   0.0 |  0.21
Other   |            | 0.1048     |            |       |  0.03

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

Total # of neighbors = 311078
Ave neighs/atom = 77.7695
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 = 273.304897640097, Press = -12.7522989146177
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  -13877.2       -13877.2       -14019.643     -14019.643      275.56506      275.56506      48018.848      48018.848      2008.7528      2008.7528    
      8000  -13875.047     -13875.047     -14016.287     -14016.287      273.23967      273.23967      48119.772      48119.772     -645.18444     -645.18444    
Loop time of 388.336 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.871 hours/ns, 2.575 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    | 387.29     | 387.29     | 387.29     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15874    | 0.15874    | 0.15874    |   0.0 |  0.04
Output  | 0.00018763 | 0.00018763 | 0.00018763 |   0.0 |  0.00
Modify  | 0.78738    | 0.78738    | 0.78738    |   0.0 |  0.20
Other   |            | 0.1045     |            |       |  0.03

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

Total # of neighbors = 311138
Ave neighs/atom = 77.7845
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 = 273.049600110002, Press = -11.1444983289945
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  -13875.047     -13875.047     -14016.287     -14016.287      273.23967      273.23967      48119.772      48119.772     -645.18444     -645.18444    
      9000  -13876.742     -13876.742     -14017.043     -14017.043      271.42183      271.42183      48115.786      48115.786     -548.29117     -548.29117    
Loop time of 383.671 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.575 hours/ns, 2.606 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    | 382.63     | 382.63     | 382.63     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15853    | 0.15853    | 0.15853    |   0.0 |  0.04
Output  | 0.0001889  | 0.0001889  | 0.0001889  |   0.0 |  0.00
Modify  | 0.78036    | 0.78036    | 0.78036    |   0.0 |  0.20
Other   |            | 0.1047     |            |       |  0.03

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

Total # of neighbors = 310920
Ave neighs/atom = 77.73
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 = 273.0911371459, Press = 2.17988592546464
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  -13876.742     -13876.742     -14017.043     -14017.043      271.42183      271.42183      48115.786      48115.786     -548.29117     -548.29117    
     10000  -13879.133     -13879.133     -14020.7       -14020.7        273.87144      273.87144      48070.965      48070.965      355.50991      355.50991    
Loop time of 385.047 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.957 hours/ns, 2.597 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    | 383.99     | 383.99     | 383.99     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16014    | 0.16014    | 0.16014    |   0.0 |  0.04
Output  | 0.00019071 | 0.00019071 | 0.00019071 |   0.0 |  0.00
Modify  | 0.78981    | 0.78981    | 0.78981    |   0.0 |  0.21
Other   |            | 0.105      |            |       |  0.03

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

Total # of neighbors = 310902
Ave neighs/atom = 77.7255
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 = 273.044133943269, Press = 1.01022186251992
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  -13879.133     -13879.133     -14020.7       -14020.7        273.87144      273.87144      48070.965      48070.965      355.50991      355.50991    
     11000  -13874.53      -13874.53      -14016.317     -14016.317      274.29646      274.29646      48089.89       48089.89       221.57607      221.57607    
Loop time of 388.519 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.922 hours/ns, 2.574 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    | 387.46     | 387.46     | 387.46     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15963    | 0.15963    | 0.15963    |   0.0 |  0.04
Output  | 0.00018887 | 0.00018887 | 0.00018887 |   0.0 |  0.00
Modify  | 0.79046    | 0.79046    | 0.79046    |   0.0 |  0.20
Other   |            | 0.1043     |            |       |  0.03

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

Total # of neighbors = 311064
Ave neighs/atom = 77.766
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 = 272.798279039698, Press = -5.08968113776255
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  -13874.53      -13874.53      -14016.317     -14016.317      274.29646      274.29646      48089.89       48089.89       221.57607      221.57607    
     12000  -13877.445     -13877.445     -14018.004     -14018.004      271.92068      271.92068      48166.182      48166.182     -2158.4188     -2158.4188    
Loop time of 385.173 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.992 hours/ns, 2.596 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    | 384.12     | 384.12     | 384.12     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15774    | 0.15774    | 0.15774    |   0.0 |  0.04
Output  | 0.00019022 | 0.00019022 | 0.00019022 |   0.0 |  0.00
Modify  | 0.78554    | 0.78554    | 0.78554    |   0.0 |  0.20
Other   |            | 0.1046     |            |       |  0.03

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

Total # of neighbors = 310950
Ave neighs/atom = 77.7375
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 = 272.736671888326, Press = -1.15295416745199
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  -13877.445     -13877.445     -14018.004     -14018.004      271.92068      271.92068      48166.182      48166.182     -2158.4188     -2158.4188    
     13000  -13873.668     -13873.668     -14015.565     -14015.565      274.50988      274.50988      48110.066      48110.066     -343.8165      -343.8165     
Loop time of 384.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.942 hours/ns, 2.597 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    | 383.94     | 383.94     | 383.94     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15969    | 0.15969    | 0.15969    |   0.0 |  0.04
Output  | 0.00019246 | 0.00019246 | 0.00019246 |   0.0 |  0.00
Modify  | 0.78766    | 0.78766    | 0.78766    |   0.0 |  0.20
Other   |            | 0.1044     |            |       |  0.03

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

Total # of neighbors = 310890
Ave neighs/atom = 77.7225
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 = 272.808949685742, Press = 6.58917467352155
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  -13873.668     -13873.668     -14015.565     -14015.565      274.50988      274.50988      48110.066      48110.066     -343.8165      -343.8165     
     14000  -13883.191     -13883.191     -14021.805     -14021.805      268.15796      268.15796      48025.859      48025.859      1381.7226      1381.7226    
Loop time of 383.225 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.451 hours/ns, 2.609 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    | 382.19     | 382.19     | 382.19     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15716    | 0.15716    | 0.15716    |   0.0 |  0.04
Output  | 0.00050995 | 0.00050995 | 0.00050995 |   0.0 |  0.00
Modify  | 0.77489    | 0.77489    | 0.77489    |   0.0 |  0.20
Other   |            | 0.1041     |            |       |  0.03

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

Total # of neighbors = 310914
Ave neighs/atom = 77.7285
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 = 272.739219996193, Press = -0.813302494023741
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  -13883.191     -13883.191     -14021.805     -14021.805      268.15796      268.15796      48025.859      48025.859      1381.7226      1381.7226    
     15000  -13873.141     -13873.141     -14016.469     -14016.469      277.2777       277.2777       48094.245      48094.245      88.759927      88.759927    
Loop time of 385.028 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.952 hours/ns, 2.597 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    | 383.98     | 383.98     | 383.98     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1586     | 0.1586     | 0.1586     |   0.0 |  0.04
Output  | 0.00018844 | 0.00018844 | 0.00018844 |   0.0 |  0.00
Modify  | 0.78607    | 0.78607    | 0.78607    |   0.0 |  0.20
Other   |            | 0.1054     |            |       |  0.03

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

Total # of neighbors = 311094
Ave neighs/atom = 77.7735
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 = 272.663656144578, Press = -2.34233780042963
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  -13873.141     -13873.141     -14016.469     -14016.469      277.2777       277.2777       48094.245      48094.245      88.759927      88.759927    
     16000  -13876.204     -13876.204     -14017.177     -14017.177      272.72277      272.72277      48127.366      48127.366     -951.5118      -951.5118     
Loop time of 384.512 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.809 hours/ns, 2.601 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    | 383.47     | 383.47     | 383.47     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15721    | 0.15721    | 0.15721    |   0.0 |  0.04
Output  | 0.0001889  | 0.0001889  | 0.0001889  |   0.0 |  0.00
Modify  | 0.77906    | 0.77906    | 0.77906    |   0.0 |  0.20
Other   |            | 0.1046     |            |       |  0.03

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

Total # of neighbors = 310920
Ave neighs/atom = 77.73
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 = 272.58083612454, Press = -2.29229357005485
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  -13876.204     -13876.204     -14017.177     -14017.177      272.72277      272.72277      48127.366      48127.366     -951.5118      -951.5118     
     17000  -13872.41      -13872.41      -14012.558     -14012.558      271.12468      271.12468      48124.073      48124.073     -437.40232     -437.40232    
Loop time of 379.844 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.512 hours/ns, 2.633 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    | 378.81     | 378.81     | 378.81     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15641    | 0.15641    | 0.15641    |   0.0 |  0.04
Output  | 0.00023943 | 0.00023943 | 0.00023943 |   0.0 |  0.00
Modify  | 0.77695    | 0.77695    | 0.77695    |   0.0 |  0.20
Other   |            | 0.1038     |            |       |  0.03

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 = 272.607844023739, Press = 2.26749663607303
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  -13872.41      -13872.41      -14012.558     -14012.558      271.12468      271.12468      48124.073      48124.073     -437.40232     -437.40232    
     18000  -13880.517     -13880.517     -14021.778     -14021.778      273.28         273.28         48034.315      48034.315      1235.301       1235.301     
Loop time of 375.461 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.295 hours/ns, 2.663 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    | 374.45     | 374.45     | 374.45     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15589    | 0.15589    | 0.15589    |   0.0 |  0.04
Output  | 0.00033353 | 0.00033353 | 0.00033353 |   0.0 |  0.00
Modify  | 0.75713    | 0.75713    | 0.75713    |   0.0 |  0.20
Other   |            | 0.1022     |            |       |  0.03

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

Total # of neighbors = 310938
Ave neighs/atom = 77.7345
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 = 272.622093462145, Press = 1.91106350648897
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  -13880.517     -13880.517     -14021.778     -14021.778      273.28         273.28         48034.315      48034.315      1235.301       1235.301     
     19000  -13873.996     -13873.996     -14016.368     -14016.368      275.4286       275.4286       48065.848      48065.848      931.54723      931.54723    
Loop time of 382.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.160 hours/ns, 2.617 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    | 381.14     | 381.14     | 381.14     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15721    | 0.15721    | 0.15721    |   0.0 |  0.04
Output  | 0.00024144 | 0.00024144 | 0.00024144 |   0.0 |  0.00
Modify  | 0.77462    | 0.77462    | 0.77462    |   0.0 |  0.20
Other   |            | 0.104      |            |       |  0.03

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

Total # of neighbors = 311086
Ave neighs/atom = 77.7715
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 = 272.532324751444, Press = -2.4436588429455
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  -13873.996     -13873.996     -14016.368     -14016.368      275.4286       275.4286       48065.848      48065.848      931.54723      931.54723    
     20000  -13877.284     -13877.284     -14016.909     -14016.909      270.11312      270.11312      48112.107      48112.107     -544.50157     -544.50157    
Loop time of 381.085 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.857 hours/ns, 2.624 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    | 380.05     | 380.05     | 380.05     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15645    | 0.15645    | 0.15645    |   0.0 |  0.04
Output  | 0.00018983 | 0.00018983 | 0.00018983 |   0.0 |  0.00
Modify  | 0.7704     | 0.7704     | 0.7704     |   0.0 |  0.20
Other   |            | 0.1048     |            |       |  0.03

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

Total # of neighbors = 311014
Ave neighs/atom = 77.7535
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 = 272.572797582292, Press = -1.23182356225337
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  -13877.284     -13877.284     -14016.909     -14016.909      270.11312      270.11312      48112.107      48112.107     -544.50157     -544.50157    
     21000  -13872.417     -13872.417     -14015.224     -14015.224      276.26962      276.26962      48111.733      48111.733     -198.21676     -198.21676    
Loop time of 383.042 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.401 hours/ns, 2.611 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    | 382        | 382        | 382        |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15737    | 0.15737    | 0.15737    |   0.0 |  0.04
Output  | 0.00023818 | 0.00023818 | 0.00023818 |   0.0 |  0.00
Modify  | 0.78211    | 0.78211    | 0.78211    |   0.0 |  0.20
Other   |            | 0.1039     |            |       |  0.03

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

Total # of neighbors = 310884
Ave neighs/atom = 77.721
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 = 272.730273874343, Press = -0.294847878604888
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  -13872.417     -13872.417     -14015.224     -14015.224      276.26962      276.26962      48111.733      48111.733     -198.21676     -198.21676    
     22000  -13877.032     -13877.032     -14014.493     -14014.493      265.92778      265.92778      48095.821      48095.821      186.23716      186.23716    
Loop time of 383.817 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.616 hours/ns, 2.605 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    | 382.76     | 382.76     | 382.76     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15962    | 0.15962    | 0.15962    |   0.0 |  0.04
Output  | 0.0001919  | 0.0001919  | 0.0001919  |   0.0 |  0.00
Modify  | 0.79012    | 0.79012    | 0.79012    |   0.0 |  0.21
Other   |            | 0.1046     |            |       |  0.03

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

Total # of neighbors = 310940
Ave neighs/atom = 77.735
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 = 272.77607463946, Press = 0.267732287514603
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  -13877.032     -13877.032     -14014.493     -14014.493      265.92778      265.92778      48095.821      48095.821      186.23716      186.23716    
     23000  -13872.911     -13872.911     -14014.6       -14014.6        274.10645      274.10645      48092.354      48092.354      391.73208      391.73208    
Loop time of 380.857 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.794 hours/ns, 2.626 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    | 379.81     | 379.81     | 379.81     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15732    | 0.15732    | 0.15732    |   0.0 |  0.04
Output  | 0.00018956 | 0.00018956 | 0.00018956 |   0.0 |  0.00
Modify  | 0.78316    | 0.78316    | 0.78316    |   0.0 |  0.21
Other   |            | 0.1046     |            |       |  0.03

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

Total # of neighbors = 310796
Ave neighs/atom = 77.699
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 = 272.795466681628, Press = 1.95758126435523
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  -13872.911     -13872.911     -14014.6       -14014.6        274.10645      274.10645      48092.354      48092.354      391.73208      391.73208    
     24000  -13877.437     -13877.437     -14017.66      -14017.66       271.27239      271.27239      48021.375      48021.375      2167.1604      2167.1604    
Loop time of 379.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.354 hours/ns, 2.637 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    | 378.24     | 378.24     | 378.24     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15637    | 0.15637    | 0.15637    |   0.0 |  0.04
Output  | 0.00024186 | 0.00024186 | 0.00024186 |   0.0 |  0.00
Modify  | 0.77074    | 0.77074    | 0.77074    |   0.0 |  0.20
Other   |            | 0.1039     |            |       |  0.03

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

Total # of neighbors = 310926
Ave neighs/atom = 77.7315
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 = 272.751090472399, Press = 0.221407520979001
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  -13877.437     -13877.437     -14017.66      -14017.66       271.27239      271.27239      48021.375      48021.375      2167.1604      2167.1604    
     25000  -13874.869     -13874.869     -14013.637     -14013.637      268.45601      268.45601      48099.01       48099.01       283.43987      283.43987    
Loop time of 383.605 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.557 hours/ns, 2.607 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    | 382.56     | 382.56     | 382.56     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1579     | 0.1579     | 0.1579     |   0.0 |  0.04
Output  | 0.00018878 | 0.00018878 | 0.00018878 |   0.0 |  0.00
Modify  | 0.77935    | 0.77935    | 0.77935    |   0.0 |  0.20
Other   |            | 0.1042     |            |       |  0.03

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

Total # of neighbors = 310992
Ave neighs/atom = 77.748
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 = 272.711997596138, Press = -2.03064083686902
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  -13874.869     -13874.869     -14013.637     -14013.637      268.45601      268.45601      48099.01       48099.01       283.43987      283.43987    
     26000  -13877.588     -13877.588     -14016.381     -14016.381      268.50287      268.50287      48126.021      48126.021     -891.61578     -891.61578    
Loop time of 381.299 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.917 hours/ns, 2.623 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    | 380.27     | 380.27     | 380.27     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15585    | 0.15585    | 0.15585    |   0.0 |  0.04
Output  | 0.0001876  | 0.0001876  | 0.0001876  |   0.0 |  0.00
Modify  | 0.76993    | 0.76993    | 0.76993    |   0.0 |  0.20
Other   |            | 0.1043     |            |       |  0.03

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 = 272.730605271378, Press = -0.704159463127149
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  -13877.588     -13877.588     -14016.381     -14016.381      268.50287      268.50287      48126.021      48126.021     -891.61578     -891.61578    
     27000  -13873.339     -13873.339     -14016.349     -14016.349      276.66265      276.66265      48104.276      48104.276     -127.99103     -127.99103    
Loop time of 384.065 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.685 hours/ns, 2.604 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    | 383.03     | 383.03     | 383.03     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15753    | 0.15753    | 0.15753    |   0.0 |  0.04
Output  | 0.00018887 | 0.00018887 | 0.00018887 |   0.0 |  0.00
Modify  | 0.77543    | 0.77543    | 0.77543    |   0.0 |  0.20
Other   |            | 0.1034     |            |       |  0.03

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

Total # of neighbors = 310918
Ave neighs/atom = 77.7295
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 = 272.850345692791, Press = 0.180949925743967
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  -13873.339     -13873.339     -14016.349     -14016.349      276.66265      276.66265      48104.276      48104.276     -127.99103     -127.99103    
     28000  -13876.601     -13876.601     -14017.68      -14017.68       272.92628      272.92628      48083.088      48083.088      185.773        185.773      
Loop time of 383.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.662 hours/ns, 2.604 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    | 382.93     | 382.93     | 382.93     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15807    | 0.15807    | 0.15807    |   0.0 |  0.04
Output  | 0.00025892 | 0.00025892 | 0.00025892 |   0.0 |  0.00
Modify  | 0.78748    | 0.78748    | 0.78748    |   0.0 |  0.21
Other   |            | 0.105      |            |       |  0.03

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

Total # of neighbors = 310980
Ave neighs/atom = 77.745
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 = 272.886081620409, Press = -0.00544155148997622
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  -13876.601     -13876.601     -14017.68      -14017.68       272.92628      272.92628      48083.088      48083.088      185.773        185.773      
     29000  -13876.287     -13876.287     -14016.69      -14016.69       271.61754      271.61754      48073.708      48073.708      603.22936      603.22936    
Loop time of 385.199 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.000 hours/ns, 2.596 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    | 384.15     | 384.15     | 384.15     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15894    | 0.15894    | 0.15894    |   0.0 |  0.04
Output  | 0.0001918  | 0.0001918  | 0.0001918  |   0.0 |  0.00
Modify  | 0.78151    | 0.78151    | 0.78151    |   0.0 |  0.20
Other   |            | 0.1049     |            |       |  0.03

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

Total # of neighbors = 310930
Ave neighs/atom = 77.7325
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 = 272.823562938287, Press = -0.582348802881538
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  -13876.287     -13876.287     -14016.69      -14016.69       271.61754      271.61754      48073.708      48073.708      603.22936      603.22936    
     30000  -13876.142     -13876.142     -14017.71      -14017.71       273.87334      273.87334      48076.021      48076.021      434.19216      434.19216    
Loop time of 378.41 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.114 hours/ns, 2.643 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    | 377.39     | 377.39     | 377.39     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15539    | 0.15539    | 0.15539    |   0.0 |  0.04
Output  | 0.0002403  | 0.0002403  | 0.0002403  |   0.0 |  0.00
Modify  | 0.76557    | 0.76557    | 0.76557    |   0.0 |  0.20
Other   |            | 0.1031     |            |       |  0.03

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 = 272.837686843951, Press = -1.46454701354172
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  -13876.142     -13876.142     -14017.71      -14017.71       273.87334      273.87334      48076.021      48076.021      434.19216      434.19216    
     31000  -13870.774     -13870.774     -14013.504     -14013.504      276.11933      276.11933      48146.728      48146.728     -1052.0371     -1052.0371    
Loop time of 385.209 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.002 hours/ns, 2.596 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    | 384.16     | 384.16     | 384.16     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15791    | 0.15791    | 0.15791    |   0.0 |  0.04
Output  | 0.00019149 | 0.00019149 | 0.00019149 |   0.0 |  0.00
Modify  | 0.78186    | 0.78186    | 0.78186    |   0.0 |  0.20
Other   |            | 0.1043     |            |       |  0.03

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

Total # of neighbors = 310918
Ave neighs/atom = 77.7295
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 = 272.898840708718, Press = -1.5968440981365
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  -13870.774     -13870.774     -14013.504     -14013.504      276.11933      276.11933      48146.728      48146.728     -1052.0371     -1052.0371    
     32000  -13875.609     -13875.609     -14014.921     -14014.921      269.50878      269.50878      48124.768      48124.768     -731.23409     -731.23409    
Loop time of 387.521 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.645 hours/ns, 2.581 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    | 386.47     | 386.47     | 386.47     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15976    | 0.15976    | 0.15976    |   0.0 |  0.04
Output  | 0.00022941 | 0.00022941 | 0.00022941 |   0.0 |  0.00
Modify  | 0.78791    | 0.78791    | 0.78791    |   0.0 |  0.20
Other   |            | 0.1039     |            |       |  0.03

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

Total # of neighbors = 310836
Ave neighs/atom = 77.709
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 = 272.932427861265, Press = 1.64282933561469
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  -13875.609     -13875.609     -14014.921     -14014.921      269.50878      269.50878      48124.768      48124.768     -731.23409     -731.23409    
     33000  -13876.196     -13876.196     -14016.746     -14016.746      271.90376      271.90376      48042.528      48042.528      1554.807       1554.807     
Loop time of 386.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.324 hours/ns, 2.588 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    | 385.31     | 385.31     | 385.31     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16006    | 0.16006    | 0.16006    |   0.0 |  0.04
Output  | 0.00027228 | 0.00027228 | 0.00027228 |   0.0 |  0.00
Modify  | 0.78526    | 0.78526    | 0.78526    |   0.0 |  0.20
Other   |            | 0.1048     |            |       |  0.03

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

Total # of neighbors = 310776
Ave neighs/atom = 77.694
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 = 272.935673895775, Press = 0.00513070796852434
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  -13876.196     -13876.196     -14016.746     -14016.746      271.90376      271.90376      48042.528      48042.528      1554.807       1554.807     
     34000  -13875.674     -13875.674     -14019.533     -14019.533      278.30498      278.30498      48102.529      48102.529     -553.62332     -553.62332    
Loop time of 379.059 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.294 hours/ns, 2.638 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    | 378.03     | 378.03     | 378.03     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15683    | 0.15683    | 0.15683    |   0.0 |  0.04
Output  | 0.00023536 | 0.00023536 | 0.00023536 |   0.0 |  0.00
Modify  | 0.76885    | 0.76885    | 0.76885    |   0.0 |  0.20
Other   |            | 0.1041     |            |       |  0.03

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

Total # of neighbors = 311034
Ave neighs/atom = 77.7585
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 = 273.001313540253, Press = -1.26540514592803
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  -13875.674     -13875.674     -14019.533     -14019.533      278.30498      278.30498      48102.529      48102.529     -553.62332     -553.62332    
     35000  -13871.623     -13871.623     -14015.296     -14015.296      277.94509      277.94509      48131.206      48131.206     -804.54363     -804.54363    
Loop time of 387.949 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.764 hours/ns, 2.578 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    | 386.89     | 386.89     | 386.89     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15967    | 0.15967    | 0.15967    |   0.0 |  0.04
Output  | 0.00019305 | 0.00019305 | 0.00019305 |   0.0 |  0.00
Modify  | 0.79184    | 0.79184    | 0.79184    |   0.0 |  0.20
Other   |            | 0.1046     |            |       |  0.03

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

Total # of neighbors = 310970
Ave neighs/atom = 77.7425
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 = 273.037612731712, Press = -0.409656583696585
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  -13871.623     -13871.623     -14015.296     -14015.296      277.94509      277.94509      48131.206      48131.206     -804.54363     -804.54363    
     36000  -13876.237     -13876.237     -14016.962     -14016.962      272.24299      272.24299      48107.419      48107.419     -337.93671     -337.93671    
Loop time of 381.415 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.948 hours/ns, 2.622 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    | 380.38     | 380.38     | 380.38     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15675    | 0.15675    | 0.15675    |   0.0 |  0.04
Output  | 0.00018906 | 0.00018906 | 0.00018906 |   0.0 |  0.00
Modify  | 0.77516    | 0.77516    | 0.77516    |   0.0 |  0.20
Other   |            | 0.1041     |            |       |  0.03

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 = 273.067856515775, Press = 0.488504752816635
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  -13876.237     -13876.237     -14016.962     -14016.962      272.24299      272.24299      48107.419      48107.419     -337.93671     -337.93671    
     37000  -13868.757     -13868.757     -14014.158     -14014.158      281.28885      281.28885      48085.578      48085.578      680.77003      680.77003    
Loop time of 390.428 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.452 hours/ns, 2.561 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    | 389.36     | 389.36     | 389.36     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16054    | 0.16054    | 0.16054    |   0.0 |  0.04
Output  | 0.00019017 | 0.00019017 | 0.00019017 |   0.0 |  0.00
Modify  | 0.80221    | 0.80221    | 0.80221    |   0.0 |  0.21
Other   |            | 0.1051     |            |       |  0.03

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

Total # of neighbors = 310940
Ave neighs/atom = 77.735
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 = 273.105770206492, Press = 0.221713106207812
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  -13868.757     -13868.757     -14014.158     -14014.158      281.28885      281.28885      48085.578      48085.578      680.77003      680.77003    
     38000  -13876.099     -13876.099     -14017.215     -14017.215      272.99886      272.99886      48107.007      48107.007     -348.43805     -348.43805    
Loop time of 380.66 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.739 hours/ns, 2.627 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    | 379.62     | 379.62     | 379.62     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1573     | 0.1573     | 0.1573     |   0.0 |  0.04
Output  | 0.00019112 | 0.00019112 | 0.00019112 |   0.0 |  0.00
Modify  | 0.77581    | 0.77581    | 0.77581    |   0.0 |  0.20
Other   |            | 0.1039     |            |       |  0.03

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

Total # of neighbors = 310838
Ave neighs/atom = 77.7095
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 = 273.155887599384, Press = -0.899268048012843
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  -13876.099     -13876.099     -14017.215     -14017.215      272.99886      272.99886      48107.007      48107.007     -348.43805     -348.43805    
     39000  -13873.275     -13873.275     -14015.704     -14015.704      275.53927      275.53927      48116.212      48116.212     -414.74342     -414.74342    
Loop time of 386.439 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.344 hours/ns, 2.588 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    | 385.39     | 385.39     | 385.39     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15855    | 0.15855    | 0.15855    |   0.0 |  0.04
Output  | 0.00018789 | 0.00018789 | 0.00018789 |   0.0 |  0.00
Modify  | 0.78585    | 0.78585    | 0.78585    |   0.0 |  0.20
Other   |            | 0.1053     |            |       |  0.03

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

Total # of neighbors = 310970
Ave neighs/atom = 77.7425
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 = 273.175809348169, Press = -0.277538333401988
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  -13873.275     -13873.275     -14015.704     -14015.704      275.53927      275.53927      48116.212      48116.212     -414.74342     -414.74342    
     40000  -13881.828     -13881.828     -14019.371     -14019.371      266.08543      266.08543      48075.487      48075.487      247.99857      247.99857    
Loop time of 384.588 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.830 hours/ns, 2.600 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    | 383.54     | 383.54     | 383.54     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15749    | 0.15749    | 0.15749    |   0.0 |  0.04
Output  | 0.00018924 | 0.00018924 | 0.00018924 |   0.0 |  0.00
Modify  | 0.78428    | 0.78428    | 0.78428    |   0.0 |  0.20
Other   |            | 0.1053     |            |       |  0.03

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 = 273.162324350475, Press = -0.224550208071281
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  -13881.828     -13881.828     -14019.371     -14019.371      266.08543      266.08543      48075.487      48075.487      247.99857      247.99857    
     41000  -13873.08      -13873.08      -14014.751     -14014.751      274.07077      274.07077      48095.907      48095.907      251.9225       251.9225     
Loop time of 386.662 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.406 hours/ns, 2.586 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    | 385.61     | 385.61     | 385.61     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15778    | 0.15778    | 0.15778    |   0.0 |  0.04
Output  | 0.00018894 | 0.00018894 | 0.00018894 |   0.0 |  0.00
Modify  | 0.79215    | 0.79215    | 0.79215    |   0.0 |  0.20
Other   |            | 0.1034     |            |       |  0.03

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 = 273.110879320665, Press = -0.230702180596862
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  -13873.08      -13873.08      -14014.751     -14014.751      274.07077      274.07077      48095.907      48095.907      251.9225       251.9225     
     42000  -13877.193     -13877.193     -14016.492     -14016.492      269.48463      269.48463      48088.048      48088.048      226.15237      226.15237    
Loop time of 380.849 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.792 hours/ns, 2.626 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    | 379.8      | 379.8      | 379.8      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1565     | 0.1565     | 0.1565     |   0.0 |  0.04
Output  | 0.00018904 | 0.00018904 | 0.00018904 |   0.0 |  0.00
Modify  | 0.78523    | 0.78523    | 0.78523    |   0.0 |  0.21
Other   |            | 0.1036     |            |       |  0.03

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

Total # of neighbors = 310754
Ave neighs/atom = 77.6885
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 = 273.124974557966, Press = -0.787147791625904
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  -13877.193     -13877.193     -14016.492     -14016.492      269.48463      269.48463      48088.048      48088.048      226.15237      226.15237    
     43000  -13877.216     -13877.216     -14016.829     -14016.829      270.08985      270.08985      48133.863      48133.863     -1097.1973     -1097.1973    
Loop time of 374.423 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 104.006 hours/ns, 2.671 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    | 373.41     | 373.41     | 373.41     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15412    | 0.15412    | 0.15412    |   0.0 |  0.04
Output  | 0.0002561  | 0.0002561  | 0.0002561  |   0.0 |  0.00
Modify  | 0.75404    | 0.75404    | 0.75404    |   0.0 |  0.20
Other   |            | 0.1003     |            |       |  0.03

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

Total # of neighbors = 310970
Ave neighs/atom = 77.7425
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 = 273.129601858874, Press = -0.736636419231711
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  -13877.216     -13877.216     -14016.829     -14016.829      270.08985      270.08985      48133.863      48133.863     -1097.1973     -1097.1973    
     44000  -13876.866     -13876.866     -14020.245     -14020.245      277.3773       277.3773       48115.709      48115.709     -885.44075     -885.44075    
Loop time of 380.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.728 hours/ns, 2.627 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    | 379.58     | 379.58     | 379.58     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15797    | 0.15797    | 0.15797    |   0.0 |  0.04
Output  | 0.00018821 | 0.00018821 | 0.00018821 |   0.0 |  0.00
Modify  | 0.78211    | 0.78211    | 0.78211    |   0.0 |  0.21
Other   |            | 0.1023     |            |       |  0.03

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

Total # of neighbors = 310832
Ave neighs/atom = 77.708
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 = 273.078344550623, Press = 1.01636469170425
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   
     44000  -13876.866     -13876.866     -14020.245     -14020.245      277.3773       277.3773       48115.709      48115.709     -885.44075     -885.44075    
     45000  -13875.074     -13875.074     -14014.806     -14014.806      270.32095      270.32095      48028.693      48028.693      2121.6024      2121.6024    
Loop time of 384.197 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.721 hours/ns, 2.603 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    | 383.15     | 383.15     | 383.15     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15859    | 0.15859    | 0.15859    |   0.0 |  0.04
Output  | 0.00023404 | 0.00023404 | 0.00023404 |   0.0 |  0.00
Modify  | 0.78184    | 0.78184    | 0.78184    |   0.0 |  0.20
Other   |            | 0.1021     |            |       |  0.03

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 = 273.072054373893, Press = 0.311598488285558
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   
     45000  -13875.074     -13875.074     -14014.806     -14014.806      270.32095      270.32095      48028.693      48028.693      2121.6024      2121.6024    
     46000  -13878.295     -13878.295     -14018.256     -14018.256      270.76465      270.76465      48074.147      48074.147      460.93122      460.93122    
Loop time of 379.904 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.529 hours/ns, 2.632 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    | 378.89     | 378.89     | 378.89     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15425    | 0.15425    | 0.15425    |   0.0 |  0.04
Output  | 0.00018856 | 0.00018856 | 0.00018856 |   0.0 |  0.00
Modify  | 0.7622     | 0.7622     | 0.7622     |   0.0 |  0.20
Other   |            | 0.1012     |            |       |  0.03

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

Total # of neighbors = 310918
Ave neighs/atom = 77.7295
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 = 273.084609902045, Press = -0.826597898632359
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   
     46000  -13878.295     -13878.295     -14018.256     -14018.256      270.76465      270.76465      48074.147      48074.147      460.93122      460.93122    
     47000  -13876.214     -13876.214     -14016.703     -14016.703      271.78529      271.78529      48118.189      48118.189     -584.07001     -584.07001    
Loop time of 379.09 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.303 hours/ns, 2.638 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    | 378.06     | 378.06     | 378.06     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15562    | 0.15562    | 0.15562    |   0.0 |  0.04
Output  | 0.00022735 | 0.00022735 | 0.00022735 |   0.0 |  0.00
Modify  | 0.76911    | 0.76911    | 0.76911    |   0.0 |  0.20
Other   |            | 0.1016     |            |       |  0.03

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

Total # of neighbors = 310996
Ave neighs/atom = 77.749
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 = 273.075595308728, Press = -0.623532917714648
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   
     47000  -13876.214     -13876.214     -14016.703     -14016.703      271.78529      271.78529      48118.189      48118.189     -584.07001     -584.07001    
     48000  -13875.599     -13875.599     -14018.678     -14018.678      276.79516      276.79516      48117.11       48117.11      -922.0181      -922.0181     
Loop time of 381.132 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.870 hours/ns, 2.624 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    | 380.11     | 380.11     | 380.11     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15595    | 0.15595    | 0.15595    |   0.0 |  0.04
Output  | 0.00023205 | 0.00023205 | 0.00023205 |   0.0 |  0.00
Modify  | 0.76881    | 0.76881    | 0.76881    |   0.0 |  0.20
Other   |            | 0.1015     |            |       |  0.03

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

Total # of neighbors = 310950
Ave neighs/atom = 77.7375
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 = 273.032185405436, Press = 0.368620797242918
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   
     48000  -13875.599     -13875.599     -14018.678     -14018.678      276.79516      276.79516      48117.11       48117.11      -922.0181      -922.0181     
     49000  -13875.574     -13875.574     -14018.564     -14018.564      276.62461      276.62461      48073.218      48073.218      448.11456      448.11456    
Loop time of 381.91 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.086 hours/ns, 2.618 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    | 380.87     | 380.87     | 380.87     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15733    | 0.15733    | 0.15733    |   0.0 |  0.04
Output  | 0.00019353 | 0.00019353 | 0.00019353 |   0.0 |  0.00
Modify  | 0.77838    | 0.77838    | 0.77838    |   0.0 |  0.20
Other   |            | 0.1023     |            |       |  0.03

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 = 273.035793387684, Press = 0.204919753085501
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   
     49000  -13875.574     -13875.574     -14018.564     -14018.564      276.62461      276.62461      48073.218      48073.218      448.11456      448.11456    
     50000  -13874.398     -13874.398     -14017.365     -14017.365      276.57872      276.57872      48067.856      48067.856      766.04353      766.04353    
Loop time of 378.341 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.095 hours/ns, 2.643 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    | 377.32     | 377.32     | 377.32     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15494    | 0.15494    | 0.15494    |   0.0 |  0.04
Output  | 0.00018947 | 0.00018947 | 0.00018947 |   0.0 |  0.00
Modify  | 0.76916    | 0.76916    | 0.76916    |   0.0 |  0.20
Other   |            | 0.1018     |            |       |  0.03

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

Total # of neighbors = 310992
Ave neighs/atom = 77.748
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 = 273.04269357453, Press = -1.2201325370352
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   
     50000  -13874.398     -13874.398     -14017.365     -14017.365      276.57872      276.57872      48067.856      48067.856      766.04353      766.04353    
     51000  -13876.296     -13876.296     -14016.076     -14016.076      270.41418      270.41418      48182.09       48182.09      -2488.1248     -2488.1248    
Loop time of 378.751 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.209 hours/ns, 2.640 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    | 377.73     | 377.73     | 377.73     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15521    | 0.15521    | 0.15521    |   0.0 |  0.04
Output  | 0.0002667  | 0.0002667  | 0.0002667  |   0.0 |  0.00
Modify  | 0.76527    | 0.76527    | 0.76527    |   0.0 |  0.20
Other   |            | 0.1013     |            |       |  0.03

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

Total # of neighbors = 310970
Ave neighs/atom = 77.7425
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 = 273.040213429602, Press = -1.21749011080753
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   
     51000  -13876.296     -13876.296     -14016.076     -14016.076      270.41418      270.41418      48182.09       48182.09      -2488.1248     -2488.1248    
     52000  -13871.838     -13871.838     -14014.287     -14014.287      275.57744      275.57744      48153.986      48153.986     -1419.7914     -1419.7914    
Loop time of 371.484 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.190 hours/ns, 2.692 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    | 370.49     | 370.49     | 370.49     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15276    | 0.15276    | 0.15276    |   0.0 |  0.04
Output  | 0.00048795 | 0.00048795 | 0.00048795 |   0.0 |  0.00
Modify  | 0.74426    | 0.74426    | 0.74426    |   0.0 |  0.20
Other   |            | 0.09978    |            |       |  0.03

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

Total # of neighbors = 310898
Ave neighs/atom = 77.7245
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 = 273.073308370399, Press = 0.707115193246363
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   
     52000  -13871.838     -13871.838     -14014.287     -14014.287      275.57744      275.57744      48153.986      48153.986     -1419.7914     -1419.7914    
     53000  -13874.044     -13874.044     -14015.21      -14015.21       273.09685      273.09685      48069.728      48069.728      937.17318      937.17318    
Loop time of 385.864 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.184 hours/ns, 2.592 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    | 384.81     | 384.81     | 384.81     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15882    | 0.15882    | 0.15882    |   0.0 |  0.04
Output  | 0.00019239 | 0.00019239 | 0.00019239 |   0.0 |  0.00
Modify  | 0.79514    | 0.79514    | 0.79514    |   0.0 |  0.21
Other   |            | 0.1033     |            |       |  0.03

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

Total # of neighbors = 310828
Ave neighs/atom = 77.707
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 = 273.069823485183, Press = 0.220301518196039
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   
     53000  -13874.044     -13874.044     -14015.21      -14015.21       273.09685      273.09685      48069.728      48069.728      937.17318      937.17318    
     54000  -13873.249     -13873.249     -14013.521     -14013.521      271.36633      271.36633      48079.581      48079.581      806.80931      806.80931    
Loop time of 380.521 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.700 hours/ns, 2.628 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    | 379.49     | 379.49     | 379.49     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15604    | 0.15604    | 0.15604    |   0.0 |  0.04
Output  | 0.00024421 | 0.00024421 | 0.00024421 |   0.0 |  0.00
Modify  | 0.77506    | 0.77506    | 0.77506    |   0.0 |  0.20
Other   |            | 0.1021     |            |       |  0.03

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

Total # of neighbors = 310950
Ave neighs/atom = 77.7375
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 = 273.043298981979, Press = -0.379278710606638
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   
     54000  -13873.249     -13873.249     -14013.521     -14013.521      271.36633      271.36633      48079.581      48079.581      806.80931      806.80931    
     55000  -13880.351     -13880.351     -14018.975     -14018.975      268.17936      268.17936      48107.954      48107.954     -571.36027     -571.36027    
Loop time of 377.841 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.956 hours/ns, 2.647 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    | 376.83     | 376.83     | 376.83     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15399    | 0.15399    | 0.15399    |   0.0 |  0.04
Output  | 0.00019347 | 0.00019347 | 0.00019347 |   0.0 |  0.00
Modify  | 0.75773    | 0.75773    | 0.75773    |   0.0 |  0.20
Other   |            | 0.1011     |            |       |  0.03

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 = 273.01487755124, Press = -0.516558490145826
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   
     55000  -13880.351     -13880.351     -14018.975     -14018.975      268.17936      268.17936      48107.954      48107.954     -571.36027     -571.36027    
     56000  -13875.769     -13875.769     -14017.296     -14017.296      273.7934       273.7934       48158.399      48158.399     -1840.4408     -1840.4408    
Loop time of 379.931 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.536 hours/ns, 2.632 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    | 378.9      | 378.9      | 378.9      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15583    | 0.15583    | 0.15583    |   0.0 |  0.04
Output  | 0.00019063 | 0.00019063 | 0.00019063 |   0.0 |  0.00
Modify  | 0.77558    | 0.77558    | 0.77558    |   0.0 |  0.20
Other   |            | 0.1023     |            |       |  0.03

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

Total # of neighbors = 311014
Ave neighs/atom = 77.7535
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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
48095.579845877

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0