# 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.613315641880036*${_u_distance}
variable latticeconst_converted equal 3.613315641880036*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331564188004
Lattice spacing in x,y,z = 3.6133156 3.6133156 3.6133156
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.133156 36.133156 36.133156)
  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.133156 36.133156 36.133156)
  create_atoms CPU = 0.003 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_WangOhLee_2020_CuCo__MO_694335101831_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 47175.6294254851    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6294254851/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6294254851/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6294254851/(1*1*${_u_distance})
variable      V0_metal equal 47175.6294254851/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 47175.6294254851*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6294254851 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_694335101831_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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14018.806     -14018.806     -14160         -14160          273.15         273.15         47175.629      47175.629      3196.8159      3196.8159    
      1000  -13870.076     -13870.076     -14014.445     -14014.445      279.29183      279.29183      47934.911      47934.911     -1401.2817     -1401.2817    
Loop time of 358.969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.241 ns/day, 99.714 hours/ns, 2.786 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 358.05     | 358.05     | 358.05     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14988    | 0.14988    | 0.14988    |   0.0 |  0.04
Output  | 0.0003382  | 0.0003382  | 0.0003382  |   0.0 |  0.00
Modify  | 0.67247    | 0.67247    | 0.67247    |   0.0 |  0.19
Other   |            | 0.096      |            |       |  0.03

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

Total # of neighbors = 536000
Ave neighs/atom = 134
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13870.076     -13870.076     -14014.445     -14014.445      279.29183      279.29183      47934.911      47934.911     -1401.2817     -1401.2817    
      2000  -13879.752     -13879.752     -14022.361     -14022.361      275.88555      275.88555      47875.069      47875.069     -480.35094     -480.35094    
Loop time of 332.908 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.474 hours/ns, 3.004 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 331.97     | 331.97     | 331.97     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14769    | 0.14769    | 0.14769    |   0.0 |  0.04
Output  | 0.00027675 | 0.00027675 | 0.00027675 |   0.0 |  0.00
Modify  | 0.68956    | 0.68956    | 0.68956    |   0.0 |  0.21
Other   |            | 0.09806    |            |       |  0.03

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

Total # of neighbors = 442046
Ave neighs/atom = 110.5115
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13879.752     -13879.752     -14022.361     -14022.361      275.88555      275.88555      47875.069      47875.069     -480.35094     -480.35094    
      3000  -13877.049     -13877.049     -14021.487     -14021.487      279.42415      279.42415      47890.152      47890.152     -639.83337     -639.83337    
Loop time of 340.269 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.519 hours/ns, 2.939 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.3      | 339.3      | 339.3      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15163    | 0.15163    | 0.15163    |   0.0 |  0.04
Output  | 0.0002297  | 0.0002297  | 0.0002297  |   0.0 |  0.00
Modify  | 0.71681    | 0.71681    | 0.71681    |   0.0 |  0.21
Other   |            | 0.101      |            |       |  0.03

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

Total # of neighbors = 443714
Ave neighs/atom = 110.9285
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13877.049     -13877.049     -14021.487     -14021.487      279.42415      279.42415      47890.152      47890.152     -639.83337     -639.83337    
      4000  -13877.12      -13877.12      -14018.007     -14018.007      272.55582      272.55582      47905.817      47905.817     -856.44933     -856.44933    
Loop time of 337.813 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.837 hours/ns, 2.960 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.86     | 336.86     | 336.86     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15007    | 0.15007    | 0.15007    |   0.0 |  0.04
Output  | 0.00027585 | 0.00027585 | 0.00027585 |   0.0 |  0.00
Modify  | 0.70283    | 0.70283    | 0.70283    |   0.0 |  0.21
Other   |            | 0.1003     |            |       |  0.03

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

Total # of neighbors = 443506
Ave neighs/atom = 110.8765
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13877.12      -13877.12      -14018.007     -14018.007      272.55582      272.55582      47905.817      47905.817     -856.44933     -856.44933    
      5000  -13880.22      -13880.22      -14017.363     -14017.363      265.31182      265.31182      47860.951      47860.951      513.55741      513.55741    
Loop time of 339.569 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.325 hours/ns, 2.945 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.61     | 338.61     | 338.61     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14983    | 0.14983    | 0.14983    |   0.0 |  0.04
Output  | 0.00019066 | 0.00019066 | 0.00019066 |   0.0 |  0.00
Modify  | 0.7066     | 0.7066     | 0.7066     |   0.0 |  0.21
Other   |            | 0.09954    |            |       |  0.03

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

Total # of neighbors = 442858
Ave neighs/atom = 110.7145
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 = 274.452432321728, Press = 727.423149769776
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13880.22      -13880.22      -14017.363     -14017.363      265.31182      265.31182      47860.951      47860.951      513.55741      513.55741    
      6000  -13874.143     -13874.143     -14020.344     -14020.344      282.83644      282.83644      47823.358      47823.358      1491.2023      1491.2023    
Loop time of 337.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.818 hours/ns, 2.961 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.77     | 336.77     | 336.77     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14928    | 0.14928    | 0.14928    |   0.0 |  0.04
Output  | 0.00018832 | 0.00018832 | 0.00018832 |   0.0 |  0.00
Modify  | 0.7296     | 0.7296     | 0.7296     |   0.0 |  0.22
Other   |            | 0.0988     |            |       |  0.03

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

Total # of neighbors = 444602
Ave neighs/atom = 111.1505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.610071860466, Press = 17.7903324634525
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13874.143     -13874.143     -14020.344     -14020.344      282.83644      282.83644      47823.358      47823.358      1491.2023      1491.2023    
      7000  -13880.514     -13880.514     -14019.502     -14019.502      268.88252      268.88252      47908.507      47908.507     -1036.1867     -1036.1867    
Loop time of 337.388 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.719 hours/ns, 2.964 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.41     | 336.41     | 336.41     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14971    | 0.14971    | 0.14971    |   0.0 |  0.04
Output  | 0.00019275 | 0.00019275 | 0.00019275 |   0.0 |  0.00
Modify  | 0.72573    | 0.72573    | 0.72573    |   0.0 |  0.22
Other   |            | 0.09933    |            |       |  0.03

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

Total # of neighbors = 445814
Ave neighs/atom = 111.4535
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.012114543449, Press = -4.48329116435763
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13880.514     -13880.514     -14019.502     -14019.502      268.88252      268.88252      47908.507      47908.507     -1036.1867     -1036.1867    
      8000  -13879.31      -13879.31      -14018.24      -14018.24       268.76918      268.76918      47900.154      47900.154     -711.71902     -711.71902    
Loop time of 336.828 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.563 hours/ns, 2.969 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.85     | 335.85     | 335.85     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14905    | 0.14905    | 0.14905    |   0.0 |  0.04
Output  | 0.00018753 | 0.00018753 | 0.00018753 |   0.0 |  0.00
Modify  | 0.72784    | 0.72784    | 0.72784    |   0.0 |  0.22
Other   |            | 0.0992     |            |       |  0.03

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

Total # of neighbors = 442684
Ave neighs/atom = 110.671
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.088072882087, Press = 19.953690299023
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13879.31      -13879.31      -14018.24      -14018.24       268.76918      268.76918      47900.154      47900.154     -711.71902     -711.71902    
      9000  -13873.264     -13873.264     -14014.598     -14014.598      273.41892      273.41892      47847.43       47847.43       1351.3959      1351.3959    
Loop time of 339.906 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.418 hours/ns, 2.942 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.92     | 338.92     | 338.92     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14965    | 0.14965    | 0.14965    |   0.0 |  0.04
Output  | 0.00019348 | 0.00019348 | 0.00019348 |   0.0 |  0.00
Modify  | 0.73681    | 0.73681    | 0.73681    |   0.0 |  0.22
Other   |            | 0.09951    |            |       |  0.03

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

Total # of neighbors = 443168
Ave neighs/atom = 110.792
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.383464303143, Press = 12.2281008929359
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13873.264     -13873.264     -14014.598     -14014.598      273.41892      273.41892      47847.43       47847.43       1351.3959      1351.3959    
     10000  -13875.848     -13875.848     -14016.169     -14016.169      271.46095      271.46095      47872.004      47872.004      394.42878      394.42878    
Loop time of 340.697 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.638 hours/ns, 2.935 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.71     | 339.71     | 339.71     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15038    | 0.15038    | 0.15038    |   0.0 |  0.04
Output  | 0.00024545 | 0.00024545 | 0.00024545 |   0.0 |  0.00
Modify  | 0.73438    | 0.73438    | 0.73438    |   0.0 |  0.22
Other   |            | 0.1002     |            |       |  0.03

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

Total # of neighbors = 444808
Ave neighs/atom = 111.202
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.298219266166, Press = 4.11257026109705
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13875.848     -13875.848     -14016.169     -14016.169      271.46095      271.46095      47872.004      47872.004      394.42878      394.42878    
     11000  -13880.74      -13880.74      -14018.7       -14018.7        266.89318      266.89318      47903.178      47903.178     -896.70056     -896.70056    
Loop time of 339.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.235 hours/ns, 2.948 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.27     | 338.27     | 338.27     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15004    | 0.15004    | 0.15004    |   0.0 |  0.04
Output  | 0.00019689 | 0.00019689 | 0.00019689 |   0.0 |  0.00
Modify  | 0.73148    | 0.73148    | 0.73148    |   0.0 |  0.22
Other   |            | 0.09915    |            |       |  0.03

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

Total # of neighbors = 444260
Ave neighs/atom = 111.065
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.181711734933, Press = 2.01454152232803
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13880.74      -13880.74      -14018.7       -14018.7        266.89318      266.89318      47903.178      47903.178     -896.70056     -896.70056    
     12000  -13879.029     -13879.029     -14019.863     -14019.863      272.45387      272.45387      47887.829      47887.829     -429.56659     -429.56659    
Loop time of 338.875 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.132 hours/ns, 2.951 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.9      | 337.9      | 337.9      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15115    | 0.15115    | 0.15115    |   0.0 |  0.04
Output  | 0.00024059 | 0.00024059 | 0.00024059 |   0.0 |  0.00
Modify  | 0.72854    | 0.72854    | 0.72854    |   0.0 |  0.21
Other   |            | 0.09976    |            |       |  0.03

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

Total # of neighbors = 443094
Ave neighs/atom = 110.7735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.921834806247, Press = 11.4619042436088
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13879.029     -13879.029     -14019.863     -14019.863      272.45387      272.45387      47887.829      47887.829     -429.56659     -429.56659    
     13000  -13879.086     -13879.086     -14020.59      -14020.59       273.74981      273.74981      47798.836      47798.836      2059.7649      2059.7649    
Loop time of 343.451 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.403 hours/ns, 2.912 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342.45     | 342.45     | 342.45     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15066    | 0.15066    | 0.15066    |   0.0 |  0.04
Output  | 0.00018686 | 0.00018686 | 0.00018686 |   0.0 |  0.00
Modify  | 0.7508     | 0.7508     | 0.7508     |   0.0 |  0.22
Other   |            | 0.1001     |            |       |  0.03

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

Total # of neighbors = 443856
Ave neighs/atom = 110.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.93982396027, Press = 2.55592050767051
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13879.086     -13879.086     -14020.59      -14020.59       273.74981      273.74981      47798.836      47798.836      2059.7649      2059.7649    
     14000  -13872.137     -13872.137     -14013.704     -14013.704      273.8704       273.8704       47913.941      47913.941     -537.52719     -537.52719    
Loop time of 344.263 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.251 ns/day, 95.629 hours/ns, 2.905 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 343.27     | 343.27     | 343.27     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14958    | 0.14958    | 0.14958    |   0.0 |  0.04
Output  | 0.00028584 | 0.00028584 | 0.00028584 |   0.0 |  0.00
Modify  | 0.74318    | 0.74318    | 0.74318    |   0.0 |  0.22
Other   |            | 0.09966    |            |       |  0.03

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

Total # of neighbors = 446728
Ave neighs/atom = 111.682
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.053899106397, Press = 0.995065230243491
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13872.137     -13872.137     -14013.704     -14013.704      273.8704       273.8704       47913.941      47913.941     -537.52719     -537.52719    
     15000  -13879.087     -13879.087     -14019.723     -14019.723      272.07033      272.07033      47872.853      47872.853     -92.749613     -92.749613    
Loop time of 341.682 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.912 hours/ns, 2.927 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.68     | 340.68     | 340.68     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15198    | 0.15198    | 0.15198    |   0.0 |  0.04
Output  | 0.0002309  | 0.0002309  | 0.0002309  |   0.0 |  0.00
Modify  | 0.74567    | 0.74567    | 0.74567    |   0.0 |  0.22
Other   |            | 0.1005     |            |       |  0.03

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

Total # of neighbors = 442524
Ave neighs/atom = 110.631
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.187713727609, Press = 3.89326154274001
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13879.087     -13879.087     -14019.723     -14019.723      272.07033      272.07033      47872.853      47872.853     -92.749613     -92.749613    
     16000  -13882.534     -13882.534     -14022.506     -14022.506      270.78406      270.78406      47843.477      47843.477      496.4608       496.4608     
Loop time of 340.001 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.445 hours/ns, 2.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.02     | 339.02     | 339.02     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15045    | 0.15045    | 0.15045    |   0.0 |  0.04
Output  | 0.00018722 | 0.00018722 | 0.00018722 |   0.0 |  0.00
Modify  | 0.7347     | 0.7347     | 0.7347     |   0.0 |  0.22
Other   |            | 0.09973    |            |       |  0.03

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

Total # of neighbors = 444502
Ave neighs/atom = 111.1255
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.159125087042, Press = 3.81869007416824
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13882.534     -13882.534     -14022.506     -14022.506      270.78406      270.78406      47843.477      47843.477      496.4608       496.4608     
     17000  -13874.859     -13874.859     -14016.184     -14016.184      273.40168      273.40168      47860.733      47860.733      749.66998      749.66998    
Loop time of 340.132 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.481 hours/ns, 2.940 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.14     | 339.14     | 339.14     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15013    | 0.15013    | 0.15013    |   0.0 |  0.04
Output  | 0.00018904 | 0.00018904 | 0.00018904 |   0.0 |  0.00
Modify  | 0.74383    | 0.74383    | 0.74383    |   0.0 |  0.22
Other   |            | 0.1013     |            |       |  0.03

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

Total # of neighbors = 445170
Ave neighs/atom = 111.2925
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.066263911268, Press = 1.52142139883643
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13874.859     -13874.859     -14016.184     -14016.184      273.40168      273.40168      47860.733      47860.733      749.66998      749.66998    
     18000  -13878.776     -13878.776     -14019.456     -14019.456      272.1545       272.1545       47905.879      47905.879     -1029.7436     -1029.7436    
Loop time of 340.483 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.579 hours/ns, 2.937 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.5      | 339.5      | 339.5      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14911    | 0.14911    | 0.14911    |   0.0 |  0.04
Output  | 0.00019239 | 0.00019239 | 0.00019239 |   0.0 |  0.00
Modify  | 0.7341     | 0.7341     | 0.7341     |   0.0 |  0.22
Other   |            | 0.09959    |            |       |  0.03

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

Total # of neighbors = 444796
Ave neighs/atom = 111.199
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.204386521797, Press = 0.340160312764099
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13878.776     -13878.776     -14019.456     -14019.456      272.1545       272.1545       47905.879      47905.879     -1029.7436     -1029.7436    
     19000  -13872.614     -13872.614     -14012.904     -14012.904      271.40184      271.40184      47911.367      47911.367     -425.91877     -425.91877    
Loop time of 343.905 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.251 ns/day, 95.529 hours/ns, 2.908 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342.9      | 342.9      | 342.9      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15071    | 0.15071    | 0.15071    |   0.0 |  0.04
Output  | 0.00018839 | 0.00018839 | 0.00018839 |   0.0 |  0.00
Modify  | 0.75697    | 0.75697    | 0.75697    |   0.0 |  0.22
Other   |            | 0.1007     |            |       |  0.03

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

Total # of neighbors = 442942
Ave neighs/atom = 110.7355
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.271030214531, Press = 4.28234574958768
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13872.614     -13872.614     -14012.904     -14012.904      271.40184      271.40184      47911.367      47911.367     -425.91877     -425.91877    
     20000  -13878.854     -13878.854     -14021.138     -14021.138      275.25793      275.25793      47801.164      47801.164      1901.1537      1901.1537    
Loop time of 337.871 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.853 hours/ns, 2.960 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.9      | 336.9      | 336.9      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14916    | 0.14916    | 0.14916    |   0.0 |  0.04
Output  | 0.00019053 | 0.00019053 | 0.00019053 |   0.0 |  0.00
Modify  | 0.72323    | 0.72323    | 0.72323    |   0.0 |  0.21
Other   |            | 0.09922    |            |       |  0.03

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

Total # of neighbors = 442822
Ave neighs/atom = 110.7055
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.281288966863, Press = 2.59563185735678
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13878.854     -13878.854     -14021.138     -14021.138      275.25793      275.25793      47801.164      47801.164      1901.1537      1901.1537    
     21000  -13877.937     -13877.937     -14019.828     -14019.828      274.49854      274.49854      47885.925      47885.925     -308.29313     -308.29313    
Loop time of 340.121 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.478 hours/ns, 2.940 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.14     | 339.14     | 339.14     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15001    | 0.15001    | 0.15001    |   0.0 |  0.04
Output  | 0.000193   | 0.000193   | 0.000193   |   0.0 |  0.00
Modify  | 0.73487    | 0.73487    | 0.73487    |   0.0 |  0.22
Other   |            | 0.09884    |            |       |  0.03

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

Total # of neighbors = 446962
Ave neighs/atom = 111.7405
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.318170266093, Press = -1.96267742381731
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13877.937     -13877.937     -14019.828     -14019.828      274.49854      274.49854      47885.925      47885.925     -308.29313     -308.29313    
     22000  -13871.593     -13871.593     -14015.362     -14015.362      278.13176      278.13176      47937.862      47937.862     -1380.783      -1380.783     
Loop time of 338.586 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.052 hours/ns, 2.953 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.61     | 337.61     | 337.61     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14916    | 0.14916    | 0.14916    |   0.0 |  0.04
Output  | 0.00019262 | 0.00019262 | 0.00019262 |   0.0 |  0.00
Modify  | 0.73079    | 0.73079    | 0.73079    |   0.0 |  0.22
Other   |            | 0.09871    |            |       |  0.03

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

Total # of neighbors = 444026
Ave neighs/atom = 111.0065
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.330020928248, Press = 3.18497826429292
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13871.593     -13871.593     -14015.362     -14015.362      278.13176      278.13176      47937.862      47937.862     -1380.783      -1380.783     
     23000  -13879.369     -13879.369     -14017.594     -14017.594      267.40631      267.40631      47845.709      47845.709      978.52828      978.52828    
Loop time of 335.433 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 93.176 hours/ns, 2.981 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 334.46     | 334.46     | 334.46     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14874    | 0.14874    | 0.14874    |   0.0 |  0.04
Output  | 0.00018885 | 0.00018885 | 0.00018885 |   0.0 |  0.00
Modify  | 0.72715    | 0.72715    | 0.72715    |   0.0 |  0.22
Other   |            | 0.09971    |            |       |  0.03

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

Total # of neighbors = 441634
Ave neighs/atom = 110.4085
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.394612307234, Press = 2.64500242131593
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13879.369     -13879.369     -14017.594     -14017.594      267.40631      267.40631      47845.709      47845.709      978.52828      978.52828    
     24000  -13873.859     -13873.859     -14017.55      -14017.55       277.98123      277.98123      47878.968      47878.968      153.10668      153.10668    
Loop time of 339.756 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.377 hours/ns, 2.943 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.77     | 338.77     | 338.77     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14985    | 0.14985    | 0.14985    |   0.0 |  0.04
Output  | 0.00019047 | 0.00019047 | 0.00019047 |   0.0 |  0.00
Modify  | 0.73217    | 0.73217    | 0.73217    |   0.0 |  0.22
Other   |            | 0.09912    |            |       |  0.03

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

Total # of neighbors = 445318
Ave neighs/atom = 111.3295
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.433385937013, Press = 0.828269039845982
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13873.859     -13873.859     -14017.55      -14017.55       277.98123      277.98123      47878.968      47878.968      153.10668      153.10668    
     25000  -13878.098     -13878.098     -14016.855     -14016.855      268.43342      268.43342      47901.751      47901.751     -532.5488      -532.5488     
Loop time of 336.714 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.532 hours/ns, 2.970 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.74     | 335.74     | 335.74     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14943    | 0.14943    | 0.14943    |   0.0 |  0.04
Output  | 0.00019422 | 0.00019422 | 0.00019422 |   0.0 |  0.00
Modify  | 0.72491    | 0.72491    | 0.72491    |   0.0 |  0.22
Other   |            | 0.09996    |            |       |  0.03

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

Total # of neighbors = 443810
Ave neighs/atom = 110.9525
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.454429104886, Press = 1.15702984043659
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13878.098     -13878.098     -14016.855     -14016.855      268.43342      268.43342      47901.751      47901.751     -532.5488      -532.5488     
     26000  -13874.24      -13874.24      -14015.494     -14015.494      273.26606      273.26606      47881.042      47881.042      324.0844       324.0844     
Loop time of 337.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.661 hours/ns, 2.966 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.21     | 336.21     | 336.21     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14919    | 0.14919    | 0.14919    |   0.0 |  0.04
Output  | 0.00025455 | 0.00025455 | 0.00025455 |   0.0 |  0.00
Modify  | 0.72515    | 0.72515    | 0.72515    |   0.0 |  0.22
Other   |            | 0.09914    |            |       |  0.03

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

Total # of neighbors = 442992
Ave neighs/atom = 110.748
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.534113614539, Press = 4.75863326319756
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13874.24      -13874.24      -14015.494     -14015.494      273.26606      273.26606      47881.042      47881.042      324.0844       324.0844     
     27000  -13875.238     -13875.238     -14015.396     -14015.396      271.14528      271.14528      47810.121      47810.121      2275.2224      2275.2224    
Loop time of 337.789 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.830 hours/ns, 2.960 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.81     | 336.81     | 336.81     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15061    | 0.15061    | 0.15061    |   0.0 |  0.04
Output  | 0.00022676 | 0.00022676 | 0.00022676 |   0.0 |  0.00
Modify  | 0.73397    | 0.73397    | 0.73397    |   0.0 |  0.22
Other   |            | 0.09875    |            |       |  0.03

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

Total # of neighbors = 443840
Ave neighs/atom = 110.96
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.50086662506, Press = 1.072994218184
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13875.238     -13875.238     -14015.396     -14015.396      271.14528      271.14528      47810.121      47810.121      2275.2224      2275.2224    
     28000  -13878.298     -13878.298     -14018.178     -14018.178      270.6079       270.6079       47901.868      47901.868     -597.78066     -597.78066    
Loop time of 339.088 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.191 hours/ns, 2.949 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.1      | 338.1      | 338.1      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1506     | 0.1506     | 0.1506     |   0.0 |  0.04
Output  | 0.00029921 | 0.00029921 | 0.00029921 |   0.0 |  0.00
Modify  | 0.73927    | 0.73927    | 0.73927    |   0.0 |  0.22
Other   |            | 0.09996    |            |       |  0.03

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

Total # of neighbors = 446118
Ave neighs/atom = 111.5295
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.524398160771, Press = -0.395083262774689
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13878.298     -13878.298     -14018.178     -14018.178      270.6079       270.6079       47901.868      47901.868     -597.78066     -597.78066    
     29000  -13876.316     -13876.316     -14017.586     -14017.586      273.29576      273.29576      47898.042      47898.042     -531.36041     -531.36041    
Loop time of 337.412 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.725 hours/ns, 2.964 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.43     | 336.43     | 336.43     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14965    | 0.14965    | 0.14965    |   0.0 |  0.04
Output  | 0.00024249 | 0.00024249 | 0.00024249 |   0.0 |  0.00
Modify  | 0.73493    | 0.73493    | 0.73493    |   0.0 |  0.22
Other   |            | 0.09936    |            |       |  0.03

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

Total # of neighbors = 443022
Ave neighs/atom = 110.7555
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.477259079575, Press = 2.40575104530339
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13876.316     -13876.316     -14017.586     -14017.586      273.29576      273.29576      47898.042      47898.042     -531.36041     -531.36041    
     30000  -13880.796     -13880.796     -14020.523     -14020.523      270.3125       270.3125       47838.931      47838.931      835.9657       835.9657     
Loop time of 338.966 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.157 hours/ns, 2.950 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.99     | 337.99     | 337.99     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14932    | 0.14932    | 0.14932    |   0.0 |  0.04
Output  | 0.00018689 | 0.00018689 | 0.00018689 |   0.0 |  0.00
Modify  | 0.72904    | 0.72904    | 0.72904    |   0.0 |  0.22
Other   |            | 0.09962    |            |       |  0.03

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

Total # of neighbors = 443192
Ave neighs/atom = 110.798
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.45083030333, Press = 1.49522572150214
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13880.796     -13880.796     -14020.523     -14020.523      270.3125       270.3125       47838.931      47838.931      835.9657       835.9657     
     31000  -13879.935     -13879.935     -14017.459     -14017.459      266.04815      266.04815      47855.672      47855.672      685.50568      685.50568    
Loop time of 340.912 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.698 hours/ns, 2.933 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.92     | 339.92     | 339.92     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15076    | 0.15076    | 0.15076    |   0.0 |  0.04
Output  | 0.00022973 | 0.00022973 | 0.00022973 |   0.0 |  0.00
Modify  | 0.73759    | 0.73759    | 0.73759    |   0.0 |  0.22
Other   |            | 0.1002     |            |       |  0.03

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

Total # of neighbors = 445040
Ave neighs/atom = 111.26
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.442632998933, Press = 0.984992784595329
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13879.935     -13879.935     -14017.459     -14017.459      266.04815      266.04815      47855.672      47855.672      685.50568      685.50568    
     32000  -13878.966     -13878.966     -14016.677     -14016.677      266.4102       266.4102       47899.183      47899.183     -554.47927     -554.47927    
Loop time of 336.062 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.350 hours/ns, 2.976 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.09     | 335.09     | 335.09     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1494     | 0.1494     | 0.1494     |   0.0 |  0.04
Output  | 0.00019152 | 0.00019152 | 0.00019152 |   0.0 |  0.00
Modify  | 0.7278     | 0.7278     | 0.7278     |   0.0 |  0.22
Other   |            | 0.09862    |            |       |  0.03

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

Total # of neighbors = 444672
Ave neighs/atom = 111.168
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.44252242871, Press = -0.621439092154511
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13878.966     -13878.966     -14016.677     -14016.677      266.4102       266.4102       47899.183      47899.183     -554.47927     -554.47927    
     33000  -13878.291     -13878.291     -14018.842     -14018.842      271.90611      271.90611      47919.19       47919.19      -1182.5023     -1182.5023    
Loop time of 338.052 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.903 hours/ns, 2.958 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.07     | 337.07     | 337.07     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15118    | 0.15118    | 0.15118    |   0.0 |  0.04
Output  | 0.0001883  | 0.0001883  | 0.0001883  |   0.0 |  0.00
Modify  | 0.73313    | 0.73313    | 0.73313    |   0.0 |  0.22
Other   |            | 0.09971    |            |       |  0.03

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

Total # of neighbors = 443170
Ave neighs/atom = 110.7925
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.356253330838, Press = 2.25594315728755
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13878.291     -13878.291     -14018.842     -14018.842      271.90611      271.90611      47919.19       47919.19      -1182.5023     -1182.5023    
     34000  -13877.34      -13877.34      -14019.773     -14019.773      275.54722      275.54722      47833.613      47833.613      1192.6666      1192.6666    
Loop time of 335.924 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.312 hours/ns, 2.977 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 334.95     | 334.95     | 334.95     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14944    | 0.14944    | 0.14944    |   0.0 |  0.04
Output  | 0.00019591 | 0.00019591 | 0.00019591 |   0.0 |  0.00
Modify  | 0.72704    | 0.72704    | 0.72704    |   0.0 |  0.22
Other   |            | 0.09895    |            |       |  0.03

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

Total # of neighbors = 442384
Ave neighs/atom = 110.596
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.354388385183, Press = 1.95429638612532
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13877.34      -13877.34      -14019.773     -14019.773      275.54722      275.54722      47833.613      47833.613      1192.6666      1192.6666    
     35000  -13878.826     -13878.826     -14020.564     -14020.564      274.20216      274.20216      47841.228      47841.228      862.68183      862.68183    
Loop time of 339.175 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.215 hours/ns, 2.948 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.19     | 338.19     | 338.19     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14902    | 0.14902    | 0.14902    |   0.0 |  0.04
Output  | 0.00019231 | 0.00019231 | 0.00019231 |   0.0 |  0.00
Modify  | 0.73294    | 0.73294    | 0.73294    |   0.0 |  0.22
Other   |            | 0.09882    |            |       |  0.03

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

Total # of neighbors = 445712
Ave neighs/atom = 111.428
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.368714339852, Press = 0.358732021755455
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13878.826     -13878.826     -14020.564     -14020.564      274.20216      274.20216      47841.228      47841.228      862.68183      862.68183    
     36000  -13878.725     -13878.725     -14017.535     -14017.535      268.53735      268.53735      47889.319      47889.319     -331.19512     -331.19512    
Loop time of 338.806 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.113 hours/ns, 2.952 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.83     | 337.83     | 337.83     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15009    | 0.15009    | 0.15009    |   0.0 |  0.04
Output  | 0.00023916 | 0.00023916 | 0.00023916 |   0.0 |  0.00
Modify  | 0.73031    | 0.73031    | 0.73031    |   0.0 |  0.22
Other   |            | 0.09971    |            |       |  0.03

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

Total # of neighbors = 445472
Ave neighs/atom = 111.368
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.379834743178, Press = 0.580102839370186
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13878.725     -13878.725     -14017.535     -14017.535      268.53735      268.53735      47889.319      47889.319     -331.19512     -331.19512    
     37000  -13874.806     -13874.806     -14016.055     -14016.055      273.2544       273.2544       47898.068      47898.068     -316.88146     -316.88146    
Loop time of 339.071 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.186 hours/ns, 2.949 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.08     | 338.08     | 338.08     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15075    | 0.15075    | 0.15075    |   0.0 |  0.04
Output  | 0.00019011 | 0.00019011 | 0.00019011 |   0.0 |  0.00
Modify  | 0.73639    | 0.73639    | 0.73639    |   0.0 |  0.22
Other   |            | 0.1        |            |       |  0.03

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

Total # of neighbors = 443562
Ave neighs/atom = 110.8905
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.376841756898, Press = 1.43643685691933
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13874.806     -13874.806     -14016.055     -14016.055      273.2544       273.2544       47898.068      47898.068     -316.88146     -316.88146    
     38000  -13879.622     -13879.622     -14020.258     -14020.258      272.07114      272.07114      47854.309      47854.309      502.49331      502.49331    
Loop time of 341.085 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.746 hours/ns, 2.932 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.09     | 340.09     | 340.09     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15045    | 0.15045    | 0.15045    |   0.0 |  0.04
Output  | 0.00023304 | 0.00023304 | 0.00023304 |   0.0 |  0.00
Modify  | 0.74403    | 0.74403    | 0.74403    |   0.0 |  0.22
Other   |            | 0.1001     |            |       |  0.03

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

Total # of neighbors = 443318
Ave neighs/atom = 110.8295
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.379722598517, Press = 0.978471147051806
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13879.622     -13879.622     -14020.258     -14020.258      272.07114      272.07114      47854.309      47854.309      502.49331      502.49331    
     39000  -13879.066     -13879.066     -14021.139     -14021.139      274.84897      274.84897      47869.063      47869.063     -109.87953     -109.87953    
Loop time of 340.442 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.567 hours/ns, 2.937 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.44     | 339.44     | 339.44     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15166    | 0.15166    | 0.15166    |   0.0 |  0.04
Output  | 0.00018932 | 0.00018932 | 0.00018932 |   0.0 |  0.00
Modify  | 0.74888    | 0.74888    | 0.74888    |   0.0 |  0.22
Other   |            | 0.09987    |            |       |  0.03

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

Total # of neighbors = 445070
Ave neighs/atom = 111.2675
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.377909119867, Press = 0.842540731968307
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13879.066     -13879.066     -14021.139     -14021.139      274.84897      274.84897      47869.063      47869.063     -109.87953     -109.87953    
     40000  -13873.652     -13873.652     -14018.071     -14018.071      279.38863      279.38863      47885.908      47885.908     -174.75078     -174.75078    
Loop time of 338.399 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.000 hours/ns, 2.955 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.42     | 337.42     | 337.42     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14967    | 0.14967    | 0.14967    |   0.0 |  0.04
Output  | 0.00019077 | 0.00019077 | 0.00019077 |   0.0 |  0.00
Modify  | 0.72747    | 0.72747    | 0.72747    |   0.0 |  0.21
Other   |            | 0.09952    |            |       |  0.03

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

Total # of neighbors = 444846
Ave neighs/atom = 111.2115
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.43222417225, Press = 1.05975850397791
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13873.652     -13873.652     -14018.071     -14018.071      279.38863      279.38863      47885.908      47885.908     -174.75078     -174.75078    
     41000  -13878.587     -13878.587     -14019.278     -14019.278      272.17503      272.17503      47808.855      47808.855      1832.7744      1832.7744    
Loop time of 340.022 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.451 hours/ns, 2.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.04     | 339.04     | 339.04     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15021    | 0.15021    | 0.15021    |   0.0 |  0.04
Output  | 0.00019313 | 0.00019313 | 0.00019313 |   0.0 |  0.00
Modify  | 0.7343     | 0.7343     | 0.7343     |   0.0 |  0.22
Other   |            | 0.0999     |            |       |  0.03

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

Total # of neighbors = 443544
Ave neighs/atom = 110.886
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.415790744364, Press = 0.854143667052651
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13878.587     -13878.587     -14019.278     -14019.278      272.17503      272.17503      47808.855      47808.855      1832.7744      1832.7744    
     42000  -13875.001     -13875.001     -14017.42      -14017.42       275.5188       275.5188       47926.981      47926.981     -1341.8059     -1341.8059    
Loop time of 341.567 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.880 hours/ns, 2.928 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.58     | 340.58     | 340.58     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14982    | 0.14982    | 0.14982    |   0.0 |  0.04
Output  | 0.00019183 | 0.00019183 | 0.00019183 |   0.0 |  0.00
Modify  | 0.73335    | 0.73335    | 0.73335    |   0.0 |  0.21
Other   |            | 0.09939    |            |       |  0.03

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

Total # of neighbors = 446534
Ave neighs/atom = 111.6335
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.400815652509, Press = -1.24612456786541
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13875.001     -13875.001     -14017.42      -14017.42       275.5188       275.5188       47926.981      47926.981     -1341.8059     -1341.8059    
     43000  -13878.307     -13878.307     -14019.465     -14019.465      273.08071      273.08071      47915.933      47915.933     -1210.2345     -1210.2345    
Loop time of 340.712 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.642 hours/ns, 2.935 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.72     | 339.72     | 339.72     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15038    | 0.15038    | 0.15038    |   0.0 |  0.04
Output  | 0.00023012 | 0.00023012 | 0.00023012 |   0.0 |  0.00
Modify  | 0.74017    | 0.74017    | 0.74017    |   0.0 |  0.22
Other   |            | 0.1002     |            |       |  0.03

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

Total # of neighbors = 442344
Ave neighs/atom = 110.586
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.394552400884, Press = 1.34166997410076
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13878.307     -13878.307     -14019.465     -14019.465      273.08071      273.08071      47915.933      47915.933     -1210.2345     -1210.2345    
     44000  -13869.947     -13869.947     -14013.606     -14013.606      277.91772      277.91772      47858.367      47858.367      1133.572       1133.572     
Loop time of 338.46 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.017 hours/ns, 2.955 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.47     | 337.47     | 337.47     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14936    | 0.14936    | 0.14936    |   0.0 |  0.04
Output  | 0.00020837 | 0.00020837 | 0.00020837 |   0.0 |  0.00
Modify  | 0.73596    | 0.73596    | 0.73596    |   0.0 |  0.22
Other   |            | 0.09988    |            |       |  0.03

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

Total # of neighbors = 442482
Ave neighs/atom = 110.6205
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.415043906429, Press = 1.51072910686343
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13869.947     -13869.947     -14013.606     -14013.606      277.91772      277.91772      47858.367      47858.367      1133.572       1133.572     
     45000  -13879.18      -13879.18      -14019.61      -14019.61       271.67227      271.67227      47866.843      47866.843      198.29216      198.29216    
Loop time of 341.39 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.830 hours/ns, 2.929 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.39     | 340.39     | 340.39     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15085    | 0.15085    | 0.15085    |   0.0 |  0.04
Output  | 0.00019087 | 0.00019087 | 0.00019087 |   0.0 |  0.00
Modify  | 0.74565    | 0.74565    | 0.74565    |   0.0 |  0.22
Other   |            | 0.1004     |            |       |  0.03

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

Total # of neighbors = 444626
Ave neighs/atom = 111.1565
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.435612959789, Press = 0.0641511791460661
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13879.18      -13879.18      -14019.61      -14019.61       271.67227      271.67227      47866.843      47866.843      198.29216      198.29216    
     46000  -13880.482     -13880.482     -14018.286     -14018.286      266.59154      266.59154      47901.421      47901.421     -791.26727     -791.26727    
Loop time of 339.141 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.206 hours/ns, 2.949 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.16     | 338.16     | 338.16     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15031    | 0.15031    | 0.15031    |   0.0 |  0.04
Output  | 0.00025101 | 0.00025101 | 0.00025101 |   0.0 |  0.00
Modify  | 0.73169    | 0.73169    | 0.73169    |   0.0 |  0.22
Other   |            | 0.09952    |            |       |  0.03

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

Total # of neighbors = 444264
Ave neighs/atom = 111.066
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.418357491526, Press = 0.72201507915541
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13880.482     -13880.482     -14018.286     -14018.286      266.59154      266.59154      47901.421      47901.421     -791.26727     -791.26727    
     47000  -13874.61      -13874.61      -14016.567     -14016.567      274.62582      274.62582      47884.761      47884.761      51.80073       51.80073     
Loop time of 339.46 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.295 hours/ns, 2.946 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.48     | 338.48     | 338.48     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1492     | 0.1492     | 0.1492     |   0.0 |  0.04
Output  | 0.00023549 | 0.00023549 | 0.00023549 |   0.0 |  0.00
Modify  | 0.73686    | 0.73686    | 0.73686    |   0.0 |  0.22
Other   |            | 0.09882    |            |       |  0.03

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

Total # of neighbors = 443120
Ave neighs/atom = 110.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 = 273.383678876924, Press = 1.07834724611442
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13874.61      -13874.61      -14016.567     -14016.567      274.62582      274.62582      47884.761      47884.761      51.80073       51.80073     
     48000  -13879.932     -13879.932     -14019.968     -14019.968      270.90845      270.90845      47870.121      47870.121     -33.042177     -33.042177    
Loop time of 338.888 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.136 hours/ns, 2.951 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.9      | 337.9      | 337.9      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15041    | 0.15041    | 0.15041    |   0.0 |  0.04
Output  | 0.00023172 | 0.00023172 | 0.00023172 |   0.0 |  0.00
Modify  | 0.73783    | 0.73783    | 0.73783    |   0.0 |  0.22
Other   |            | 0.1006     |            |       |  0.03

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

Total # of neighbors = 443970
Ave neighs/atom = 110.9925
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.355981822851, Press = 0.595683636038415
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13879.932     -13879.932     -14019.968     -14019.968      270.90845      270.90845      47870.121      47870.121     -33.042177     -33.042177    
     49000  -13875.341     -13875.341     -14017.398     -14017.398      274.8192       274.8192       47876.91       47876.91       52.001363      52.001363    
Loop time of 341.539 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.872 hours/ns, 2.928 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.55     | 340.55     | 340.55     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15073    | 0.15073    | 0.15073    |   0.0 |  0.04
Output  | 0.0002335  | 0.0002335  | 0.0002335  |   0.0 |  0.00
Modify  | 0.74124    | 0.74124    | 0.74124    |   0.0 |  0.22
Other   |            | 0.1001     |            |       |  0.03

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

Total # of neighbors = 444218
Ave neighs/atom = 111.0545
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.307504486834, Press = 0.671032571324758
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13875.341     -13875.341     -14017.398     -14017.398      274.8192       274.8192       47876.91       47876.91       52.001363      52.001363    
     50000  -13875.271     -13875.271     -14020.011     -14020.011      280.0099       280.0099       47878.904      47878.904     -96.468394     -96.468394    
Loop time of 341.82 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.950 hours/ns, 2.926 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.82     | 340.82     | 340.82     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15005    | 0.15005    | 0.15005    |   0.0 |  0.04
Output  | 0.00018729 | 0.00018729 | 0.00018729 |   0.0 |  0.00
Modify  | 0.74524    | 0.74524    | 0.74524    |   0.0 |  0.22
Other   |            | 0.1006     |            |       |  0.03

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

Total # of neighbors = 443776
Ave neighs/atom = 110.944
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
47876.3084839259

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0