# 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.5213917419314393*${_u_distance}
variable latticeconst_converted equal 3.5213917419314393*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174193144
Lattice spacing in x,y,z = 3.5213917 3.5213917 3.5213917
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.213917 35.213917 35.213917)
  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 (35.213917 35.213917 35.213917)
  create_atoms CPU = 0.007 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KoGrabowskiNeugebauer_2015_NiTi__MO_663355627503_002
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9611745232 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_663355627503_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -17648.467     -17648.467     -17800         -17800          293.15         293.15         43665.961      43665.961      3706.6528      3706.6528    
      1000  -17487.218     -17487.218     -17639.074     -17639.074      293.77608      293.77608      44098.105      44098.105      1723.188       1723.188     
Loop time of 415.857 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.516 hours/ns, 2.405 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    | 414.88     | 414.88     | 414.88     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15256    | 0.15256    | 0.15256    |   0.0 |  0.04
Output  | 0.00026906 | 0.00026906 | 0.00026906 |   0.0 |  0.00
Modify  | 0.72189    | 0.72189    | 0.72189    |   0.0 |  0.17
Other   |            | 0.1026     |            |       |  0.02

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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17487.218     -17487.218     -17639.074     -17639.074      293.77608      293.77608      44098.105      44098.105      1723.188       1723.188     
      2000  -17496.169     -17496.169     -17648.973     -17648.973      295.6098       295.6098       44114.802      44114.802      144.575        144.575      
Loop time of 426.383 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.440 hours/ns, 2.345 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    | 425.31     | 425.31     | 425.31     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17118    | 0.17118    | 0.17118    |   0.0 |  0.04
Output  | 0.00022875 | 0.00022875 | 0.00022875 |   0.0 |  0.00
Modify  | 0.79615    | 0.79615    | 0.79615    |   0.0 |  0.19
Other   |            | 0.1079     |            |       |  0.03

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

Total # of neighbors = 541266
Ave neighs/atom = 135.3165
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17496.169     -17496.169     -17648.973     -17648.973      295.6098       295.6098       44114.802      44114.802      144.575        144.575      
      3000  -17495.469     -17495.469     -17646.81      -17646.81       292.77988      292.77988      44116.673      44116.673      235.90424      235.90424    
Loop time of 427.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.735 hours/ns, 2.339 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    | 426.37     | 426.37     | 426.37     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16919    | 0.16919    | 0.16919    |   0.0 |  0.04
Output  | 0.00027407 | 0.00027407 | 0.00027407 |   0.0 |  0.00
Modify  | 0.79629    | 0.79629    | 0.79629    |   0.0 |  0.19
Other   |            | 0.1076     |            |       |  0.03

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

Total # of neighbors = 541000
Ave neighs/atom = 135.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 = 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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17495.469     -17495.469     -17646.81      -17646.81       292.77988      292.77988      44116.673      44116.673      235.90424      235.90424    
      4000  -17493.172     -17493.172     -17646.043     -17646.043      295.73855      295.73855      44136.783      44136.783     -473.23164     -473.23164    
Loop time of 412.373 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.548 hours/ns, 2.425 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    | 411.35     | 411.35     | 411.35     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16347    | 0.16347    | 0.16347    |   0.0 |  0.04
Output  | 0.00027822 | 0.00027822 | 0.00027822 |   0.0 |  0.00
Modify  | 0.7538     | 0.7538     | 0.7538     |   0.0 |  0.18
Other   |            | 0.1054     |            |       |  0.03

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

Total # of neighbors = 541126
Ave neighs/atom = 135.2815
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17493.172     -17493.172     -17646.043     -17646.043      295.73855      295.73855      44136.783      44136.783     -473.23164     -473.23164    
      5000  -17497.998     -17497.998     -17650.24      -17650.24       294.52206      294.52206      44132.523      44132.523     -767.87942     -767.87942    
Loop time of 432.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.069 hours/ns, 2.313 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    | 431.14     | 431.14     | 431.14     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17096    | 0.17096    | 0.17096    |   0.0 |  0.04
Output  | 0.00024552 | 0.00024552 | 0.00024552 |   0.0 |  0.00
Modify  | 0.82316    | 0.82316    | 0.82316    |   0.0 |  0.19
Other   |            | 0.1099     |            |       |  0.03

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

Total # of neighbors = 541110
Ave neighs/atom = 135.2775
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.295148062943, Press = 346.173160248603
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17497.998     -17497.998     -17650.24      -17650.24       294.52206      294.52206      44132.523      44132.523     -767.87942     -767.87942    
      6000  -17492.32      -17492.32      -17644.702     -17644.702      294.79184      294.79184      44169.255      44169.255     -1740.6785     -1740.6785    
Loop time of 384.969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.936 hours/ns, 2.598 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    | 384        | 384        | 384        |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15616    | 0.15616    | 0.15616    |   0.0 |  0.04
Output  | 0.00023372 | 0.00023372 | 0.00023372 |   0.0 |  0.00
Modify  | 0.711      | 0.711      | 0.711      |   0.0 |  0.18
Other   |            | 0.09874    |            |       |  0.03

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

Total # of neighbors = 541126
Ave neighs/atom = 135.2815
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.714115830436, Press = 21.3565123088513
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17492.32      -17492.32      -17644.702     -17644.702      294.79184      294.79184      44169.255      44169.255     -1740.6785     -1740.6785    
      7000  -17498.285     -17498.285     -17652.738     -17652.738      298.79937      298.79937      44178.88       44178.88      -2789.7999     -2789.7999    
Loop time of 416.551 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 115.709 hours/ns, 2.401 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    | 415.49     | 415.49     | 415.49     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16527    | 0.16527    | 0.16527    |   0.0 |  0.04
Output  | 0.00024989 | 0.00024989 | 0.00024989 |   0.0 |  0.00
Modify  | 0.78849    | 0.78849    | 0.78849    |   0.0 |  0.19
Other   |            | 0.1056     |            |       |  0.03

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

Total # of neighbors = 540896
Ave neighs/atom = 135.224
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.003679186476, Press = -12.9941405330018
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17498.285     -17498.285     -17652.738     -17652.738      298.79937      298.79937      44178.88       44178.88      -2789.7999     -2789.7999    
      8000  -17494.277     -17494.277     -17649.014     -17649.014      299.34904      299.34904      44145.566      44145.566     -1130.3577     -1130.3577    
Loop time of 415.993 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.554 hours/ns, 2.404 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    | 414.93     | 414.93     | 414.93     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16332    | 0.16332    | 0.16332    |   0.0 |  0.04
Output  | 0.00018673 | 0.00018673 | 0.00018673 |   0.0 |  0.00
Modify  | 0.79724    | 0.79724    | 0.79724    |   0.0 |  0.19
Other   |            | 0.1068     |            |       |  0.03

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

Total # of neighbors = 540720
Ave neighs/atom = 135.18
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.925991324895, Press = -11.7927504678851
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17494.277     -17494.277     -17649.014     -17649.014      299.34904      299.34904      44145.566      44145.566     -1130.3577     -1130.3577    
      9000  -17498.257     -17498.257     -17647.393     -17647.393      288.51344      288.51344      44108.38       44108.38       509.43022      509.43022    
Loop time of 424.116 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.810 hours/ns, 2.358 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    | 423.03     | 423.03     | 423.03     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1691     | 0.1691     | 0.1691     |   0.0 |  0.04
Output  | 0.00024615 | 0.00024615 | 0.00024615 |   0.0 |  0.00
Modify  | 0.8107     | 0.8107     | 0.8107     |   0.0 |  0.19
Other   |            | 0.107      |            |       |  0.03

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

Total # of neighbors = 540876
Ave neighs/atom = 135.219
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.563292444283, Press = -3.10732650727816
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17498.257     -17498.257     -17647.393     -17647.393      288.51344      288.51344      44108.38       44108.38       509.43022      509.43022    
     10000  -17496.59      -17496.59      -17647.732     -17647.732      292.39455      292.39455      44106.163      44106.163      610.49141      610.49141    
Loop time of 433.026 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.285 hours/ns, 2.309 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    | 431.92     | 431.92     | 431.92     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16837    | 0.16837    | 0.16837    |   0.0 |  0.04
Output  | 0.00022654 | 0.00022654 | 0.00022654 |   0.0 |  0.00
Modify  | 0.83366    | 0.83366    | 0.83366    |   0.0 |  0.19
Other   |            | 0.1081     |            |       |  0.02

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

Total # of neighbors = 541092
Ave neighs/atom = 135.273
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.849036355188, Press = 1.28725172121813
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17496.59      -17496.59      -17647.732     -17647.732      292.39455      292.39455      44106.163      44106.163      610.49141      610.49141    
     11000  -17490.219     -17490.219     -17644.804     -17644.804      299.05575      299.05575      44106.231      44106.231      944.31546      944.31546    
Loop time of 432.132 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.037 hours/ns, 2.314 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    | 431.03     | 431.03     | 431.03     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17024    | 0.17024    | 0.17024    |   0.0 |  0.04
Output  | 0.00024577 | 0.00024577 | 0.00024577 |   0.0 |  0.00
Modify  | 0.82698    | 0.82698    | 0.82698    |   0.0 |  0.19
Other   |            | 0.1084     |            |       |  0.03

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

Total # of neighbors = 541110
Ave neighs/atom = 135.2775
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.165074201611, Press = 4.48273766066796
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17490.219     -17490.219     -17644.804     -17644.804      299.05575      299.05575      44106.231      44106.231      944.31546      944.31546    
     12000  -17497.809     -17497.809     -17646.554     -17646.554      287.75764      287.75764      44082.103      44082.103      1689.103       1689.103     
Loop time of 430.344 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.540 hours/ns, 2.324 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    | 429.22     | 429.22     | 429.22     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1699     | 0.1699     | 0.1699     |   0.0 |  0.04
Output  | 0.00018989 | 0.00018989 | 0.00018989 |   0.0 |  0.00
Modify  | 0.84086    | 0.84086    | 0.84086    |   0.0 |  0.20
Other   |            | 0.1088     |            |       |  0.03

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

Total # of neighbors = 541166
Ave neighs/atom = 135.2915
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.333576537413, Press = 7.57669510809181
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17497.809     -17497.809     -17646.554     -17646.554      287.75764      287.75764      44082.103      44082.103      1689.103       1689.103     
     13000  -17491.48      -17491.48      -17643.96      -17643.96       294.98218      294.98218      44079.358      44079.358      2180.9181      2180.9181    
Loop time of 431.272 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.798 hours/ns, 2.319 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    | 430.13     | 430.13     | 430.13     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17377    | 0.17377    | 0.17377    |   0.0 |  0.04
Output  | 0.00023919 | 0.00023919 | 0.00023919 |   0.0 |  0.00
Modify  | 0.8527     | 0.8527     | 0.8527     |   0.0 |  0.20
Other   |            | 0.1108     |            |       |  0.03

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

Total # of neighbors = 541210
Ave neighs/atom = 135.3025
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.479430060356, Press = 17.4782430653307
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17491.48      -17491.48      -17643.96      -17643.96       294.98218      294.98218      44079.358      44079.358      2180.9181      2180.9181    
     14000  -17496.526     -17496.526     -17645.812     -17645.812      288.80463      288.80463      44131.506      44131.506     -348.05087     -348.05087    
Loop time of 418.735 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.315 hours/ns, 2.388 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    | 417.66     | 417.66     | 417.66     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16593    | 0.16593    | 0.16593    |   0.0 |  0.04
Output  | 0.00019291 | 0.00019291 | 0.00019291 |   0.0 |  0.00
Modify  | 0.8007     | 0.8007     | 0.8007     |   0.0 |  0.19
Other   |            | 0.1059     |            |       |  0.03

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

Total # of neighbors = 541210
Ave neighs/atom = 135.3025
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.555787434994, Press = 9.46230139241308
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17496.526     -17496.526     -17645.812     -17645.812      288.80463      288.80463      44131.506      44131.506     -348.05087     -348.05087    
     15000  -17495.897     -17495.897     -17648.537     -17648.537      295.29261      295.29261      44147.99       44147.99      -1191.039      -1191.039     
Loop time of 375.472 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.298 hours/ns, 2.663 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    | 374.54     | 374.54     | 374.54     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15401    | 0.15401    | 0.15401    |   0.0 |  0.04
Output  | 0.00019318 | 0.00019318 | 0.00019318 |   0.0 |  0.00
Modify  | 0.68401    | 0.68401    | 0.68401    |   0.0 |  0.18
Other   |            | 0.09763    |            |       |  0.03

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

Total # of neighbors = 541070
Ave neighs/atom = 135.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 = 293.644457045911, Press = 4.96488508026445
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17495.897     -17495.897     -17648.537     -17648.537      295.29261      295.29261      44147.99       44147.99      -1191.039      -1191.039     
     16000  -17494.982     -17494.982     -17649.499     -17649.499      298.92268      298.92268      44149.006      44149.006     -1300.6511     -1300.6511    
Loop time of 411.055 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.182 hours/ns, 2.433 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    | 410.02     | 410.02     | 410.02     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16435    | 0.16435    | 0.16435    |   0.0 |  0.04
Output  | 0.00023889 | 0.00023889 | 0.00023889 |   0.0 |  0.00
Modify  | 0.77199    | 0.77199    | 0.77199    |   0.0 |  0.19
Other   |            | 0.1033     |            |       |  0.03

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

Total # of neighbors = 540878
Ave neighs/atom = 135.2195
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.578145147063, Press = 3.37306018925368
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17494.982     -17494.982     -17649.499     -17649.499      298.92268      298.92268      44149.006      44149.006     -1300.6511     -1300.6511    
     17000  -17495.53      -17495.53      -17646.199     -17646.199      291.48013      291.48013      44138.098      44138.098     -686.33107     -686.33107    
Loop time of 436.109 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.141 hours/ns, 2.293 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    | 434.97     | 434.97     | 434.97     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17552    | 0.17552    | 0.17552    |   0.0 |  0.04
Output  | 0.00023439 | 0.00023439 | 0.00023439 |   0.0 |  0.00
Modify  | 0.85135    | 0.85135    | 0.85135    |   0.0 |  0.20
Other   |            | 0.1084     |            |       |  0.02

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

Total # of neighbors = 540904
Ave neighs/atom = 135.226
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.599355219753, Press = 1.26150628037008
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17495.53      -17495.53      -17646.199     -17646.199      291.48013      291.48013      44138.098      44138.098     -686.33107     -686.33107    
     18000  -17496.106     -17496.106     -17646.49      -17646.49       290.927        290.927        44131.003      44131.003     -283.3177      -283.3177     
Loop time of 429.725 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.368 hours/ns, 2.327 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    | 428.62     | 428.62     | 428.62     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17183    | 0.17183    | 0.17183    |   0.0 |  0.04
Output  | 0.00019594 | 0.00019594 | 0.00019594 |   0.0 |  0.00
Modify  | 0.82391    | 0.82391    | 0.82391    |   0.0 |  0.19
Other   |            | 0.1086     |            |       |  0.03

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

Total # of neighbors = 541130
Ave neighs/atom = 135.2825
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.54160424678, Press = -0.74672522677064
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17496.106     -17496.106     -17646.49      -17646.49       290.927        290.927        44131.003      44131.003     -283.3177      -283.3177     
     19000  -17498.977     -17498.977     -17647.767     -17647.767      287.84344      287.84344      44090.78       44090.78       1206.776       1206.776     
Loop time of 436.657 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.294 hours/ns, 2.290 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    | 435.54     | 435.54     | 435.54     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17053    | 0.17053    | 0.17053    |   0.0 |  0.04
Output  | 0.00024028 | 0.00024028 | 0.00024028 |   0.0 |  0.00
Modify  | 0.84026    | 0.84026    | 0.84026    |   0.0 |  0.19
Other   |            | 0.1097     |            |       |  0.03

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

Total # of neighbors = 540996
Ave neighs/atom = 135.249
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.556597268802, Press = -2.34712368488018
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17498.977     -17498.977     -17647.767     -17647.767      287.84344      287.84344      44090.78       44090.78       1206.776       1206.776     
     20000  -17495.365     -17495.365     -17647.377     -17647.377      294.07697      294.07697      44076.552      44076.552      1881.0696      1881.0696    
Loop time of 435 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.833 hours/ns, 2.299 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    | 433.88     | 433.88     | 433.88     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16978    | 0.16978    | 0.16978    |   0.0 |  0.04
Output  | 0.00019005 | 0.00019005 | 0.00019005 |   0.0 |  0.00
Modify  | 0.83958    | 0.83958    | 0.83958    |   0.0 |  0.19
Other   |            | 0.1091     |            |       |  0.03

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

Total # of neighbors = 541024
Ave neighs/atom = 135.256
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.509830791524, Press = 0.638664968398381
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17495.365     -17495.365     -17647.377     -17647.377      294.07697      294.07697      44076.552      44076.552      1881.0696      1881.0696    
     21000  -17494.373     -17494.373     -17646.179     -17646.179      293.67839      293.67839      44090.259      44090.259      1402.7636      1402.7636    
Loop time of 437.082 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.412 hours/ns, 2.288 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    | 435.95     | 435.95     | 435.95     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17101    | 0.17101    | 0.17101    |   0.0 |  0.04
Output  | 0.00019209 | 0.00019209 | 0.00019209 |   0.0 |  0.00
Modify  | 0.84909    | 0.84909    | 0.84909    |   0.0 |  0.19
Other   |            | 0.1091     |            |       |  0.02

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

Total # of neighbors = 541312
Ave neighs/atom = 135.328
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.501275292686, Press = 2.00855749198666
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17494.373     -17494.373     -17646.179     -17646.179      293.67839      293.67839      44090.259      44090.259      1402.7636      1402.7636    
     22000  -17497.773     -17497.773     -17647.676     -17647.676      289.99659      289.99659      44107.071      44107.071      558.70678      558.70678    
Loop time of 434.34 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.650 hours/ns, 2.302 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    | 433.21     | 433.21     | 433.21     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1741     | 0.1741     | 0.1741     |   0.0 |  0.04
Output  | 0.00019565 | 0.00019565 | 0.00019565 |   0.0 |  0.00
Modify  | 0.84339    | 0.84339    | 0.84339    |   0.0 |  0.19
Other   |            | 0.1092     |            |       |  0.03

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

Total # of neighbors = 541380
Ave neighs/atom = 135.345
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.43503358996, Press = 1.99652680161328
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17497.773     -17497.773     -17647.676     -17647.676      289.99659      289.99659      44107.071      44107.071      558.70678      558.70678    
     23000  -17496.102     -17496.102     -17646.833     -17646.833      291.59885      291.59885      44115.401      44115.401      314.37287      314.37287    
Loop time of 430.675 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.632 hours/ns, 2.322 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    | 429.57     | 429.57     | 429.57     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16959    | 0.16959    | 0.16959    |   0.0 |  0.04
Output  | 0.00024237 | 0.00024237 | 0.00024237 |   0.0 |  0.00
Modify  | 0.82422    | 0.82422    | 0.82422    |   0.0 |  0.19
Other   |            | 0.1085     |            |       |  0.03

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

Total # of neighbors = 541194
Ave neighs/atom = 135.2985
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.360128598986, Press = 1.88048769164194
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17496.102     -17496.102     -17646.833     -17646.833      291.59885      291.59885      44115.401      44115.401      314.37287      314.37287    
     24000  -17498.279     -17498.279     -17645.483     -17645.483      284.77688      284.77688      44113.401      44113.401      403.54068      403.54068    
Loop time of 426.483 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.468 hours/ns, 2.345 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    | 425.38     | 425.38     | 425.38     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17249    | 0.17249    | 0.17249    |   0.0 |  0.04
Output  | 0.00031938 | 0.00031938 | 0.00031938 |   0.0 |  0.00
Modify  | 0.8257     | 0.8257     | 0.8257     |   0.0 |  0.19
Other   |            | 0.1079     |            |       |  0.03

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

Total # of neighbors = 541142
Ave neighs/atom = 135.2855
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.272816673154, Press = 1.63473758625138
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17498.279     -17498.279     -17645.483     -17645.483      284.77688      284.77688      44113.401      44113.401      403.54068      403.54068    
     25000  -17493.574     -17493.574     -17646.868     -17646.868      296.55737      296.55737      44124.917      44124.917     -25.194512     -25.194512    
Loop time of 400.038 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.122 hours/ns, 2.500 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    | 399.03     | 399.03     | 399.03     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16054    | 0.16054    | 0.16054    |   0.0 |  0.04
Output  | 0.00025167 | 0.00025167 | 0.00025167 |   0.0 |  0.00
Modify  | 0.74623    | 0.74623    | 0.74623    |   0.0 |  0.19
Other   |            | 0.1009     |            |       |  0.03

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

Total # of neighbors = 541174
Ave neighs/atom = 135.2935
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.208121839195, Press = 1.18329881814499
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17493.574     -17493.574     -17646.868     -17646.868      296.55737      296.55737      44124.917      44124.917     -25.194512     -25.194512    
     26000  -17496.154     -17496.154     -17645.355     -17645.355      288.63935      288.63935      44123.799      44123.799      49.550732      49.550732    
Loop time of 428.223 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.951 hours/ns, 2.335 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    | 427.11     | 427.11     | 427.11     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17049    | 0.17049    | 0.17049    |   0.0 |  0.04
Output  | 0.00018968 | 0.00018968 | 0.00018968 |   0.0 |  0.00
Modify  | 0.83028    | 0.83028    | 0.83028    |   0.0 |  0.19
Other   |            | 0.1072     |            |       |  0.03

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

Total # of neighbors = 541192
Ave neighs/atom = 135.298
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.159994818827, Press = 1.14961003105371
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17496.154     -17496.154     -17645.355     -17645.355      288.63935      288.63935      44123.799      44123.799      49.550732      49.550732    
     27000  -17495.221     -17495.221     -17648.269     -17648.269      296.08191      296.08191      44123.172      44123.172     -161.02679     -161.02679    
Loop time of 437.564 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.546 hours/ns, 2.285 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    | 436.44     | 436.44     | 436.44     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17167    | 0.17167    | 0.17167    |   0.0 |  0.04
Output  | 0.00023588 | 0.00023588 | 0.00023588 |   0.0 |  0.00
Modify  | 0.84293    | 0.84293    | 0.84293    |   0.0 |  0.19
Other   |            | 0.1076     |            |       |  0.02

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

Total # of neighbors = 541166
Ave neighs/atom = 135.2915
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.197938522018, Press = 0.9972985251959
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17495.221     -17495.221     -17648.269     -17648.269      296.08191      296.08191      44123.172      44123.172     -161.02679     -161.02679    
     28000  -17489.174     -17489.174     -17643.844     -17643.844      299.21981      299.21981      44141.889      44141.889     -404.17489     -404.17489    
Loop time of 436.978 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.383 hours/ns, 2.288 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    | 435.86     | 435.86     | 435.86     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17279    | 0.17279    | 0.17279    |   0.0 |  0.04
Output  | 0.00024306 | 0.00024306 | 0.00024306 |   0.0 |  0.00
Modify  | 0.83975    | 0.83975    | 0.83975    |   0.0 |  0.19
Other   |            | 0.1095     |            |       |  0.03

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

Total # of neighbors = 541042
Ave neighs/atom = 135.2605
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.235602439021, Press = 1.16030423954855
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17489.174     -17489.174     -17643.844     -17643.844      299.21981      299.21981      44141.889      44141.889     -404.17489     -404.17489    
     29000  -17496.404     -17496.404     -17646.517     -17646.517      290.40425      290.40425      44137.535      44137.535     -553.68869     -553.68869    
Loop time of 412.779 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.661 hours/ns, 2.423 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    | 411.73     | 411.73     | 411.73     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16285    | 0.16285    | 0.16285    |   0.0 |  0.04
Output  | 0.0002306  | 0.0002306  | 0.0002306  |   0.0 |  0.00
Modify  | 0.77966    | 0.77966    | 0.77966    |   0.0 |  0.19
Other   |            | 0.1045     |            |       |  0.03

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

Total # of neighbors = 541072
Ave neighs/atom = 135.268
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.271562950265, Press = 0.658711282689735
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17496.404     -17496.404     -17646.517     -17646.517      290.40425      290.40425      44137.535      44137.535     -553.68869     -553.68869    
     30000  -17489.702     -17489.702     -17643.247     -17643.247      297.04226      297.04226      44148.976      44148.976     -678.56972     -678.56972    
Loop time of 421.812 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.170 hours/ns, 2.371 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    | 420.72     | 420.72     | 420.72     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16813    | 0.16813    | 0.16813    |   0.0 |  0.04
Output  | 0.0002614  | 0.0002614  | 0.0002614  |   0.0 |  0.00
Modify  | 0.81232    | 0.81232    | 0.81232    |   0.0 |  0.19
Other   |            | 0.1068     |            |       |  0.03

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

Total # of neighbors = 540896
Ave neighs/atom = 135.224
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.344538421852, Press = -0.354983504647402
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17489.702     -17489.702     -17643.247     -17643.247      297.04226      297.04226      44148.976      44148.976     -678.56972     -678.56972    
     31000  -17495.577     -17495.577     -17645.311     -17645.311      289.66961      289.66961      44120.047      44120.047      217.94652      217.94652    
Loop time of 413.719 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.922 hours/ns, 2.417 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    | 412.67     | 412.67     | 412.67     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16351    | 0.16351    | 0.16351    |   0.0 |  0.04
Output  | 0.00019329 | 0.00019329 | 0.00019329 |   0.0 |  0.00
Modify  | 0.78408    | 0.78408    | 0.78408    |   0.0 |  0.19
Other   |            | 0.105      |            |       |  0.03

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

Total # of neighbors = 540974
Ave neighs/atom = 135.2435
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.367864978945, Press = -0.658189015163167
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17495.577     -17495.577     -17645.311     -17645.311      289.66961      289.66961      44120.047      44120.047      217.94652      217.94652    
     32000  -17496.14      -17496.14      -17647.572     -17647.572      292.9557       292.9557       44092.819      44092.819      1176.9545      1176.9545    
Loop time of 423.285 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.579 hours/ns, 2.362 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    | 422.2      | 422.2      | 422.2      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16833    | 0.16833    | 0.16833    |   0.0 |  0.04
Output  | 0.00019109 | 0.00019109 | 0.00019109 |   0.0 |  0.00
Modify  | 0.80964    | 0.80964    | 0.80964    |   0.0 |  0.19
Other   |            | 0.1068     |            |       |  0.03

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

Total # of neighbors = 541218
Ave neighs/atom = 135.3045
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.371339528567, Press = -0.515228294437598
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17496.14      -17496.14      -17647.572     -17647.572      292.9557       292.9557       44092.819      44092.819      1176.9545      1176.9545    
     33000  -17492.249     -17492.249     -17644.903     -17644.903      295.31843      295.31843      44075.246      44075.246      2154.3683      2154.3683    
Loop time of 428.473 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 119.020 hours/ns, 2.334 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    | 427.36     | 427.36     | 427.36     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17304    | 0.17304    | 0.17304    |   0.0 |  0.04
Output  | 0.00019077 | 0.00019077 | 0.00019077 |   0.0 |  0.00
Modify  | 0.82592    | 0.82592    | 0.82592    |   0.0 |  0.19
Other   |            | 0.1089     |            |       |  0.03

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

Total # of neighbors = 541274
Ave neighs/atom = 135.3185
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.351197482704, Press = 0.037475559423573
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17492.249     -17492.249     -17644.903     -17644.903      295.31843      295.31843      44075.246      44075.246      2154.3683      2154.3683    
     34000  -17497.524     -17497.524     -17646.302     -17646.302      287.81987      287.81987      44070.305      44070.305      2164.024       2164.024     
Loop time of 396.33 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 110.092 hours/ns, 2.523 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    | 395.33     | 395.33     | 395.33     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16037    | 0.16037    | 0.16037    |   0.0 |  0.04
Output  | 0.00019827 | 0.00019827 | 0.00019827 |   0.0 |  0.00
Modify  | 0.74215    | 0.74215    | 0.74215    |   0.0 |  0.19
Other   |            | 0.1003     |            |       |  0.03

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

Total # of neighbors = 541354
Ave neighs/atom = 135.3385
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.365628243132, Press = 1.263410190554
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17497.524     -17497.524     -17646.302     -17646.302      287.81987      287.81987      44070.305      44070.305      2164.024       2164.024     
     35000  -17489.882     -17489.882     -17644.59      -17644.59       299.29309      299.29309      44114.854      44114.854      676.3523       676.3523     
Loop time of 415.183 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.329 hours/ns, 2.409 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    | 414.11     | 414.11     | 414.11     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16759    | 0.16759    | 0.16759    |   0.0 |  0.04
Output  | 0.00023451 | 0.00023451 | 0.00023451 |   0.0 |  0.00
Modify  | 0.80127    | 0.80127    | 0.80127    |   0.0 |  0.19
Other   |            | 0.1057     |            |       |  0.03

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

Total # of neighbors = 541364
Ave neighs/atom = 135.341
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.382051863782, Press = 1.46745083581693
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17489.882     -17489.882     -17644.59      -17644.59       299.29309      299.29309      44114.854      44114.854      676.3523       676.3523     
     36000  -17496.345     -17496.345     -17647.456     -17647.456      292.33584      292.33584      44110.891      44110.891      417.79956      417.79956    
Loop time of 413.953 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.987 hours/ns, 2.416 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    | 412.88     | 412.88     | 412.88     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17136    | 0.17136    | 0.17136    |   0.0 |  0.04
Output  | 0.00019126 | 0.00019126 | 0.00019126 |   0.0 |  0.00
Modify  | 0.79811    | 0.79811    | 0.79811    |   0.0 |  0.19
Other   |            | 0.1055     |            |       |  0.03

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

Total # of neighbors = 541118
Ave neighs/atom = 135.2795
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.421607214103, Press = 1.41607647127789
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17496.345     -17496.345     -17647.456     -17647.456      292.33584      292.33584      44110.891      44110.891      417.79956      417.79956    
     37000  -17493.395     -17493.395     -17646.832     -17646.832      296.83439      296.83439      44132.618      44132.618     -427.12098     -427.12098    
Loop time of 386.738 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.427 hours/ns, 2.586 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    | 385.77     | 385.77     | 385.77     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15249    | 0.15249    | 0.15249    |   0.0 |  0.04
Output  | 0.00024423 | 0.00024423 | 0.00024423 |   0.0 |  0.00
Modify  | 0.71591    | 0.71591    | 0.71591    |   0.0 |  0.19
Other   |            | 0.1006     |            |       |  0.03

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

Total # of neighbors = 541156
Ave neighs/atom = 135.289
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.398540643307, Press = 1.48728847392086
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17493.395     -17493.395     -17646.832     -17646.832      296.83439      296.83439      44132.618      44132.618     -427.12098     -427.12098    
     38000  -17493.236     -17493.236     -17645.838     -17645.838      295.21837      295.21837      44161.169      44161.169     -1491.5554     -1491.5554    
Loop time of 399.9 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.083 hours/ns, 2.501 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    | 398.9      | 398.9      | 398.9      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15887    | 0.15887    | 0.15887    |   0.0 |  0.04
Output  | 0.00019145 | 0.00019145 | 0.00019145 |   0.0 |  0.00
Modify  | 0.74395    | 0.74395    | 0.74395    |   0.0 |  0.19
Other   |            | 0.1013     |            |       |  0.03

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

Total # of neighbors = 541086
Ave neighs/atom = 135.2715
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.388587812704, Press = 1.46823722217639
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17493.236     -17493.236     -17645.838     -17645.838      295.21837      295.21837      44161.169      44161.169     -1491.5554     -1491.5554    
     39000  -17497.886     -17497.886     -17647.657     -17647.657      289.74185      289.74185      44200.252      44200.252     -3342.2323     -3342.2323    
Loop time of 413.33 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.814 hours/ns, 2.419 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    | 412.28     | 412.28     | 412.28     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16233    | 0.16233    | 0.16233    |   0.0 |  0.04
Output  | 0.00019209 | 0.00019209 | 0.00019209 |   0.0 |  0.00
Modify  | 0.78569    | 0.78569    | 0.78569    |   0.0 |  0.19
Other   |            | 0.1033     |            |       |  0.02

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

Total # of neighbors = 540858
Ave neighs/atom = 135.2145
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.320806998404, Press = 0.533953347346516
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17497.886     -17497.886     -17647.657     -17647.657      289.74185      289.74185      44200.252      44200.252     -3342.2323     -3342.2323    
     40000  -17495.009     -17495.009     -17644.291     -17644.291      288.79639      288.79639      44168.452      44168.452     -1652.2477     -1652.2477    
Loop time of 411.719 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.366 hours/ns, 2.429 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    | 410.68     | 410.68     | 410.68     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15975    | 0.15975    | 0.15975    |   0.0 |  0.04
Output  | 0.00024726 | 0.00024726 | 0.00024726 |   0.0 |  0.00
Modify  | 0.77367    | 0.77367    | 0.77367    |   0.0 |  0.19
Other   |            | 0.1044     |            |       |  0.03

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

Total # of neighbors = 540716
Ave neighs/atom = 135.179
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.308444312238, Press = -0.268626903082964
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17495.009     -17495.009     -17644.291     -17644.291      288.79639      288.79639      44168.452      44168.452     -1652.2477     -1652.2477    
     41000  -17490.687     -17490.687     -17642.653     -17642.653      293.98871      293.98871      44148.226      44148.226     -660.7862      -660.7862     
Loop time of 429.23 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.231 hours/ns, 2.330 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    | 428.11     | 428.11     | 428.11     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17482    | 0.17482    | 0.17482    |   0.0 |  0.04
Output  | 0.00028491 | 0.00028491 | 0.00028491 |   0.0 |  0.00
Modify  | 0.8365     | 0.8365     | 0.8365     |   0.0 |  0.19
Other   |            | 0.1067     |            |       |  0.02

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

Total # of neighbors = 540888
Ave neighs/atom = 135.222
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
44123.2567228552

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0