# 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.006 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_Wagner_2007_Cu__MO_313717476091_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_313717476091_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.1678      3179.1678    
      1000  -13896.407     -13896.407     -14034.852     -14034.852      267.83013      267.83013      47805.75       47805.75       106.2064       106.2064     
Loop time of 204.808 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.891 hours/ns, 4.883 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.84     | 203.84     | 203.84     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15143    | 0.15143    | 0.15143    |   0.0 |  0.07
Output  | 0.00024791 | 0.00024791 | 0.00024791 |   0.0 |  0.00
Modify  | 0.7192     | 0.7192     | 0.7192     |   0.0 |  0.35
Other   |            | 0.1021     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       312000 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13896.407     -13896.407     -14034.852     -14034.852      267.83013      267.83013      47805.75       47805.75       106.2064       106.2064     
      2000  -13888.442     -13888.442     -14032.826     -14032.826      279.32134      279.32134      47832.368      47832.368     -777.66863     -777.66863    
Loop time of 199.448 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.56     | 198.56     | 198.56     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14418    | 0.14418    | 0.14418    |   0.0 |  0.07
Output  | 0.00023806 | 0.00023806 | 0.00023806 |   0.0 |  0.00
Modify  | 0.64828    | 0.64828    | 0.64828    |   0.0 |  0.33
Other   |            | 0.09732    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311706 ave      311706 max      311706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311706
Ave neighs/atom = 77.9265
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  -13888.442     -13888.442     -14032.826     -14032.826      279.32134      279.32134      47832.368      47832.368     -777.66863     -777.66863    
      3000  -13892.643     -13892.643     -14035.569     -14035.569      276.49896      276.49896      47756.666      47756.666      1198.151       1198.151     
Loop time of 199.464 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.58     | 198.58     | 198.58     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14431    | 0.14431    | 0.14431    |   0.0 |  0.07
Output  | 0.00028852 | 0.00028852 | 0.00028852 |   0.0 |  0.00
Modify  | 0.64667    | 0.64667    | 0.64667    |   0.0 |  0.32
Other   |            | 0.09593    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311638 ave      311638 max      311638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311638
Ave neighs/atom = 77.9095
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  -13892.643     -13892.643     -14035.569     -14035.569      276.49896      276.49896      47756.666      47756.666      1198.151       1198.151     
      4000  -13893.475     -13893.475     -14033.534     -14033.534      270.95312      270.95312      47831.344      47831.344     -961.25823     -961.25823    
Loop time of 199.499 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.61     | 198.61     | 198.61     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14431    | 0.14431    | 0.14431    |   0.0 |  0.07
Output  | 0.00023891 | 0.00023891 | 0.00023891 |   0.0 |  0.00
Modify  | 0.64937    | 0.64937    | 0.64937    |   0.0 |  0.33
Other   |            | 0.09528    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311750 ave      311750 max      311750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311750
Ave neighs/atom = 77.9375
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  -13893.475     -13893.475     -14033.534     -14033.534      270.95312      270.95312      47831.344      47831.344     -961.25823     -961.25823    
      5000  -13890.728     -13890.728     -14033.315     -14033.315      275.84475      275.84475      47810.28       47810.28      -65.045484     -65.045484    
Loop time of 199.676 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.79     | 198.79     | 198.79     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14341    | 0.14341    | 0.14341    |   0.0 |  0.07
Output  | 0.00019572 | 0.00019572 | 0.00019572 |   0.0 |  0.00
Modify  | 0.65097    | 0.65097    | 0.65097    |   0.0 |  0.33
Other   |            | 0.09493    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311684 ave      311684 max      311684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311684
Ave neighs/atom = 77.921
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 = 275.549534778812, Press = 317.18362491047
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  -13890.728     -13890.728     -14033.315     -14033.315      275.84475      275.84475      47810.28       47810.28      -65.045484     -65.045484    
      6000  -13892.889     -13892.889     -14033.468     -14033.468      271.95989      271.95989      47765.003      47765.003      1018.6914      1018.6914    
Loop time of 199.408 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.49     | 198.49     | 198.49     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14342    | 0.14342    | 0.14342    |   0.0 |  0.07
Output  | 0.00019358 | 0.00019358 | 0.00019358 |   0.0 |  0.00
Modify  | 0.67361    | 0.67361    | 0.67361    |   0.0 |  0.34
Other   |            | 0.09607    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311660 ave      311660 max      311660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311660
Ave neighs/atom = 77.915
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.113330999165, Press = -7.15961052130919
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  -13892.889     -13892.889     -14033.468     -14033.468      271.95989      271.95989      47765.003      47765.003      1018.6914      1018.6914    
      7000  -13895.175     -13895.175     -14035.892     -14035.892      272.22701      272.22701      47856.91       47856.91      -1464.6158     -1464.6158    
Loop time of 200.687 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.746 hours/ns, 4.983 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.77     | 199.77     | 199.77     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14446    | 0.14446    | 0.14446    |   0.0 |  0.07
Output  | 0.00026845 | 0.00026845 | 0.00026845 |   0.0 |  0.00
Modify  | 0.68049    | 0.68049    | 0.68049    |   0.0 |  0.34
Other   |            | 0.09544    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311702 ave      311702 max      311702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311702
Ave neighs/atom = 77.9255
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.303532474388, Press = 3.66230377707243
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  -13895.175     -13895.175     -14035.892     -14035.892      272.22701      272.22701      47856.91       47856.91      -1464.6158     -1464.6158    
      8000  -13889.526     -13889.526     -14032.946     -14032.946      277.45627      277.45627      47770.259      47770.259      906.93376      906.93376    
Loop time of 235.864 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.518 hours/ns, 4.240 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.73     | 234.73     | 234.73     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16565    | 0.16565    | 0.16565    |   0.0 |  0.07
Output  | 0.00024881 | 0.00024881 | 0.00024881 |   0.0 |  0.00
Modify  | 0.86076    | 0.86076    | 0.86076    |   0.0 |  0.36
Other   |            | 0.1098     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311644 ave      311644 max      311644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311644
Ave neighs/atom = 77.911
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.801353992736, Press = 13.2726336092695
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  -13889.526     -13889.526     -14032.946     -14032.946      277.45627      277.45627      47770.259      47770.259      906.93376      906.93376    
      9000  -13891.367     -13891.367     -14032.672     -14032.672      273.36384      273.36384      47763.969      47763.969      995.3072       995.3072     
Loop time of 236.041 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.567 hours/ns, 4.237 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.94     | 234.94     | 234.94     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1632     | 0.1632     | 0.1632     |   0.0 |  0.07
Output  | 0.00019259 | 0.00019259 | 0.00019259 |   0.0 |  0.00
Modify  | 0.83245    | 0.83245    | 0.83245    |   0.0 |  0.35
Other   |            | 0.1072     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311612 ave      311612 max      311612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311612
Ave neighs/atom = 77.903
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.723937028041, Press = -6.07781744659235
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  -13891.367     -13891.367     -14032.672     -14032.672      273.36384      273.36384      47763.969      47763.969      995.3072       995.3072     
     10000  -13894.766     -13894.766     -14035.058     -14035.058      271.40383      271.40383      47830.76       47830.76      -1068.1783     -1068.1783    
Loop time of 235.799 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.500 hours/ns, 4.241 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.68     | 234.68     | 234.68     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16394    | 0.16394    | 0.16394    |   0.0 |  0.07
Output  | 0.00019913 | 0.00019913 | 0.00019913 |   0.0 |  0.00
Modify  | 0.84471    | 0.84471    | 0.84471    |   0.0 |  0.36
Other   |            | 0.1086     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311708 ave      311708 max      311708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311708
Ave neighs/atom = 77.927
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.962207559981, Press = -1.49945495534573
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  -13894.766     -13894.766     -14035.058     -14035.058      271.40383      271.40383      47830.76       47830.76      -1068.1783     -1068.1783    
     11000  -13895.879     -13895.879     -14035.241     -14035.241      269.60403      269.60403      47811.555      47811.555     -281.03258     -281.03258    
Loop time of 236.157 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.599 hours/ns, 4.234 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.04     | 235.04     | 235.04     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16456    | 0.16456    | 0.16456    |   0.0 |  0.07
Output  | 0.00019361 | 0.00019361 | 0.00019361 |   0.0 |  0.00
Modify  | 0.83995    | 0.83995    | 0.83995    |   0.0 |  0.36
Other   |            | 0.108      |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311642 ave      311642 max      311642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311642
Ave neighs/atom = 77.9105
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.864089922855, Press = 9.11961720869861
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  -13895.879     -13895.879     -14035.241     -14035.241      269.60403      269.60403      47811.555      47811.555     -281.03258     -281.03258    
     12000  -13890.318     -13890.318     -14030.32      -14030.32       270.8434       270.8434       47756.401      47756.401      1011.6907      1011.6907    
Loop time of 235.877 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.521 hours/ns, 4.239 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.75     | 234.75     | 234.75     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16544    | 0.16544    | 0.16544    |   0.0 |  0.07
Output  | 0.00019826 | 0.00019826 | 0.00019826 |   0.0 |  0.00
Modify  | 0.84912    | 0.84912    | 0.84912    |   0.0 |  0.36
Other   |            | 0.1088     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311678 ave      311678 max      311678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311678
Ave neighs/atom = 77.9195
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.524514980519, Press = -1.36654692783446
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  -13890.318     -13890.318     -14030.32      -14030.32       270.8434       270.8434       47756.401      47756.401      1011.6907      1011.6907    
     13000  -13887.843     -13887.843     -14034.047     -14034.047      282.84007      282.84007      47851.903      47851.903     -1438.4068     -1438.4068    
Loop time of 236.298 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.638 hours/ns, 4.232 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.17     | 235.17     | 235.17     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16602    | 0.16602    | 0.16602    |   0.0 |  0.07
Output  | 0.00025036 | 0.00025036 | 0.00025036 |   0.0 |  0.00
Modify  | 0.84749    | 0.84749    | 0.84749    |   0.0 |  0.36
Other   |            | 0.1092     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311628 ave      311628 max      311628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311628
Ave neighs/atom = 77.907
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.515345460079, Press = 2.19928994632876
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  -13887.843     -13887.843     -14034.047     -14034.047      282.84007      282.84007      47851.903      47851.903     -1438.4068     -1438.4068    
     14000  -13894.037     -13894.037     -14036.142     -14036.142      274.91036      274.91036      47779.174      47779.174      541.16483      541.16483    
Loop time of 235.928 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.536 hours/ns, 4.239 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.81     | 234.81     | 234.81     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16483    | 0.16483    | 0.16483    |   0.0 |  0.07
Output  | 0.00052776 | 0.00052776 | 0.00052776 |   0.0 |  0.00
Modify  | 0.84254    | 0.84254    | 0.84254    |   0.0 |  0.36
Other   |            | 0.1089     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311576 ave      311576 max      311576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311576
Ave neighs/atom = 77.894
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.642796417245, Press = 2.44843699486638
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  -13894.037     -13894.037     -14036.142     -14036.142      274.91036      274.91036      47779.174      47779.174      541.16483      541.16483    
     15000  -13888.292     -13888.292     -14030.083     -14030.083      274.3042       274.3042       47814.574      47814.574     -473.56715     -473.56715    
Loop time of 236.398 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.666 hours/ns, 4.230 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.27     | 235.27     | 235.27     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16471    | 0.16471    | 0.16471    |   0.0 |  0.07
Output  | 0.00019646 | 0.00019646 | 0.00019646 |   0.0 |  0.00
Modify  | 0.85074    | 0.85074    | 0.85074    |   0.0 |  0.36
Other   |            | 0.1095     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311664 ave      311664 max      311664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311664
Ave neighs/atom = 77.916
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.721975073721, Press = 0.620784778209606
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  -13888.292     -13888.292     -14030.083     -14030.083      274.3042       274.3042       47814.574      47814.574     -473.56715     -473.56715    
     16000  -13889.556     -13889.556     -14031.61      -14031.61       274.81366      274.81366      47797.92       47797.92       127.94096      127.94096    
Loop time of 235.743 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.484 hours/ns, 4.242 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.62     | 234.62     | 234.62     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16503    | 0.16503    | 0.16503    |   0.0 |  0.07
Output  | 0.00019401 | 0.00019401 | 0.00019401 |   0.0 |  0.00
Modify  | 0.85193    | 0.85193    | 0.85193    |   0.0 |  0.36
Other   |            | 0.1098     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311568 ave      311568 max      311568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311568
Ave neighs/atom = 77.892
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.702244945163, Press = 3.17515179241432
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  -13889.556     -13889.556     -14031.61      -14031.61       274.81366      274.81366      47797.92       47797.92       127.94096      127.94096    
     17000  -13891.955     -13891.955     -14031.844     -14031.844      270.62547      270.62547      47773.919      47773.919      817.68304      817.68304    
Loop time of 228.051 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.96     | 226.96     | 226.96     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16076    | 0.16076    | 0.16076    |   0.0 |  0.07
Output  | 0.00023887 | 0.00023887 | 0.00023887 |   0.0 |  0.00
Modify  | 0.82338    | 0.82338    | 0.82338    |   0.0 |  0.36
Other   |            | 0.1076     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311646 ave      311646 max      311646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311646
Ave neighs/atom = 77.9115
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.652293379447, Press = 1.28339268823471
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  -13891.955     -13891.955     -14031.844     -14031.844      270.62547      270.62547      47773.919      47773.919      817.68304      817.68304    
     18000  -13895.373     -13895.373     -14035.339     -14035.339      270.77443      270.77443      47811.493      47811.493     -386.38672     -386.38672    
Loop time of 218.827 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 217.8      | 217.8      | 217.8      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15392    | 0.15392    | 0.15392    |   0.0 |  0.07
Output  | 0.00019107 | 0.00019107 | 0.00019107 |   0.0 |  0.00
Modify  | 0.76774    | 0.76774    | 0.76774    |   0.0 |  0.35
Other   |            | 0.1038     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311676 ave      311676 max      311676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311676
Ave neighs/atom = 77.919
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.613910267491, Press = -0.14034182111389
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  -13895.373     -13895.373     -14035.339     -14035.339      270.77443      270.77443      47811.493      47811.493     -386.38672     -386.38672    
     19000  -13890.748     -13890.748     -14033.421     -14033.421      276.01043      276.01043      47834.151      47834.151     -694.84994     -694.84994    
Loop time of 198.373 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.103 hours/ns, 5.041 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.47     | 197.47     | 197.47     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14019    | 0.14019    | 0.14019    |   0.0 |  0.07
Output  | 0.00019372 | 0.00019372 | 0.00019372 |   0.0 |  0.00
Modify  | 0.66852    | 0.66852    | 0.66852    |   0.0 |  0.34
Other   |            | 0.09724    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311634 ave      311634 max      311634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311634
Ave neighs/atom = 77.9085
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.550805246895, Press = 2.77674276168694
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  -13890.748     -13890.748     -14033.421     -14033.421      276.01043      276.01043      47834.151      47834.151     -694.84994     -694.84994    
     20000  -13888.38      -13888.38      -14032.52      -14032.52       278.84738      278.84738      47751.607      47751.607      1510.7109      1510.7109    
Loop time of 198.842 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.234 hours/ns, 5.029 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.93     | 197.93     | 197.93     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14001    | 0.14001    | 0.14001    |   0.0 |  0.07
Output  | 0.00019003 | 0.00019003 | 0.00019003 |   0.0 |  0.00
Modify  | 0.67127    | 0.67127    | 0.67127    |   0.0 |  0.34
Other   |            | 0.09721    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311702 ave      311702 max      311702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311702
Ave neighs/atom = 77.9255
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.542371038732, Press = 2.22836838050798
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  -13888.38      -13888.38      -14032.52      -14032.52       278.84738      278.84738      47751.607      47751.607      1510.7109      1510.7109    
     21000  -13893.918     -13893.918     -14034.736     -14034.736      272.42139      272.42139      47832.052      47832.052     -965.0383      -965.0383     
Loop time of 198.753 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.209 hours/ns, 5.031 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.84     | 197.84     | 197.84     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14033    | 0.14033    | 0.14033    |   0.0 |  0.07
Output  | 0.00018986 | 0.00018986 | 0.00018986 |   0.0 |  0.00
Modify  | 0.67041    | 0.67041    | 0.67041    |   0.0 |  0.34
Other   |            | 0.09769    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311696 ave      311696 max      311696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311696
Ave neighs/atom = 77.924
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.606512087883, Press = -1.85139751201974
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  -13893.918     -13893.918     -14034.736     -14034.736      272.42139      272.42139      47832.052      47832.052     -965.0383      -965.0383     
     22000  -13895.557     -13895.557     -14034.112     -14034.112      268.04488      268.04488      47814.879      47814.879     -288.58352     -288.58352    
Loop time of 198.499 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.139 hours/ns, 5.038 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.59     | 197.59     | 197.59     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14036    | 0.14036    | 0.14036    |   0.0 |  0.07
Output  | 0.00019017 | 0.00019017 | 0.00019017 |   0.0 |  0.00
Modify  | 0.66902    | 0.66902    | 0.66902    |   0.0 |  0.34
Other   |            | 0.0983     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311668 ave      311668 max      311668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311668
Ave neighs/atom = 77.917
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.660092264368, Press = 3.6201201866795
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  -13895.557     -13895.557     -14034.112     -14034.112      268.04488      268.04488      47814.879      47814.879     -288.58352     -288.58352    
     23000  -13893.472     -13893.472     -14033.448     -14033.448      270.79273      270.79273      47753.857      47753.857      1307.2179      1307.2179    
Loop time of 198.555 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.154 hours/ns, 5.036 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.65     | 197.65     | 197.65     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14032    | 0.14032    | 0.14032    |   0.0 |  0.07
Output  | 0.00018966 | 0.00018966 | 0.00018966 |   0.0 |  0.00
Modify  | 0.66977    | 0.66977    | 0.66977    |   0.0 |  0.34
Other   |            | 0.09757    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311686 ave      311686 max      311686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311686
Ave neighs/atom = 77.9215
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.663672031946, Press = -0.803846290389604
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  -13893.472     -13893.472     -14033.448     -14033.448      270.79273      270.79273      47753.857      47753.857      1307.2179      1307.2179    
     24000  -13887.538     -13887.538     -14030.823     -14030.823      277.19458      277.19458      47838.603      47838.603     -1072.4103     -1072.4103    
Loop time of 198.587 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.163 hours/ns, 5.036 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.68     | 197.68     | 197.68     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14019    | 0.14019    | 0.14019    |   0.0 |  0.07
Output  | 0.00019232 | 0.00019232 | 0.00019232 |   0.0 |  0.00
Modify  | 0.66998    | 0.66998    | 0.66998    |   0.0 |  0.34
Other   |            | 0.09787    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311656 ave      311656 max      311656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311656
Ave neighs/atom = 77.914
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.674638678885, Press = 0.34827652155794
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  -13887.538     -13887.538     -14030.823     -14030.823      277.19458      277.19458      47838.603      47838.603     -1072.4103     -1072.4103    
     25000  -13894.882     -13894.882     -14035.158     -14035.158      271.37232      271.37232      47772.908      47772.908      667.45277      667.45277    
Loop time of 201.91 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.086 hours/ns, 4.953 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.98     | 200.98     | 200.98     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14354    | 0.14354    | 0.14354    |   0.0 |  0.07
Output  | 0.0001953  | 0.0001953  | 0.0001953  |   0.0 |  0.00
Modify  | 0.68865    | 0.68865    | 0.68865    |   0.0 |  0.34
Other   |            | 0.09827    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311634 ave      311634 max      311634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311634
Ave neighs/atom = 77.9085
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.726600970215, Press = 2.43215025696423
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  -13894.882     -13894.882     -14035.158     -14035.158      271.37232      271.37232      47772.908      47772.908      667.45277      667.45277    
     26000  -13896.618     -13896.618     -14035.225     -14035.225      268.14395      268.14395      47764.222      47764.222      742.53686      742.53686    
Loop time of 235.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.552 hours/ns, 4.238 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.88     | 234.88     | 234.88     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16437    | 0.16437    | 0.16437    |   0.0 |  0.07
Output  | 0.00025511 | 0.00025511 | 0.00025511 |   0.0 |  0.00
Modify  | 0.83532    | 0.83532    | 0.83532    |   0.0 |  0.35
Other   |            | 0.1073     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311660 ave      311660 max      311660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311660
Ave neighs/atom = 77.915
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.701162579926, Press = -1.05570450582617
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  -13896.618     -13896.618     -14035.225     -14035.225      268.14395      268.14395      47764.222      47764.222      742.53686      742.53686    
     27000  -13892.841     -13892.841     -14034.652     -14034.652      274.34186      274.34186      47895.469      47895.469     -2647.8577     -2647.8577    
Loop time of 235.595 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.48     | 234.48     | 234.48     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16586    | 0.16586    | 0.16586    |   0.0 |  0.07
Output  | 0.00019318 | 0.00019318 | 0.00019318 |   0.0 |  0.00
Modify  | 0.84654    | 0.84654    | 0.84654    |   0.0 |  0.36
Other   |            | 0.1065     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311670 ave      311670 max      311670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311670
Ave neighs/atom = 77.9175
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.687046494814, Press = 0.742790151766979
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  -13892.841     -13892.841     -14034.652     -14034.652      274.34186      274.34186      47895.469      47895.469     -2647.8577     -2647.8577    
     28000  -13889.133     -13889.133     -14031.48      -14031.48       275.37818      275.37818      47792.191      47792.191      411.85795      411.85795    
Loop time of 235.916 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.532 hours/ns, 4.239 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.8      | 234.8      | 234.8      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.166      | 0.166      | 0.166      |   0.0 |  0.07
Output  | 0.00019361 | 0.00019361 | 0.00019361 |   0.0 |  0.00
Modify  | 0.84404    | 0.84404    | 0.84404    |   0.0 |  0.36
Other   |            | 0.1073     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311568 ave      311568 max      311568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311568
Ave neighs/atom = 77.892
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.721046293765, Press = 2.80206265046685
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  -13889.133     -13889.133     -14031.48      -14031.48       275.37818      275.37818      47792.191      47792.191      411.85795      411.85795    
     29000  -13890.648     -13890.648     -14031.06      -14031.06       271.63646      271.63646      47781.911      47781.911      677.37525      677.37525    
Loop time of 227.071 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.075 hours/ns, 4.404 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226        | 226        | 226        |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16059    | 0.16059    | 0.16059    |   0.0 |  0.07
Output  | 0.0003281  | 0.0003281  | 0.0003281  |   0.0 |  0.00
Modify  | 0.80534    | 0.80534    | 0.80534    |   0.0 |  0.35
Other   |            | 0.1063     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311606 ave      311606 max      311606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311606
Ave neighs/atom = 77.9015
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.719122898776, Press = 0.0859209997237532
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  -13890.648     -13890.648     -14031.06      -14031.06       271.63646      271.63646      47781.911      47781.911      677.37525      677.37525    
     30000  -13891.916     -13891.916     -14032.958     -14032.958      272.85555      272.85555      47837.7        47837.7       -1028.3458     -1028.3458    
Loop time of 235.748 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.486 hours/ns, 4.242 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.64     | 234.64     | 234.64     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16421    | 0.16421    | 0.16421    |   0.0 |  0.07
Output  | 0.00025008 | 0.00025008 | 0.00025008 |   0.0 |  0.00
Modify  | 0.83929    | 0.83929    | 0.83929    |   0.0 |  0.36
Other   |            | 0.1081     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311668 ave      311668 max      311668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311668
Ave neighs/atom = 77.917
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.718992853151, Press = 0.259269174748081
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  -13891.916     -13891.916     -14032.958     -14032.958      272.85555      272.85555      47837.7        47837.7       -1028.3458     -1028.3458    
     31000  -13895.65      -13895.65      -14034.108     -14034.108      267.85708      267.85708      47816.345      47816.345     -370.6026      -370.6026     
Loop time of 235.349 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.375 hours/ns, 4.249 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.23     | 234.23     | 234.23     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1652     | 0.1652     | 0.1652     |   0.0 |  0.07
Output  | 0.00025071 | 0.00025071 | 0.00025071 |   0.0 |  0.00
Modify  | 0.8487     | 0.8487     | 0.8487     |   0.0 |  0.36
Other   |            | 0.108      |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311690 ave      311690 max      311690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311690
Ave neighs/atom = 77.9225
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.743651170341, Press = 1.90209661353558
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  -13895.65      -13895.65      -14034.108     -14034.108      267.85708      267.85708      47816.345      47816.345     -370.6026      -370.6026     
     32000  -13890.768     -13890.768     -14032.322     -14032.322      273.84574      273.84574      47731.255      47731.255      2001.2936      2001.2936    
Loop time of 235.311 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.21     | 234.21     | 234.21     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1637     | 0.1637     | 0.1637     |   0.0 |  0.07
Output  | 0.00019521 | 0.00019521 | 0.00019521 |   0.0 |  0.00
Modify  | 0.83366    | 0.83366    | 0.83366    |   0.0 |  0.35
Other   |            | 0.1055     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311682 ave      311682 max      311682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311682
Ave neighs/atom = 77.9205
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.7314420806, Press = 0.491000556457376
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  -13890.768     -13890.768     -14032.322     -14032.322      273.84574      273.84574      47731.255      47731.255      2001.2936      2001.2936    
     33000  -13892.016     -13892.016     -14032.358     -14032.358      271.50169      271.50169      47841.365      47841.365     -1163.8291     -1163.8291    
Loop time of 235.236 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.343 hours/ns, 4.251 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.12     | 234.12     | 234.12     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16408    | 0.16408    | 0.16408    |   0.0 |  0.07
Output  | 0.00031338 | 0.00031338 | 0.00031338 |   0.0 |  0.00
Modify  | 0.84812    | 0.84812    | 0.84812    |   0.0 |  0.36
Other   |            | 0.1081     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311584 ave      311584 max      311584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311584
Ave neighs/atom = 77.896
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.690631412082, Press = -1.19958098212508
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  -13892.016     -13892.016     -14032.358     -14032.358      271.50169      271.50169      47841.365      47841.365     -1163.8291     -1163.8291    
     34000  -13893.27      -13893.27      -14035.005     -14035.005      274.19564      274.19564      47816.005      47816.005     -537.48435     -537.48435    
Loop time of 234.509 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.39     | 233.39     | 233.39     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16315    | 0.16315    | 0.16315    |   0.0 |  0.07
Output  | 0.00024069 | 0.00024069 | 0.00024069 |   0.0 |  0.00
Modify  | 0.84735    | 0.84735    | 0.84735    |   0.0 |  0.36
Other   |            | 0.1066     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311560 ave      311560 max      311560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311560
Ave neighs/atom = 77.89
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.688536636474, Press = 1.80068064227758
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  -13893.27      -13893.27      -14035.005     -14035.005      274.19564      274.19564      47816.005      47816.005     -537.48435     -537.48435    
     35000  -13890.046     -13890.046     -14032.484     -14032.484      275.55655      275.55655      47763.393      47763.393      1180.5334      1180.5334    
Loop time of 234.354 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.22     | 233.22     | 233.22     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16492    | 0.16492    | 0.16492    |   0.0 |  0.07
Output  | 0.00030508 | 0.00030508 | 0.00030508 |   0.0 |  0.00
Modify  | 0.85828    | 0.85828    | 0.85828    |   0.0 |  0.37
Other   |            | 0.1067     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311634 ave      311634 max      311634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311634
Ave neighs/atom = 77.9085
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.664191581229, Press = -0.0719215850662041
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  -13890.046     -13890.046     -14032.484     -14032.484      275.55655      275.55655      47763.393      47763.393      1180.5334      1180.5334    
     36000  -13895.362     -13895.362     -14034.587     -14034.587      269.34037      269.34037      47834.728      47834.728     -955.96175     -955.96175    
Loop time of 208.315 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.415 ns/day, 57.865 hours/ns, 4.800 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 207.35     | 207.35     | 207.35     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1447     | 0.1447     | 0.1447     |   0.0 |  0.07
Output  | 0.00023692 | 0.00023692 | 0.00023692 |   0.0 |  0.00
Modify  | 0.71911    | 0.71911    | 0.71911    |   0.0 |  0.35
Other   |            | 0.09846    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311622 ave      311622 max      311622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311622
Ave neighs/atom = 77.9055
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.566030858536, Press = -0.172785750867752
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  -13895.362     -13895.362     -14034.587     -14034.587      269.34037      269.34037      47834.728      47834.728     -955.96175     -955.96175    
     37000  -13891.018     -13891.018     -14032.647     -14032.647      273.99067      273.99067      47808.679      47808.679     -253.55273     -253.55273    
Loop time of 197.301 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.806 hours/ns, 5.068 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.4      | 196.4      | 196.4      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13806    | 0.13806    | 0.13806    |   0.0 |  0.07
Output  | 0.00019476 | 0.00019476 | 0.00019476 |   0.0 |  0.00
Modify  | 0.66452    | 0.66452    | 0.66452    |   0.0 |  0.34
Other   |            | 0.09474    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311622 ave      311622 max      311622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311622
Ave neighs/atom = 77.9055
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.519591427755, Press = 1.43429416432629
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  -13891.018     -13891.018     -14032.647     -14032.647      273.99067      273.99067      47808.679      47808.679     -253.55273     -253.55273    
     38000  -13896.551     -13896.551     -14034.979     -14034.979      267.79842      267.79842      47782.541      47782.541      187.00423      187.00423    
Loop time of 197.543 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.873 hours/ns, 5.062 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.64     | 196.64     | 196.64     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13867    | 0.13867    | 0.13867    |   0.0 |  0.07
Output  | 0.00019116 | 0.00019116 | 0.00019116 |   0.0 |  0.00
Modify  | 0.66855    | 0.66855    | 0.66855    |   0.0 |  0.34
Other   |            | 0.0958     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311646 ave      311646 max      311646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311646
Ave neighs/atom = 77.9115
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.479442259109, Press = 0.518708253868879
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  -13896.551     -13896.551     -14034.979     -14034.979      267.79842      267.79842      47782.541      47782.541      187.00423      187.00423    
     39000  -13893.775     -13893.775     -14032.354     -14032.354      268.09092      268.09092      47807.376      47807.376     -209.20034     -209.20034    
Loop time of 197.59 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.886 hours/ns, 5.061 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.69     | 196.69     | 196.69     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13951    | 0.13951    | 0.13951    |   0.0 |  0.07
Output  | 0.00019316 | 0.00019316 | 0.00019316 |   0.0 |  0.00
Modify  | 0.66896    | 0.66896    | 0.66896    |   0.0 |  0.34
Other   |            | 0.09535    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311688 ave      311688 max      311688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311688
Ave neighs/atom = 77.922
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.496085699077, Press = 0.664445543468201
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  -13893.775     -13893.775     -14032.354     -14032.354      268.09092      268.09092      47807.376      47807.376     -209.20034     -209.20034    
     40000  -13888.014     -13888.014     -14031.978     -14031.978      278.50759      278.50759      47780.111      47780.111      673.07996      673.07996    
Loop time of 197.431 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.842 hours/ns, 5.065 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.53     | 196.53     | 196.53     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1394     | 0.1394     | 0.1394     |   0.0 |  0.07
Output  | 0.00019409 | 0.00019409 | 0.00019409 |   0.0 |  0.00
Modify  | 0.6672     | 0.6672     | 0.6672     |   0.0 |  0.34
Other   |            | 0.0945     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311648 ave      311648 max      311648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311648
Ave neighs/atom = 77.912
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.524441562174, Press = 0.158621357265066
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  -13888.014     -13888.014     -14031.978     -14031.978      278.50759      278.50759      47780.111      47780.111      673.07996      673.07996    
     41000  -13890.42      -13890.42      -14034.969     -14034.969      279.63933      279.63933      47867.706      47867.706     -1674.2275     -1674.2275    
Loop time of 197.193 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.776 hours/ns, 5.071 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.29     | 196.29     | 196.29     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.138      | 0.138      | 0.138      |   0.0 |  0.07
Output  | 0.00023828 | 0.00023828 | 0.00023828 |   0.0 |  0.00
Modify  | 0.66551    | 0.66551    | 0.66551    |   0.0 |  0.34
Other   |            | 0.09497    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311646 ave      311646 max      311646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311646
Ave neighs/atom = 77.9115
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.527282166936, Press = -0.299862402423623
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  -13890.42      -13890.42      -14034.969     -14034.969      279.63933      279.63933      47867.706      47867.706     -1674.2275     -1674.2275    
     42000  -13894.157     -13894.157     -14033.599     -14033.599      269.76051      269.76051      47790.252      47790.252      258.29498      258.29498    
Loop time of 197.634 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.898 hours/ns, 5.060 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.73     | 196.73     | 196.73     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13847    | 0.13847    | 0.13847    |   0.0 |  0.07
Output  | 0.00019255 | 0.00019255 | 0.00019255 |   0.0 |  0.00
Modify  | 0.66774    | 0.66774    | 0.66774    |   0.0 |  0.34
Other   |            | 0.09473    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311592 ave      311592 max      311592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311592
Ave neighs/atom = 77.898
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.551910787827, Press = 1.76271558215561
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  -13894.157     -13894.157     -14033.599     -14033.599      269.76051      269.76051      47790.252      47790.252      258.29498      258.29498    
     43000  -13893.357     -13893.357     -14033.549     -14033.549      271.21076      271.21076      47756.97       47756.97       1242.1776      1242.1776    
Loop time of 197.239 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.789 hours/ns, 5.070 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.34     | 196.34     | 196.34     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13836    | 0.13836    | 0.13836    |   0.0 |  0.07
Output  | 0.00019557 | 0.00019557 | 0.00019557 |   0.0 |  0.00
Modify  | 0.66681    | 0.66681    | 0.66681    |   0.0 |  0.34
Other   |            | 0.09487    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311634 ave      311634 max      311634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311634
Ave neighs/atom = 77.9085
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.537742495008, Press = -0.139448767129691
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  -13893.357     -13893.357     -14033.549     -14033.549      271.21076      271.21076      47756.97       47756.97       1242.1776      1242.1776    
     44000  -13890.872     -13890.872     -14034.309     -14034.309      277.48869      277.48869      47847.292      47847.292     -1228.5868     -1228.5868    
Loop time of 197.205 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.779 hours/ns, 5.071 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.31     | 196.31     | 196.31     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13787    | 0.13787    | 0.13787    |   0.0 |  0.07
Output  | 0.00024077 | 0.00024077 | 0.00024077 |   0.0 |  0.00
Modify  | 0.6649     | 0.6649     | 0.6649     |   0.0 |  0.34
Other   |            | 0.09537    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311700 ave      311700 max      311700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311700
Ave neighs/atom = 77.925
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.533806147703, Press = -0.121976073059263
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  -13890.872     -13890.872     -14034.309     -14034.309      277.48869      277.48869      47847.292      47847.292     -1228.5868     -1228.5868    
     45000  -13891.191     -13891.191     -14033.72      -14033.72       275.73169      275.73169      47801.061      47801.061     -93.700728     -93.700728    
Loop time of 197.149 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.764 hours/ns, 5.072 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.25     | 196.25     | 196.25     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13877    | 0.13877    | 0.13877    |   0.0 |  0.07
Output  | 0.00019135 | 0.00019135 | 0.00019135 |   0.0 |  0.00
Modify  | 0.66446    | 0.66446    | 0.66446    |   0.0 |  0.34
Other   |            | 0.09512    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311620 ave      311620 max      311620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311620
Ave neighs/atom = 77.905
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.522543934049, Press = 0.762297915360042
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  -13891.191     -13891.191     -14033.72      -14033.72       275.73169      275.73169      47801.061      47801.061     -93.700728     -93.700728    
     46000  -13893.496     -13893.496     -14035.232     -14035.232      274.19775      274.19775      47796.488      47796.488      45.324866      45.324866    
Loop time of 197.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.781 hours/ns, 5.071 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.31     | 196.31     | 196.31     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13749    | 0.13749    | 0.13749    |   0.0 |  0.07
Output  | 0.00019252 | 0.00019252 | 0.00019252 |   0.0 |  0.00
Modify  | 0.66593    | 0.66593    | 0.66593    |   0.0 |  0.34
Other   |            | 0.09502    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311610 ave      311610 max      311610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311610
Ave neighs/atom = 77.9025
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.475263758563, Press = 0.112297050678051
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  -13893.496     -13893.496     -14035.232     -14035.232      274.19775      274.19775      47796.488      47796.488      45.324866      45.324866    
     47000  -13895.893     -13895.893     -14033.59      -14033.59       266.3848       266.3848       47806.232      47806.232     -269.28777     -269.28777    
Loop time of 197.232 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.787 hours/ns, 5.070 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.33     | 196.33     | 196.33     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13869    | 0.13869    | 0.13869    |   0.0 |  0.07
Output  | 0.00024055 | 0.00024055 | 0.00024055 |   0.0 |  0.00
Modify  | 0.66682    | 0.66682    | 0.66682    |   0.0 |  0.34
Other   |            | 0.09426    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311652 ave      311652 max      311652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311652
Ave neighs/atom = 77.913
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.451438121131, Press = 0.258224297075925
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  -13895.893     -13895.893     -14033.59      -14033.59       266.3848       266.3848       47806.232      47806.232     -269.28777     -269.28777    
     48000  -13893.48      -13893.48      -14034.739     -14034.739      273.27452      273.27452      47802.074      47802.074     -142.53194     -142.53194    
Loop time of 197.376 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.827 hours/ns, 5.066 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.48     | 196.48     | 196.48     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13816    | 0.13816    | 0.13816    |   0.0 |  0.07
Output  | 0.00019317 | 0.00019317 | 0.00019317 |   0.0 |  0.00
Modify  | 0.66702    | 0.66702    | 0.66702    |   0.0 |  0.34
Other   |            | 0.09518    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311650 ave      311650 max      311650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311650
Ave neighs/atom = 77.9125
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.432941912273, Press = 0.619610024370999
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  -13893.48      -13893.48      -14034.739     -14034.739      273.27452      273.27452      47802.074      47802.074     -142.53194     -142.53194    
     49000  -13888.248     -13888.248     -14032.31      -14032.31       278.69786      278.69786      47749.775      47749.775      1469.3438      1469.3438    
Loop time of 197.314 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.809 hours/ns, 5.068 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.41     | 196.41     | 196.41     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13791    | 0.13791    | 0.13791    |   0.0 |  0.07
Output  | 0.00023434 | 0.00023434 | 0.00023434 |   0.0 |  0.00
Modify  | 0.66591    | 0.66591    | 0.66591    |   0.0 |  0.34
Other   |            | 0.09504    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311638 ave      311638 max      311638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311638
Ave neighs/atom = 77.9095
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.457384435808, Press = 0.126384675125507
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  -13888.248     -13888.248     -14032.31      -14032.31       278.69786      278.69786      47749.775      47749.775      1469.3438      1469.3438    
     50000  -13890.871     -13890.871     -14033.044     -14033.044      275.04376      275.04376      47831.054      47831.054     -944.73582     -944.73582    
Loop time of 197.504 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.862 hours/ns, 5.063 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.6      | 196.6      | 196.6      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13928    | 0.13928    | 0.13928    |   0.0 |  0.07
Output  | 0.00019181 | 0.00019181 | 0.00019181 |   0.0 |  0.00
Modify  | 0.66765    | 0.66765    | 0.66765    |   0.0 |  0.34
Other   |            | 0.09469    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311644 ave      311644 max      311644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311644
Ave neighs/atom = 77.911
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.46160507728, Press = -0.126423304822189
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  -13890.871     -13890.871     -14033.044     -14033.044      275.04376      275.04376      47831.054      47831.054     -944.73582     -944.73582    
     51000  -13891.11      -13891.11      -14034.141     -14034.141      276.70217      276.70217      47814.215      47814.215     -82.500489     -82.500489    
Loop time of 197.151 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.764 hours/ns, 5.072 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.25     | 196.25     | 196.25     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13875    | 0.13875    | 0.13875    |   0.0 |  0.07
Output  | 0.00019087 | 0.00019087 | 0.00019087 |   0.0 |  0.00
Modify  | 0.66466    | 0.66466    | 0.66466    |   0.0 |  0.34
Other   |            | 0.09557    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311662 ave      311662 max      311662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311662
Ave neighs/atom = 77.9155
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.429754064006, Press = 0.850371581503777
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  -13891.11      -13891.11      -14034.141     -14034.141      276.70217      276.70217      47814.215      47814.215     -82.500489     -82.500489    
     52000  -13894.185     -13894.185     -14034.276     -14034.276      271.01603      271.01603      47739.003      47739.003      1818.0626      1818.0626    
Loop time of 197.488 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.858 hours/ns, 5.064 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.59     | 196.59     | 196.59     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13814    | 0.13814    | 0.13814    |   0.0 |  0.07
Output  | 0.00050069 | 0.00050069 | 0.00050069 |   0.0 |  0.00
Modify  | 0.66659    | 0.66659    | 0.66659    |   0.0 |  0.34
Other   |            | 0.09424    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311630 ave      311630 max      311630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311630
Ave neighs/atom = 77.9075
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.42624614164, Press = 0.658060428373241
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  -13894.185     -13894.185     -14034.276     -14034.276      271.01603      271.01603      47739.003      47739.003      1818.0626      1818.0626    
     53000  -13897.162     -13897.162     -14036.278     -14036.278      269.12801      269.12801      47774.182      47774.182      648.40879      648.40879    
Loop time of 197.381 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.828 hours/ns, 5.066 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.48     | 196.48     | 196.48     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13879    | 0.13879    | 0.13879    |   0.0 |  0.07
Output  | 0.0001935  | 0.0001935  | 0.0001935  |   0.0 |  0.00
Modify  | 0.66586    | 0.66586    | 0.66586    |   0.0 |  0.34
Other   |            | 0.09516    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311654 ave      311654 max      311654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311654
Ave neighs/atom = 77.9135
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.399178511977, Press = -0.815892966040889
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  -13897.162     -13897.162     -14036.278     -14036.278      269.12801      269.12801      47774.182      47774.182      648.40879      648.40879    
     54000  -13891.963     -13891.963     -14034.067     -14034.067      274.90837      274.90837      47858.328      47858.328     -1682.6244     -1682.6244    
Loop time of 196.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.568 hours/ns, 5.090 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.55     | 195.55     | 195.55     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13819    | 0.13819    | 0.13819    |   0.0 |  0.07
Output  | 0.00018076 | 0.00018076 | 0.00018076 |   0.0 |  0.00
Modify  | 0.6638     | 0.6638     | 0.6638     |   0.0 |  0.34
Other   |            | 0.09418    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311700 ave      311700 max      311700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311700
Ave neighs/atom = 77.925
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.38198817064, Press = -0.286228469337991
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  -13891.963     -13891.963     -14034.067     -14034.067      274.90837      274.90837      47858.328      47858.328     -1682.6244     -1682.6244    
     55000  -13891.075     -13891.075     -14033.236     -14033.236      275.02024      275.02024      47808.703      47808.703     -156.901       -156.901      
Loop time of 188.338 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.459 ns/day, 52.316 hours/ns, 5.310 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 187.47     | 187.47     | 187.47     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13428    | 0.13428    | 0.13428    |   0.0 |  0.07
Output  | 0.00019202 | 0.00019202 | 0.00019202 |   0.0 |  0.00
Modify  | 0.63815    | 0.63815    | 0.63815    |   0.0 |  0.34
Other   |            | 0.09234    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311612 ave      311612 max      311612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311612
Ave neighs/atom = 77.903
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.347471601781, Press = 0.842476125032698
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  -13891.075     -13891.075     -14033.236     -14033.236      275.02024      275.02024      47808.703      47808.703     -156.901       -156.901      
     56000  -13889.21      -13889.21      -14034.381     -14034.381      280.84277      280.84277      47784.66       47784.66       672.2215       672.2215     
Loop time of 188.175 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.459 ns/day, 52.271 hours/ns, 5.314 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 187.31     | 187.31     | 187.31     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13354    | 0.13354    | 0.13354    |   0.0 |  0.07
Output  | 0.00018162 | 0.00018162 | 0.00018162 |   0.0 |  0.00
Modify  | 0.63973    | 0.63973    | 0.63973    |   0.0 |  0.34
Other   |            | 0.09207    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311682 ave      311682 max      311682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311682
Ave neighs/atom = 77.9205
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.320197789841, Press = 0.269527382490675
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   
     56000  -13889.21      -13889.21      -14034.381     -14034.381      280.84277      280.84277      47784.66       47784.66       672.2215       672.2215     
     57000  -13893.358     -13893.358     -14036.508     -14036.508      276.93392      276.93392      47781.285      47781.285      655.06575      655.06575    
Loop time of 189.328 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.456 ns/day, 52.591 hours/ns, 5.282 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 188.46     | 188.46     | 188.46     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13395    | 0.13395    | 0.13395    |   0.0 |  0.07
Output  | 0.00019262 | 0.00019262 | 0.00019262 |   0.0 |  0.00
Modify  | 0.64162    | 0.64162    | 0.64162    |   0.0 |  0.34
Other   |            | 0.09283    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311690 ave      311690 max      311690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311690
Ave neighs/atom = 77.9225
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.334014009615, Press = 0.284366487353567
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   
     57000  -13893.358     -13893.358     -14036.508     -14036.508      276.93392      276.93392      47781.285      47781.285      655.06575      655.06575    
     58000  -13890.881     -13890.881     -14033.167     -14033.167      275.26159      275.26159      47818.786      47818.786     -439.1137      -439.1137     
Loop time of 192.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.449 ns/day, 53.490 hours/ns, 5.193 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.68     | 191.68     | 191.68     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1354     | 0.1354     | 0.1354     |   0.0 |  0.07
Output  | 0.00018191 | 0.00018191 | 0.00018191 |   0.0 |  0.00
Modify  | 0.65251    | 0.65251    | 0.65251    |   0.0 |  0.34
Other   |            | 0.09307    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311650 ave      311650 max      311650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311650
Ave neighs/atom = 77.9125
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.379426893794, Press = -0.111585827391535
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   
     58000  -13890.881     -13890.881     -14033.167     -14033.167      275.26159      275.26159      47818.786      47818.786     -439.1137      -439.1137     
     59000  -13893.428     -13893.428     -14032.559     -14032.559      269.15877      269.15877      47818.9        47818.9       -602.64897     -602.64897    
Loop time of 187.521 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.461 ns/day, 52.089 hours/ns, 5.333 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 186.66     | 186.66     | 186.66     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13227    | 0.13227    | 0.13227    |   0.0 |  0.07
Output  | 0.0001819  | 0.0001819  | 0.0001819  |   0.0 |  0.00
Modify  | 0.636      | 0.636      | 0.636      |   0.0 |  0.34
Other   |            | 0.09187    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311602 ave      311602 max      311602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311602
Ave neighs/atom = 77.9005
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.372262593388, Press = 1.06923423377921
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   
     59000  -13893.428     -13893.428     -14032.559     -14032.559      269.15877      269.15877      47818.9        47818.9       -602.64897     -602.64897    
     60000  -13895.399     -13895.399     -14036.552     -14036.552      273.06996      273.06996      47715.944      47715.944      2396.8264      2396.8264    
Loop time of 189.077 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.457 ns/day, 52.521 hours/ns, 5.289 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 188.21     | 188.21     | 188.21     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13386    | 0.13386    | 0.13386    |   0.0 |  0.07
Output  | 0.00018132 | 0.00018132 | 0.00018132 |   0.0 |  0.00
Modify  | 0.64338    | 0.64338    | 0.64338    |   0.0 |  0.34
Other   |            | 0.09195    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311604 ave      311604 max      311604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311604
Ave neighs/atom = 77.901
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.373096743336, Press = 0.194236971725091
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   
     60000  -13895.399     -13895.399     -14036.552     -14036.552      273.06996      273.06996      47715.944      47715.944      2396.8264      2396.8264    
     61000  -13891.602     -13891.602     -14032.489     -14032.489      272.55624      272.55624      47822.234      47822.234     -514.17818     -514.17818    
Loop time of 188.085 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.459 ns/day, 52.246 hours/ns, 5.317 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 187.22     | 187.22     | 187.22     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13216    | 0.13216    | 0.13216    |   0.0 |  0.07
Output  | 0.00018189 | 0.00018189 | 0.00018189 |   0.0 |  0.00
Modify  | 0.63927    | 0.63927    | 0.63927    |   0.0 |  0.34
Other   |            | 0.09181    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       311744 ave      311744 max      311744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311744
Ave neighs/atom = 77.936
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
47801.0909266135

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0