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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_849011491644_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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14008.467     -14008.467     -14160         -14160          293.15         293.15         47175.629      47175.629      3430.895       3430.895     
      1000  -13849.002     -13849.002     -14003.684     -14003.684      299.24183      299.24183      48019.328      48019.328     -2367.7399     -2367.7399    
Loop time of 165.438 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.522 ns/day, 45.955 hours/ns, 6.045 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 164.52     | 164.52     | 164.52     |   0.0 | 99.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14811    | 0.14811    | 0.14811    |   0.0 |  0.09
Output  | 0.00029552 | 0.00029552 | 0.00029552 |   0.0 |  0.00
Modify  | 0.67126    | 0.67126    | 0.67126    |   0.0 |  0.41
Other   |            | 0.09845    |            |       |  0.06

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

Total # of neighbors = 216000
Ave neighs/atom = 54
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13849.002     -13849.002     -14003.684     -14003.684      299.24183      299.24183      48019.328      48019.328     -2367.7399     -2367.7399    
      2000  -13859.305     -13859.305     -14012.236     -14012.236      295.85458      295.85458      47901.143      47901.143      142.62939      142.62939    
Loop time of 177.92 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.486 ns/day, 49.422 hours/ns, 5.620 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 177.04     | 177.04     | 177.04     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14283    | 0.14283    | 0.14283    |   0.0 |  0.08
Output  | 0.00023482 | 0.00023482 | 0.00023482 |   0.0 |  0.00
Modify  | 0.64184    | 0.64184    | 0.64184    |   0.0 |  0.36
Other   |            | 0.0975     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       247532 ave      247532 max      247532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247532
Ave neighs/atom = 61.883
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13859.305     -13859.305     -14012.236     -14012.236      295.85458      295.85458      47901.143      47901.143      142.62939      142.62939    
      3000  -13856.435     -13856.435     -14011.373     -14011.373      299.73786      299.73786      47942.165      47942.165     -746.16519     -746.16519    
Loop time of 204.546 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.5      | 203.5      | 203.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16062    | 0.16062    | 0.16062    |   0.0 |  0.08
Output  | 0.00024017 | 0.00024017 | 0.00024017 |   0.0 |  0.00
Modify  | 0.77779    | 0.77779    | 0.77779    |   0.0 |  0.38
Other   |            | 0.1049     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248608 ave      248608 max      248608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248608
Ave neighs/atom = 62.152
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13856.435     -13856.435     -14011.373     -14011.373      299.73786      299.73786      47942.165      47942.165     -746.16519     -746.16519    
      4000  -13856.343     -13856.343     -14007.995     -14007.995      293.38063      293.38063      47939.837      47939.837     -455.49601     -455.49601    
Loop time of 209.762 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.267 hours/ns, 4.767 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 208.68     | 208.68     | 208.68     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16498    | 0.16498    | 0.16498    |   0.0 |  0.08
Output  | 0.00023765 | 0.00023765 | 0.00023765 |   0.0 |  0.00
Modify  | 0.81385    | 0.81385    | 0.81385    |   0.0 |  0.39
Other   |            | 0.107      |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5838 ave        5838 max        5838 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248122 ave      248122 max      248122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248122
Ave neighs/atom = 62.0305
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13856.343     -13856.343     -14007.995     -14007.995      293.38063      293.38063      47939.837      47939.837     -455.49601     -455.49601    
      5000  -13859.978     -13859.978     -14007.154     -14007.154      284.72245      284.72245      47898.374      47898.374      826.36653      826.36653    
Loop time of 209.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.260 hours/ns, 4.768 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 208.64     | 208.64     | 208.64     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16588    | 0.16588    | 0.16588    |   0.0 |  0.08
Output  | 0.00019337 | 0.00019337 | 0.00019337 |   0.0 |  0.00
Modify  | 0.82033    | 0.82033    | 0.82033    |   0.0 |  0.39
Other   |            | 0.1075     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5837 ave        5837 max        5837 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248554 ave      248554 max      248554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248554
Ave neighs/atom = 62.1385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.810509246367, Press = 334.949100560885
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13859.978     -13859.978     -14007.154     -14007.154      284.72245      284.72245      47898.374      47898.374      826.36653      826.36653    
      6000  -13853.348     -13853.348     -14008.924     -14008.924      300.97202      300.97202      47960.439      47960.439     -939.92844     -939.92844    
Loop time of 211.132 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.409 ns/day, 58.648 hours/ns, 4.736 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 210.01     | 210.01     | 210.01     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16693    | 0.16693    | 0.16693    |   0.0 |  0.08
Output  | 0.00019266 | 0.00019266 | 0.00019266 |   0.0 |  0.00
Modify  | 0.8456     | 0.8456     | 0.8456     |   0.0 |  0.40
Other   |            | 0.1066     |            |       |  0.05

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

Total # of neighbors = 248894
Ave neighs/atom = 62.2235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.542087619751, Press = -15.9123620128242
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13853.348     -13853.348     -14008.924     -14008.924      300.97202      300.97202      47960.439      47960.439     -939.92844     -939.92844    
      7000  -13859.988     -13859.988     -14009.647     -14009.647      289.52613      289.52613      47858.292      47858.292      1789.3865      1789.3865    
Loop time of 203.113 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.420 hours/ns, 4.923 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.04     | 202.04     | 202.04     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16419    | 0.16419    | 0.16419    |   0.0 |  0.08
Output  | 0.00019208 | 0.00019208 | 0.00019208 |   0.0 |  0.00
Modify  | 0.80817    | 0.80817    | 0.80817    |   0.0 |  0.40
Other   |            | 0.1047     |            |       |  0.05

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

Total # of neighbors = 247852
Ave neighs/atom = 61.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.973491986911, Press = 30.9873123999302
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13859.988     -13859.988     -14009.647     -14009.647      289.52613      289.52613      47858.292      47858.292      1789.3865      1789.3865    
      8000  -13858.608     -13858.608     -14007.995     -14007.995      289.0005       289.0005       47971.786      47971.786     -1397.5384     -1397.5384    
Loop time of 188.29 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 187.32     | 187.32     | 187.32     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15233    | 0.15233    | 0.15233    |   0.0 |  0.08
Output  | 0.00019169 | 0.00019169 | 0.00019169 |   0.0 |  0.00
Modify  | 0.72098    | 0.72098    | 0.72098    |   0.0 |  0.38
Other   |            | 0.09795    |            |       |  0.05

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

Total # of neighbors = 249132
Ave neighs/atom = 62.283
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.062142341101, Press = -12.2121137047066
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13858.608     -13858.608     -14007.995     -14007.995      289.0005       289.0005       47971.786      47971.786     -1397.5384     -1397.5384    
      9000  -13855.399     -13855.399     -14005.369     -14005.369      290.12677      290.12677      47901.193      47901.193      1019.3202      1019.3202    
Loop time of 179.127 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.482 ns/day, 49.757 hours/ns, 5.583 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.21     | 178.21     | 178.21     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14847    | 0.14847    | 0.14847    |   0.0 |  0.08
Output  | 0.00019269 | 0.00019269 | 0.00019269 |   0.0 |  0.00
Modify  | 0.6764     | 0.6764     | 0.6764     |   0.0 |  0.38
Other   |            | 0.09225    |            |       |  0.05

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

Total # of neighbors = 247830
Ave neighs/atom = 61.9575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.743707994266, Press = 11.5910031252964
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13855.399     -13855.399     -14005.369     -14005.369      290.12677      290.12677      47901.193      47901.193      1019.3202      1019.3202    
     10000  -13858.393     -13858.393     -14007.834     -14007.834      289.10439      289.10439      47922.369      47922.369      94.843165      94.843165    
Loop time of 186.541 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.817 hours/ns, 5.361 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 185.58     | 185.58     | 185.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15088    | 0.15088    | 0.15088    |   0.0 |  0.08
Output  | 0.00019262 | 0.00019262 | 0.00019262 |   0.0 |  0.00
Modify  | 0.71235    | 0.71235    | 0.71235    |   0.0 |  0.38
Other   |            | 0.09556    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       249046 ave      249046 max      249046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249046
Ave neighs/atom = 62.2615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.911949172724, Press = -0.976289334344457
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13858.393     -13858.393     -14007.834     -14007.834      289.10439      289.10439      47922.369      47922.369      94.843165      94.843165    
     11000  -13858.435     -13858.435     -14007.175     -14007.175      287.74833      287.74833      47929.49       47929.49      -88.898089     -88.898089    
Loop time of 196.433 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.565 hours/ns, 5.091 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.4      | 195.4      | 195.4      |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15719    | 0.15719    | 0.15719    |   0.0 |  0.08
Output  | 0.00024179 | 0.00024179 | 0.00024179 |   0.0 |  0.00
Modify  | 0.77517    | 0.77517    | 0.77517    |   0.0 |  0.39
Other   |            | 0.1024     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248604 ave      248604 max      248604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248604
Ave neighs/atom = 62.151
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.236912175536, Press = 3.67590444383136
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13858.435     -13858.435     -14007.175     -14007.175      287.74833      287.74833      47929.49       47929.49      -88.898089     -88.898089    
     12000  -13854.763     -13854.763     -14006.924     -14006.924      294.36526      294.36526      47909.754      47909.754      638.56136      638.56136    
Loop time of 210.625 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.507 hours/ns, 4.748 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 209.5      | 209.5      | 209.5      |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16732    | 0.16732    | 0.16732    |   0.0 |  0.08
Output  | 0.00019507 | 0.00019507 | 0.00019507 |   0.0 |  0.00
Modify  | 0.84818    | 0.84818    | 0.84818    |   0.0 |  0.40
Other   |            | 0.1067     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248402 ave      248402 max      248402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248402
Ave neighs/atom = 62.1005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.033804157993, Press = -0.697489423047104
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13854.763     -13854.763     -14006.924     -14006.924      294.36526      294.36526      47909.754      47909.754      638.56136      638.56136    
     13000  -13859.426     -13859.426     -14009.661     -14009.661      290.63981      290.63981      47968.387      47968.387     -1362.4438     -1362.4438    
Loop time of 189.937 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.455 ns/day, 52.760 hours/ns, 5.265 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 188.95     | 188.95     | 188.95     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15431    | 0.15431    | 0.15431    |   0.0 |  0.08
Output  | 0.00019259 | 0.00019259 | 0.00019259 |   0.0 |  0.00
Modify  | 0.73204    | 0.73204    | 0.73204    |   0.0 |  0.39
Other   |            | 0.09746    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5838 ave        5838 max        5838 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248396 ave      248396 max      248396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248396
Ave neighs/atom = 62.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.981529645748, Press = 0.913229185755648
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13859.426     -13859.426     -14009.661     -14009.661      290.63981      290.63981      47968.387      47968.387     -1362.4438     -1362.4438    
     14000  -13856.539     -13856.539     -14006.478     -14006.478      290.06729      290.06729      47874.395      47874.395      1695.6104      1695.6104    
Loop time of 190.228 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.454 ns/day, 52.841 hours/ns, 5.257 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 189.24     | 189.24     | 189.24     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15427    | 0.15427    | 0.15427    |   0.0 |  0.08
Output  | 0.00024623 | 0.00024623 | 0.00024623 |   0.0 |  0.00
Modify  | 0.73673    | 0.73673    | 0.73673    |   0.0 |  0.39
Other   |            | 0.09777    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5838 ave        5838 max        5838 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       247850 ave      247850 max      247850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247850
Ave neighs/atom = 61.9625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.933751511129, Press = 3.07506363979246
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13856.539     -13856.539     -14006.478     -14006.478      290.06729      290.06729      47874.395      47874.395      1695.6104      1695.6104    
     15000  -13861.265     -13861.265     -14010.729     -14010.729      289.14824      289.14824      47983.192      47983.192     -1953.9344     -1953.9344    
Loop time of 211.14 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.409 ns/day, 58.650 hours/ns, 4.736 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    | 210.02     | 210.02     | 210.02     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16845    | 0.16845    | 0.16845    |   0.0 |  0.08
Output  | 0.00019669 | 0.00019669 | 0.00019669 |   0.0 |  0.00
Modify  | 0.84668    | 0.84668    | 0.84668    |   0.0 |  0.40
Other   |            | 0.1061     |            |       |  0.05

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

Total # of neighbors = 249234
Ave neighs/atom = 62.3085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.769003326316, Press = -1.42616683206629
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13861.265     -13861.265     -14010.729     -14010.729      289.14824      289.14824      47983.192      47983.192     -1953.9344     -1953.9344    
     16000  -13851.683     -13851.683     -14004.732     -14004.732      296.08288      296.08288      47878.152      47878.152      1867.4311      1867.4311    
Loop time of 198.456 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.42     | 197.42     | 197.42     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15856    | 0.15856    | 0.15856    |   0.0 |  0.08
Output  | 0.00023202 | 0.00023202 | 0.00023202 |   0.0 |  0.00
Modify  | 0.77753    | 0.77753    | 0.77753    |   0.0 |  0.39
Other   |            | 0.1005     |            |       |  0.05

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

Total # of neighbors = 247570
Ave neighs/atom = 61.8925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.821107058406, Press = 3.36451215528622
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13851.683     -13851.683     -14004.732     -14004.732      296.08288      296.08288      47878.152      47878.152      1867.4311      1867.4311    
     17000  -13858.217     -13858.217     -14010.16      -14010.16       293.94419      293.94419      47936.894      47936.894     -457.69287     -457.69287    
Loop time of 187.694 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.460 ns/day, 52.137 hours/ns, 5.328 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 186.73     | 186.73     | 186.73     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15145    | 0.15145    | 0.15145    |   0.0 |  0.08
Output  | 0.00019087 | 0.00019087 | 0.00019087 |   0.0 |  0.00
Modify  | 0.71735    | 0.71735    | 0.71735    |   0.0 |  0.38
Other   |            | 0.09771    |            |       |  0.05

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

Total # of neighbors = 249154
Ave neighs/atom = 62.2885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.992733042718, Press = -0.53187551770467
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13858.217     -13858.217     -14010.16      -14010.16       293.94419      293.94419      47936.894      47936.894     -457.69287     -457.69287    
     18000  -13850.552     -13850.552     -14004.798     -14004.798      298.39903      298.39903      47931.848      47931.848      282.69488      282.69488    
Loop time of 209.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.125 hours/ns, 4.779 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    | 208.13     | 208.13     | 208.13     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16597    | 0.16597    | 0.16597    |   0.0 |  0.08
Output  | 0.00019154 | 0.00019154 | 0.00019154 |   0.0 |  0.00
Modify  | 0.84365    | 0.84365    | 0.84365    |   0.0 |  0.40
Other   |            | 0.1068     |            |       |  0.05

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

Total # of neighbors = 247968
Ave neighs/atom = 61.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.074497016098, Press = 1.64130640370306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13850.552     -13850.552     -14004.798     -14004.798      298.39903      298.39903      47931.848      47931.848      282.69488      282.69488    
     19000  -13859.88      -13859.88      -14009.371     -14009.371      289.19948      289.19948      47946.215      47946.215     -669.72617     -669.72617    
Loop time of 209.018 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.061 hours/ns, 4.784 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    | 207.91     | 207.91     | 207.91     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16742    | 0.16742    | 0.16742    |   0.0 |  0.08
Output  | 0.00027176 | 0.00027176 | 0.00027176 |   0.0 |  0.00
Modify  | 0.83615    | 0.83615    | 0.83615    |   0.0 |  0.40
Other   |            | 0.1061     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5832 ave        5832 max        5832 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248264 ave      248264 max      248264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248264
Ave neighs/atom = 62.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 = 293.157154349161, Press = 0.754696113288345
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13859.88      -13859.88      -14009.371     -14009.371      289.19948      289.19948      47946.215      47946.215     -669.72617     -669.72617    
     20000  -13853.247     -13853.247     -14006.158     -14006.158      295.8155       295.8155       47894.198      47894.198      1197.306       1197.306     
Loop time of 191.036 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.452 ns/day, 53.065 hours/ns, 5.235 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.05     | 190.05     | 190.05     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15507    | 0.15507    | 0.15507    |   0.0 |  0.08
Output  | 0.00025111 | 0.00025111 | 0.00025111 |   0.0 |  0.00
Modify  | 0.73793    | 0.73793    | 0.73793    |   0.0 |  0.39
Other   |            | 0.09734    |            |       |  0.05

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

Total # of neighbors = 247986
Ave neighs/atom = 61.9965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.201621572786, Press = 2.69384766939227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13853.247     -13853.247     -14006.158     -14006.158      295.8155       295.8155       47894.198      47894.198      1197.306       1197.306     
     21000  -13857.012     -13857.012     -14007.811     -14007.811      291.73216      291.73216      47969.727      47969.727     -1240.7139     -1240.7139    
Loop time of 192.973 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.448 ns/day, 53.604 hours/ns, 5.182 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.97     | 191.97     | 191.97     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15636    | 0.15636    | 0.15636    |   0.0 |  0.08
Output  | 0.00025245 | 0.00025245 | 0.00025245 |   0.0 |  0.00
Modify  | 0.75096    | 0.75096    | 0.75096    |   0.0 |  0.39
Other   |            | 0.09859    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248934 ave      248934 max      248934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248934
Ave neighs/atom = 62.2335
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.227067653236, Press = -1.49171867797914
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13857.012     -13857.012     -14007.811     -14007.811      291.73216      291.73216      47969.727      47969.727     -1240.7139     -1240.7139    
     22000  -13853.648     -13853.648     -14007.28      -14007.28       297.21088      297.21088      47888.058      47888.058      1202.2626      1202.2626    
Loop time of 204.235 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.16     | 203.16     | 203.16     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16429    | 0.16429    | 0.16429    |   0.0 |  0.08
Output  | 0.00024525 | 0.00024525 | 0.00024525 |   0.0 |  0.00
Modify  | 0.80679    | 0.80679    | 0.80679    |   0.0 |  0.40
Other   |            | 0.1044     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       247806 ave      247806 max      247806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247806
Ave neighs/atom = 61.9515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.229326998104, Press = 2.99343316875933
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13853.648     -13853.648     -14007.28      -14007.28       297.21088      297.21088      47888.058      47888.058      1202.2626      1202.2626    
     23000  -13854.642     -13854.642     -14005.789     -14005.789      292.40478      292.40478      47955.005      47955.005     -584.28387     -584.28387    
Loop time of 197.71 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.920 hours/ns, 5.058 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    | 196.68     | 196.68     | 196.68     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15831    | 0.15831    | 0.15831    |   0.0 |  0.08
Output  | 0.00031115 | 0.00031115 | 0.00031115 |   0.0 |  0.00
Modify  | 0.77308    | 0.77308    | 0.77308    |   0.0 |  0.39
Other   |            | 0.1018     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       249000 ave      249000 max      249000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249000
Ave neighs/atom = 62.25
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.244604611627, Press = -1.23547664247736
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13854.642     -13854.642     -14005.789     -14005.789      292.40478      292.40478      47955.005      47955.005     -584.28387     -584.28387    
     24000  -13857.933     -13857.933     -14007.816     -14007.816      289.9597       289.9597       47884.904      47884.904      1172.6982      1172.6982    
Loop time of 207.733 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.704 hours/ns, 4.814 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 206.63     | 206.63     | 206.63     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16577    | 0.16577    | 0.16577    |   0.0 |  0.08
Output  | 0.00019463 | 0.00019463 | 0.00019463 |   0.0 |  0.00
Modify  | 0.83299    | 0.83299    | 0.83299    |   0.0 |  0.40
Other   |            | 0.1051     |            |       |  0.05

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

Total # of neighbors = 248202
Ave neighs/atom = 62.0505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.154678336945, Press = 2.26691021219305
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13857.933     -13857.933     -14007.816     -14007.816      289.9597       289.9597       47884.904      47884.904      1172.6982      1172.6982    
     25000  -13858.039     -13858.039     -14009.712     -14009.712      293.42168      293.42168      47950.539      47950.539     -867.54759     -867.54759    
Loop time of 192.83 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.448 ns/day, 53.564 hours/ns, 5.186 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    | 191.83     | 191.83     | 191.83     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15674    | 0.15674    | 0.15674    |   0.0 |  0.08
Output  | 0.00023946 | 0.00023946 | 0.00023946 |   0.0 |  0.00
Modify  | 0.74806    | 0.74806    | 0.74806    |   0.0 |  0.39
Other   |            | 0.09955    |            |       |  0.05

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

Total # of neighbors = 248860
Ave neighs/atom = 62.215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.112732947131, Press = -2.00954937010478
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13858.039     -13858.039     -14009.712     -14009.712      293.42168      293.42168      47950.539      47950.539     -867.54759     -867.54759    
     26000  -13858.254     -13858.254     -14007.738     -14007.738      289.18587      289.18587      47885.916      47885.916      1130.0838      1130.0838    
Loop time of 179.635 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.481 ns/day, 49.899 hours/ns, 5.567 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.72     | 178.72     | 178.72     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14727    | 0.14727    | 0.14727    |   0.0 |  0.08
Output  | 0.00019316 | 0.00019316 | 0.00019316 |   0.0 |  0.00
Modify  | 0.67646    | 0.67646    | 0.67646    |   0.0 |  0.38
Other   |            | 0.09213    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       247844 ave      247844 max      247844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247844
Ave neighs/atom = 61.961
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.007299553158, Press = 3.42789712246146
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13858.254     -13858.254     -14007.738     -14007.738      289.18587      289.18587      47885.916      47885.916      1130.0838      1130.0838    
     27000  -13860.075     -13860.075     -14010.181     -14010.181      290.39143      290.39143      47931.885      47931.885     -450.88158     -450.88158    
Loop time of 191.874 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.450 ns/day, 53.298 hours/ns, 5.212 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.87     | 190.87     | 190.87     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15453    | 0.15453    | 0.15453    |   0.0 |  0.08
Output  | 0.00019618 | 0.00019618 | 0.00019618 |   0.0 |  0.00
Modify  | 0.74664    | 0.74664    | 0.74664    |   0.0 |  0.39
Other   |            | 0.09889    |            |       |  0.05

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

Total # of neighbors = 248864
Ave neighs/atom = 62.216
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.986495245889, Press = -1.03352111510113
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13860.075     -13860.075     -14010.181     -14010.181      290.39143      290.39143      47931.885      47931.885     -450.88158     -450.88158    
     28000  -13856.585     -13856.585     -14008.298     -14008.298      293.49931      293.49931      47913.308      47913.308      263.68763      263.68763    
Loop time of 208.956 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.043 hours/ns, 4.786 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 207.84     | 207.84     | 207.84     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16534    | 0.16534    | 0.16534    |   0.0 |  0.08
Output  | 0.00019    | 0.00019    | 0.00019    |   0.0 |  0.00
Modify  | 0.83833    | 0.83833    | 0.83833    |   0.0 |  0.40
Other   |            | 0.1071     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248154 ave      248154 max      248154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248154
Ave neighs/atom = 62.0385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.955850262506, Press = 1.41173519480799
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13856.585     -13856.585     -14008.298     -14008.298      293.49931      293.49931      47913.308      47913.308      263.68763      263.68763    
     29000  -13853.458     -13853.458     -14004.863     -14004.863      292.90185      292.90185      47922.232      47922.232      435.94227      435.94227    
Loop time of 210.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.457 hours/ns, 4.752 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    | 209.33     | 209.33     | 209.33     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16562    | 0.16562    | 0.16562    |   0.0 |  0.08
Output  | 0.0001927  | 0.0001927  | 0.0001927  |   0.0 |  0.00
Modify  | 0.84055    | 0.84055    | 0.84055    |   0.0 |  0.40
Other   |            | 0.1064     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248356 ave      248356 max      248356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0